Your Data Privacy & Security

# Current Medical Document Processing - Production Implementation
# PDF Processing: PyMuPDF (medical-grade, used by healthcare institutions)
def extract_text_from_pdf(file_path: str) -> str:
    """Extract text from PDF with enhanced error handling"""
    try:
        doc = fitz.open(file_path)  # PyMuPDF - industry standard
        text = ""
        for page_num, page in enumerate(doc):
            page_text = page.get_text()
            text += page_text
            logger.debug(f"Extracted {len(page_text)} chars from page {page_num + 1}")
        doc.close()

        if len(text.strip()) < 50:
            raise ValueError("PDF contains too little readable text")

        return text.strip()
    except Exception as e:
        logger.error(f"PDF extraction error: {e}")
        raise

# Enhanced Medical Image OCR: Multi-strategy Tesseract
def extract_text_from_image_enhanced(file_path: str) -> str:
    """Enhanced OCR with multiple strategies for medical documents"""
    try:
        image = Image.open(file_path)
        if image.mode != 'RGB':
            image = image.convert('RGB')  # Normalize for OCR

        # Multiple OCR strategies optimized for medical text
        strategies = [
            {'config': r'--oem 3 --psm 6', 'desc': 'Default medical'},
            {'config': r'--oem 3 --psm 3', 'desc': 'Fully automatic'},
            {'config': r'--oem 3 --psm 4', 'desc': 'Single column'},
        ]

        best_text = ""
        best_word_count = 0

        for strategy in strategies:
            try:
                text = pytesseract.image_to_string(image, config=strategy['config'])
                word_count = len(text.split())

                if word_count > best_word_count:
                    best_text = text
                    best_word_count = word_count

                logger.info(f"OCR {strategy['desc']}: {word_count} words extracted")
            except Exception as e:
                logger.warning(f"OCR strategy {strategy['desc']} failed: {e}")

        if best_word_count < 10:
            raise ValueError("Could not extract sufficient text from image")

        return best_text.strip()
    except Exception as e:
        logger.error(f"Image OCR error: {e}")
        raise

# Word Document Processing: Enhanced table extraction
def extract_text_from_docx(file_path: str) -> str:
    """Extract text from Word documents with table support"""
    try:
        doc = Document(file_path)
        text = ""

        # Extract from paragraphs (preserving medical report structure)
        for paragraph in doc.paragraphs:
            text += paragraph.text + "\n"

        # Extract from tables (critical for lab reports)
        for table in doc.tables:
            for row in table.rows:
                for cell in row.cells:
                    text += cell.text + "\t"
                text += "\n"

        if len(text.strip()) < 50:
            raise ValueError("Document contains too little text")

        return text.strip()
    except Exception as e:
        logger.error(f"DOCX extraction error: {e}")
        raise

# Main text extraction pipeline with comprehensive error handling
async def extract_text_from_file(file_path: Path, content_type: str) -> str:
    """Extract text from various file formats with medical document optimization"""
    try:
        if content_type == "application/pdf":
            return extract_text_from_pdf(str(file_path))
        elif content_type.startswith("image/"):
            return extract_text_from_image_enhanced(str(file_path))
        elif content_type == "text/plain":
            with open(file_path, "r", encoding="utf-8") as f:
                return f.read()
        elif "wordprocessingml" in content_type:
            return extract_text_from_docx(str(file_path))
        else:
            raise ValueError(f"Unsupported file type: {content_type}")
    except Exception as e:
        logger.error(f"Text extraction failed: {e}")
        raise HTTPException(status_code=400, detail=f"Failed to extract text: {str(e)}")

# Current Medical Analysis Engine - Production Implementation
async def analyze_with_openai(text: str, language: str) -> str:
    """Analyze medical text with OpenAI Enterprise API"""
    if not openai_client:
        raise HTTPException(status_code=503, detail="AI service not available")

    try:
        logger.info(f"Starting OpenAI analysis for {len(text)} chars in {language}")

        # Use OpenAI Enterprise API with medical-specific prompt
        response = openai_client.chat.completions.create(
            model=settings.openai_model,  # GPT-4 for medical accuracy
            messages=[
                {
                    "role": "system",
                    "content": "You are a medical AI assistant specialized in explaining medical reports clearly."
                },
                {
                    "role": "user",
                    "content": MEDICAL_ANALYSIS_PROMPT.format(
                        language=language,
                        report_text=text
                    )
                }
            ],
            max_tokens=settings.openai_max_tokens,  # 4000 tokens for comprehensive analysis
            temperature=0.3,  # Low temperature for consistent medical explanations
        )

        analysis = response.choices[0].message.content
        logger.info(f"Analysis completed: {len(analysis)} characters")
        return analysis

    except Exception as e:
        logger.error(f"OpenAI analysis error: {e}")
        raise HTTPException(status_code=500, detail="Analysis service error")

# Medical Analysis Prompt Template (Structured for 65+ Languages)
MEDICAL_ANALYSIS_PROMPT = """You are a medical AI assistant helping patients understand their medical reports.
Analyze the following medical report and provide a clear, comprehensive explanation in {language}.

IMPORTANT GUIDELINES:
1. Use simple, everyday language that non-medical people can understand
2. Explain all medical terms in parentheses when first used
3. Be reassuring when results are normal, honest but gentle when they're not
4. Focus on what the patient needs to know and do
5. Never diagnose or recommend specific treatments
6. Always emphasize this is educational information only

Structure your response EXACTLY as follows:

**EXECUTIVE SUMMARY**
[2-3 sentences summarizing the overall report findings in very simple terms]

**DETAILED FINDINGS**
[For each test/measurement in the report with normal ranges and interpretations]

**WHAT YOUR RESULTS MEAN**
[Practical implications for the patient's health in everyday language]

**AREAS THAT LOOK GOOD** ✓
[List all normal/healthy findings for reassurance]

**AREAS TO DISCUSS WITH YOUR DOCTOR** ⚠️
[Any abnormal findings requiring follow-up]

**QUESTIONS TO ASK YOUR DOCTOR**
[3-5 specific questions based on report findings]

**MEDICAL TERMS GLOSSARY** 📖
[Every medical term with simple definitions]

Medical Report Content:
{report_text}

Remember: Translate everything into {language}, keep explanations simple, be empathetic"""

# Multi-language medical terminology support (65+ languages)
SUPPORTED_LANGUAGES = [
    "English", "Spanish", "French", "German", "Italian", "Portuguese", "Dutch",
    "Russian", "Chinese (Mandarin)", "Japanese", "Korean", "Arabic", "Hindi",
    "Bengali", "Punjabi", "Telugu", "Marathi", "Tamil", "Urdu", "Gujarati",
    "Malayalam", "Kannada", "Odia", "Vietnamese", "Thai", "Turkish", "Polish",
    # ... 65+ languages total with proper medical terminology context
]

# Current Implementation: Dual Cleanup System for Maximum Privacy
@app.post("/api/analyze")
async def analyze_report(request: AnalysisRequest):
    try:
        # ... file loading and analysis code ...
        
        # Extract text and analyze with AI
        text_content = await extract_text_from_file(file_path, content_type)
        analysis = await analyze_with_openai(text_content, request.language)
        
        # IMMEDIATE CLEANUP #1: Delete files right after analysis
        try:
            upload_dir = Path(tempfile.gettempdir()) / "medgpt_uploads" / request.session_id
            shutil.rmtree(upload_dir)  # Permanent deletion from filesystem
            logger.info(f"Cleaned up session {request.session_id} after analysis")
        except Exception as e:
            logger.warning(f"Immediate cleanup failed: {e}")
        
        return AnalysisResponse(success=True, analysis=analysis)
    
    except HTTPException:
        raise
    except Exception as e:
        # Even if analysis fails, still attempt cleanup
        try:
            upload_dir = Path(tempfile.gettempdir()) / "medgpt_uploads" / request.session_id
            if upload_dir.exists():
                shutil.rmtree(upload_dir)
        except:
            pass
        logger.error(f"Analysis error: {e}")
        raise HTTPException(500, "Analysis failed")

# SCHEDULED CLEANUP #2: Automatic cleanup manager (24-hour guarantee)
class FileCleanupManager:
    def __init__(self):
        self.cleanup_tasks: Dict[str, asyncio.Task] = {}

    async def schedule_cleanup(self, session_id: str, delay_hours: int = 24):
        """Schedule file deletion after delay - PRIVACY GUARANTEE"""
        async def cleanup():
            await asyncio.sleep(delay_hours * 3600)  # Wait 24 hours
            try:
                upload_dir = Path(tempfile.gettempdir()) / "medgpt_uploads" / session_id
                if upload_dir.exists():
                    shutil.rmtree(upload_dir)  # Permanent deletion
                    logger.info(f"Scheduled cleanup completed for {session_id} after {delay_hours} hours")
            except Exception as e:
                logger.error(f"Scheduled cleanup failed for {session_id}: {e}")

        # Create background task
        task = asyncio.create_task(cleanup())
        self.cleanup_tasks[session_id] = task

cleanup_manager = FileCleanupManager()

# Cleanup scheduled immediately on upload
@app.post("/api/upload")
async def upload_file(file: UploadFile = File(...)):
    # ... file upload logic ...
    
    # PRIVACY: Schedule cleanup as soon as file is uploaded
    await cleanup_manager.schedule_cleanup(session_id, settings.cleanup_delay_hours)
    
    return {"success": True, "session_id": session_id, "preview": preview}

# Application shutdown: Cancel all pending cleanups
@asynccontextmanager
async def lifespan(app: FastAPI):
    logger.info("MedGPT Backend starting")
    yield
    logger.info("MedGPT Backend shutting down")
    # Cancel all cleanup tasks on shutdown
    for task in cleanup_manager.cleanup_tasks.values():
        task.cancel()

# Current Production Privacy Implementation
class Settings(BaseSettings):
    cleanup_delay_hours: int = 24  # Maximum file retention
    max_file_size: int = 10_485_760  # 10MB security limit
    environment: str = "production"
    
    @property
    def allowed_origins(self) -> List[str]:
        """Secure CORS origins for production"""
        return [
            "https://medgpt.me",
            "https://www.medgpt.me", 
            "https://medgpt-nextjs.vercel.app"
        ]

# Security features implemented:
def sanitize_filename(filename: str) -> str:
    """Sanitize filename for security - prevent directory traversal"""
    filename = re.sub(r'[^\w\s.\-]', '', filename).strip()
    filename = re.sub(r'[\-\s]+', '-', filename)
    return filename

def validate_file_type(content_type: str) -> bool:
    """Validate file type - only allow safe medical document types"""
    allowed_types = {
        "application/pdf", "image/jpeg", "image/png", 
        "text/plain", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
    }
    return content_type in allowed_types

# Comprehensive logging for security auditing
logger.info(f"File uploaded: session={session_id}, file={filename}")
logger.info(f"Analysis completed: {len(analysis)} characters")
logger.info(f"Cleaned up session {session_id} after analysis")

# Settings loaded securely from environment
settings = Settings()  # Automatically loads from .env with validation