src/file_processor.py

"""
Local Processor for FhirFlame Development
Core logic with optional Mistral API OCR and multimodal fallbacks
"""

import asyncio
import json
import uuid
import os
import io
import base64
from datetime import datetime
from typing import Dict, Any, Optional, List
from .monitoring import monitor

# PDF and Image Processing
try:
    from pdf2image import convert_from_bytes
    from PIL import Image
    import PyPDF2
    PDF_PROCESSING_AVAILABLE = True
except ImportError:
    PDF_PROCESSING_AVAILABLE = False

class LocalProcessor:
    """Local processor with optional external fallbacks"""
    
    def __init__(self):
        self.use_mistral_fallback = os.getenv("USE_MISTRAL_FALLBACK", "false").lower() == "true"
        self.use_multimodal_fallback = os.getenv("USE_MULTIMODAL_FALLBACK", "false").lower() == "true"
        self.mistral_api_key = os.getenv("MISTRAL_API_KEY")
        
    @monitor.track_operation("real_document_processing")
    async def process_document(self, document_bytes: bytes, user_id: str, filename: str) -> Dict[str, Any]:
        """Process document with fallback capabilities and quality assertions"""
        
        # Try external OCR if enabled and available
        extracted_text = await self._extract_text_with_fallback(document_bytes, filename)
        
        # Log OCR quality metrics
        monitor.log_event("ocr_text_extracted", {
            "text_extracted": len(extracted_text) > 0,
            "text_length": len(extracted_text),
            "filename": filename
        })
        monitor.log_event("ocr_minimum_length", {
            "substantial_text": len(extracted_text) > 50,
            "text_length": len(extracted_text)
        })
        
        # Extract medical entities from text
        entities = self._extract_medical_entities(extracted_text)
        
        # Log medical entity extraction
        monitor.log_event("medical_entities_found", {
            "entities_found": len(entities) > 0,
            "entity_count": len(entities)
        })
        
        # Create FHIR bundle
        fhir_bundle = self._create_simple_fhir_bundle(entities, user_id)
        
        # Log FHIR validation
        monitor.log_event("fhir_bundle_valid", {
            "bundle_valid": fhir_bundle.get("resourceType") == "Bundle",
            "resource_type": fhir_bundle.get("resourceType")
        })
        monitor.log_event("fhir_has_entries", {
            "has_entries": len(fhir_bundle.get("entry", [])) > 0,
            "entry_count": len(fhir_bundle.get("entry", []))
        })
        
        # Log processing with enhanced metrics
        monitor.log_medical_processing(
            entities_found=len(entities),
            confidence=0.85,
            processing_time=100.0,
            processing_mode="file_processing",
            model_used="enhanced_processor"
        )
        
        return {
            "status": "success",
            "processing_mode": self._get_processing_mode(),
            "filename": filename,
            "processed_by": user_id,
            "entities_found": len(entities),
            "fhir_bundle": fhir_bundle,
            "extracted_text": extracted_text[:500] + "..." if len(extracted_text) > 500 else extracted_text,
            "text_length": len(extracted_text)
        }
    
    async def _extract_text_with_fallback(self, document_bytes: bytes, filename: str) -> str:
        """Extract text with optional fallbacks"""
        
        # Try Mistral API OCR first if enabled
        if self.use_mistral_fallback and self.mistral_api_key:
            try:
                monitor.log_event("mistral_attempt_start", {
                    "document_size": len(document_bytes),
                    "api_key_present": bool(self.mistral_api_key),
                    "use_mistral_fallback": self.use_mistral_fallback
                })
                result = await self._extract_with_mistral(document_bytes)
                monitor.log_event("mistral_success_in_fallback", {
                    "text_length": len(result),
                    "text_preview": result[:100] + "..." if len(result) > 100 else result
                })
                return result
            except Exception as e:
                import traceback
                monitor.log_event("mistral_fallback_failed", {
                    "error": str(e),
                    "error_type": type(e).__name__,
                    "traceback": traceback.format_exc(),
                    "document_size": len(document_bytes),
                    "api_key_format": f"{self.mistral_api_key[:8]}...{self.mistral_api_key[-4:]}" if self.mistral_api_key else "none"
                })
                print(f"🚨 MISTRAL API FAILED: {type(e).__name__}: {str(e)}")
                print(f"🚨 Full traceback: {traceback.format_exc()}")
        
        # Try multimodal processor if enabled
        if self.use_multimodal_fallback:
            try:
                return await self._extract_with_multimodal(document_bytes)
            except Exception as e:
                monitor.log_event("multimodal_fallback_failed", {"error": str(e)})
        
        # CRITICAL: No dummy data in production - fail properly when OCR fails
        raise Exception(f"Document text extraction failed for {filename}. All OCR methods exhausted. Cannot return dummy data for real medical processing.")
    
    def _convert_pdf_to_images(self, pdf_bytes: bytes) -> List[bytes]:
        """Convert PDF to list of image bytes for Mistral vision processing"""
        if not PDF_PROCESSING_AVAILABLE:
            raise Exception("PDF processing libraries not available. Install pdf2image, Pillow, and PyPDF2.")
        
        try:
            # Convert PDF pages to PIL Images
            monitor.log_event("pdf_conversion_debug", {
                "step": "starting_pdf_conversion",
                "pdf_size": len(pdf_bytes)
            })
            
            # Convert PDF to images (300 DPI for good OCR quality)
            images = convert_from_bytes(pdf_bytes, dpi=300, fmt='PNG')
            
            monitor.log_event("pdf_conversion_debug", {
                "step": "pdf_converted_to_images",
                "page_count": len(images),
                "image_sizes": [(img.width, img.height) for img in images]
            })
            
            # Convert PIL Images to bytes
            image_bytes_list = []
            for i, img in enumerate(images):
                # Convert to RGB if necessary (for JPEG compatibility)
                if img.mode != 'RGB':
                    img = img.convert('RGB')
                
                # Save as high-quality JPEG bytes
                img_byte_arr = io.BytesIO()
                img.save(img_byte_arr, format='JPEG', quality=95)
                img_bytes = img_byte_arr.getvalue()
                image_bytes_list.append(img_bytes)
                
                monitor.log_event("pdf_conversion_debug", {
                    "step": f"page_{i+1}_converted",
                    "page_size": len(img_bytes),
                    "dimensions": f"{img.width}x{img.height}"
                })
            
            monitor.log_event("pdf_conversion_success", {
                "total_pages": len(image_bytes_list),
                "total_size": sum(len(img_bytes) for img_bytes in image_bytes_list)
            })
            
            return image_bytes_list
            
        except Exception as e:
            monitor.log_event("pdf_conversion_error", {
                "error": str(e),
                "error_type": type(e).__name__
            })
            raise Exception(f"PDF to image conversion failed: {str(e)}")

    async def _extract_with_mistral(self, document_bytes: bytes) -> str:
        """Extract text using Mistral OCR API - using proper document understanding endpoint"""
        import httpx
        import base64
        import tempfile
        import os
        
        # 🔍 DEBUGGING: Log entry to Mistral OCR function
        monitor.log_event("mistral_ocr_start", {
            "document_size": len(document_bytes),
            "api_key_present": bool(self.mistral_api_key),
            "api_key_format": f"sk-...{self.mistral_api_key[-4:]}" if self.mistral_api_key else "none"
        })
        
        # Detect file type and extension
        def detect_file_info(data: bytes) -> tuple[str, str]:
            if data.startswith(b'%PDF'):
                return "application/pdf", ".pdf"
            elif data.startswith(b'\xff\xd8\xff'):  # JPEG
                return "image/jpeg", ".jpg"
            elif data.startswith(b'\x89PNG\r\n\x1a\n'):  # PNG
                return "image/png", ".png"
            elif data.startswith(b'GIF87a') or data.startswith(b'GIF89a'):  # GIF
                return "image/gif", ".gif"
            elif data.startswith(b'BM'):  # BMP
                return "image/bmp", ".bmp"
            elif data.startswith(b'RIFF') and b'WEBP' in data[:12]:  # WEBP
                return "image/webp", ".webp"
            elif data.startswith(b'II*\x00') or data.startswith(b'MM\x00*'):  # TIFF
                return "image/tiff", ".tiff"
            elif data.startswith(b'\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1'):  # DOC (OLE2)
                return "application/msword", ".doc"
            elif data.startswith(b'PK\x03\x04') and b'word/' in data[:1000]:  # DOCX
                return "application/vnd.openxmlformats-officedocument.wordprocessingml.document", ".docx"
            else:
                return "application/pdf", ".pdf"
        
        mime_type, file_ext = detect_file_info(document_bytes)
        
        # 🔍 DEBUGGING: Log document analysis
        monitor.log_event("mistral_ocr_debug", {
            "step": "document_analysis",
            "mime_type": mime_type,
            "file_extension": file_ext,
            "document_size": len(document_bytes),
            "document_start": document_bytes[:100].hex()[:50] + "..." if len(document_bytes) > 50 else document_bytes.hex()
        })
        
        try:
            # 🔍 DEBUGGING: Log exact HTTP request details
            monitor.log_event("mistral_http_debug", {
                "step": "preparing_http_client",
                "api_endpoint": "https://api.mistral.ai/v1/chat/completions",
                "api_key_prefix": f"{self.mistral_api_key[:8]}..." if self.mistral_api_key else "none",
                "timeout": 180.0,
                "client_config": "httpx.AsyncClient() with default settings"
            })
            
            async with httpx.AsyncClient() as client:
                
                # Handle PDF conversion to images
                if mime_type == "application/pdf":
                    monitor.log_event("mistral_ocr_debug", {
                        "step": "pdf_detected_converting_to_images",
                        "pdf_size": len(document_bytes)
                    })
                    
                    # Convert PDF to images
                    try:
                        image_bytes_list = self._convert_pdf_to_images(document_bytes)
                        monitor.log_event("mistral_ocr_debug", {
                            "step": "pdf_conversion_success",
                            "page_count": len(image_bytes_list)
                        })
                    except Exception as pdf_error:
                        monitor.log_event("mistral_ocr_debug", {
                            "step": "pdf_conversion_failed",
                            "error": str(pdf_error)
                        })
                        raise Exception(f"PDF conversion failed: {str(pdf_error)}")
                    
                    # Process each page and combine results
                    all_extracted_text = []
                    
                    for page_num, image_bytes in enumerate(image_bytes_list, 1):
                        monitor.log_event("mistral_ocr_debug", {
                            "step": f"processing_page_{page_num}",
                            "image_size": len(image_bytes)
                        })
                        
                        # Convert image to base64
                        b64_data = base64.b64encode(image_bytes).decode()
                        
                        # 🔍 DEBUGGING: Log exact HTTP request details
                        request_payload = {
                            "model": "pixtral-12b-2409",
                            "messages": [
                                {
                                    "role": "user",
                                    "content": [
                                        {
                                            "type": "text",
                                            "text": f"""You are a strict OCR text extraction tool. Your job is to extract ONLY the actual text that appears in this image - nothing more, nothing less.
        
        CRITICAL RULES:
        - Extract ONLY text that is actually visible in the image
        - Do NOT generate, invent, or create any content
        - Do NOT add examples or sample data
        - Do NOT fill in missing information
        - If the image contains minimal text, return minimal text
        - If the image is blank or contains no medical content, return what you actually see
        
        For page {page_num}, extract exactly what text appears in this image:"""
                                        },
                                        {
                                            "type": "image_url",
                                            "image_url": {
                                                "url": f"data:image/jpeg;base64,{b64_data[:50]}..."  # Truncated for logging
                                            }
                                        }
                                    ]
                                }
                            ],
                            "max_tokens": 8000,
                            "temperature": 0.0
                        }
                        
                        monitor.log_event("mistral_http_request_start", {
                            "step": f"sending_request_page_{page_num}",
                            "url": "https://api.mistral.ai/v1/chat/completions",
                            "method": "POST",
                            "headers_count": 2,
                            "payload_size": len(str(request_payload)),
                            "b64_data_size": len(b64_data),
                            "timeout": min(300.0, 60.0 + (len(b64_data) / 100000)),  # Dynamic timeout: 60s base + 1s per 100KB
                            "estimated_timeout": min(300.0, 60.0 + (len(b64_data) / 100000))
                        })
                        
                        # Calculate dynamic timeout based on image size
                        dynamic_timeout = min(300.0, 60.0 + (len(b64_data) / 100000))  # Max 5 minutes
                        
                        
                        # API call for this page with dynamic timeout
                        response = await client.post(
                            "https://api.mistral.ai/v1/chat/completions",
                            headers={
                                "Authorization": f"Bearer {self.mistral_api_key}",
                                "Content-Type": "application/json"
                            },
                            json={
                                "model": "pixtral-12b-2409",
                                "messages": [
                                    {
                                        "role": "user",
                                        "content": [
                                            {
                                                "type": "text",
                                                "text": f"""You are a strict OCR text extraction tool. Your job is to extract ONLY the actual text that appears in this image - nothing more, nothing less.
        
        CRITICAL RULES:
        - Extract ONLY text that is actually visible in the image
        - Do NOT generate, invent, or create any content
        - Do NOT add examples or sample data
        - Do NOT fill in missing information
        - If the image contains minimal text, return minimal text
        - If the image is blank or contains no medical content, return what you actually see
        
        For page {page_num}, extract exactly what text appears in this image:"""
                                            },
                                            {
                                                "type": "image_url",
                                                "image_url": {
                                                    "url": f"data:image/jpeg;base64,{b64_data}"
                                                }
                                            }
                                        ]
                                    }
                                ],
                                "max_tokens": 8000,
                                "temperature": 0.0
                            },
                            timeout=dynamic_timeout
                        )
                        
                        monitor.log_event("mistral_http_response_received", {
                            "step": f"response_page_{page_num}",
                            "status_code": response.status_code,
                            "response_size": len(response.content),
                            "headers": dict(response.headers),
                            "elapsed_seconds": response.elapsed.total_seconds() if hasattr(response, 'elapsed') else "unknown"
                        })
                        
                        # Process response for this page
                        monitor.log_event("mistral_ocr_debug", {
                            "step": f"page_{page_num}_api_response",
                            "status_code": response.status_code
                        })
                        
                        if response.status_code == 200:
                            result = response.json()
                            if 'choices' in result and len(result['choices']) > 0:
                                message = result['choices'][0].get('message', {})
                                page_text = message.get('content', '').strip()
                                if page_text:
                                    cleaned_text = self._clean_ocr_text(page_text)
                                    all_extracted_text.append(f"[PAGE {page_num}]\n{cleaned_text}")
                                    
                                    monitor.log_event("mistral_ocr_debug", {
                                        "step": f"page_{page_num}_extracted",
                                        "text_length": len(cleaned_text)
                                    })
                        else:
                            monitor.log_event("mistral_ocr_debug", {
                                "step": f"page_{page_num}_api_error",
                                "status_code": response.status_code,
                                "error": response.text
                            })
                            # Continue with other pages even if one fails
                    
                    # Combine all pages
                    if all_extracted_text:
                        combined_text = "\n\n".join(all_extracted_text)
                        monitor.log_event("mistral_ocr_success", {
                            "mime_type": mime_type,
                            "total_pages": len(image_bytes_list),
                            "pages_processed": len(all_extracted_text),
                            "total_text_length": len(combined_text)
                        })
                        return f"[MISTRAL PDF PROCESSED - {len(image_bytes_list)} pages]\n\n{combined_text}"
                    else:
                        raise Exception("No text extracted from any PDF pages")
                
                else:
                    # Handle non-PDF documents (images) - original logic
                    b64_data = base64.b64encode(document_bytes).decode()
                    b64_preview = b64_data[:100] + "..." if len(b64_data) > 100 else b64_data
                    
                    monitor.log_event("mistral_ocr_debug", {
                        "step": "api_call_preparation",
                        "b64_data_length": len(b64_data),
                        "b64_preview": b64_preview,
                        "api_endpoint": "https://api.mistral.ai/v1/chat/completions",
                        "model": "pixtral-12b-2409"
                    })
                    
                    # Calculate dynamic timeout based on image size
                    dynamic_timeout = min(300.0, 60.0 + (len(b64_data) / 100000))  # Max 5 minutes
                    
                    monitor.log_event("mistral_http_request_start", {
                        "step": "sending_request_image",
                        "url": "https://api.mistral.ai/v1/chat/completions",
                        "method": "POST",
                        "mime_type": mime_type,
                        "b64_data_size": len(b64_data),
                        "timeout": dynamic_timeout,
                        "estimated_timeout": dynamic_timeout
                    })
                    
                    
                    response = await client.post(
                        "https://api.mistral.ai/v1/chat/completions",
                        headers={
                            "Authorization": f"Bearer {self.mistral_api_key}",
                            "Content-Type": "application/json"
                        },
                        json={
                            "model": "pixtral-12b-2409",
                            "messages": [
                                {
                                    "role": "user",
                                    "content": [
                                        {
                                            "type": "text",
                                            "text": """You are a strict OCR text extraction tool. Your job is to extract ONLY the actual text that appears in this image - nothing more, nothing less.

CRITICAL RULES:
- Extract ONLY text that is actually visible in the image
- Do NOT generate, invent, or create any content
- Do NOT add examples or sample data
- Do NOT fill in missing information
- If the image contains minimal text, return minimal text
- If the image is blank or contains no medical content, return what you actually see

Extract exactly what text appears in this image:"""
                                        },
                                        {
                                            "type": "image_url",
                                            "image_url": {
                                                "url": f"data:{mime_type};base64,{b64_data}"
                                            }
                                        }
                                    ]
                                }
                            ],
                            "max_tokens": 8000,
                            "temperature": 0.0
                        },
                        timeout=dynamic_timeout
                    )
                    
                    monitor.log_event("mistral_http_response_received", {
                        "step": "response_image",
                        "status_code": response.status_code,
                        "response_size": len(response.content),
                        "headers": dict(response.headers),
                        "elapsed_seconds": response.elapsed.total_seconds() if hasattr(response, 'elapsed') else "unknown"
                    })
                
                # 🔍 DEBUGGING: Log API response
                monitor.log_event("mistral_ocr_debug", {
                    "step": "api_response_received",
                    "status_code": response.status_code,
                    "response_headers": dict(response.headers),
                    "response_size": len(response.content),
                    "response_preview": response.text[:500] + "..." if len(response.text) > 500 else response.text
                })
                
                if response.status_code == 200:
                    result = response.json()
                    
                    # 🔍 DEBUGGING: Log successful response parsing
                    monitor.log_event("mistral_ocr_debug", {
                        "step": "response_parsing_success",
                        "result_keys": list(result.keys()) if isinstance(result, dict) else "not_dict",
                        "choices_count": len(result.get("choices", [])) if isinstance(result, dict) else 0
                    })
                    
                    # Log successful API response
                    monitor.log_event("mistral_api_success", {
                        "status_code": response.status_code,
                        "response_format": "valid"
                    })
                    
                    # Extract text from Mistral chat completion response
                    if 'choices' in result and len(result['choices']) > 0:
                        message = result['choices'][0].get('message', {})
                        extracted_text = message.get('content', '').strip()
                        
                        # Log OCR quality
                        monitor.log_event("mistral_response_has_content", {
                            "has_content": len(extracted_text) > 0,
                            "text_length": len(extracted_text)
                        })
                        
                        if extracted_text:
                            # Clean up the response - remove any OCR processing artifacts
                            cleaned_text = self._clean_ocr_text(extracted_text)
                            
                            # Log cleaned text quality
                            monitor.log_event("mistral_cleaned_text_substantial", {
                                "substantial": len(cleaned_text) > 20,
                                "text_length": len(cleaned_text)
                            })
                            
                            # Log successful OCR metrics
                            monitor.log_event("mistral_ocr_success", {
                                "mime_type": mime_type,
                                "raw_length": len(extracted_text),
                                "cleaned_length": len(cleaned_text),
                                "cleaning_ratio": len(cleaned_text) / len(extracted_text) if extracted_text else 0
                            })
                            
                            return f"[MISTRAL DOCUMENT AI PROCESSED - {mime_type}]\n\n{cleaned_text}"
                        else:
                            monitor.log_event("mistral_ocr_not_empty", {
                                "empty_response": True,
                                "mime_type": mime_type
                            })
                            monitor.log_event("mistral_ocr_empty_response", {"mime_type": mime_type})
                            raise Exception("Mistral OCR returned empty text content")
                    else:
                        monitor.log_event("mistral_response_format_valid", {
                            "format_valid": False,
                            "response_keys": list(result.keys()) if isinstance(result, dict) else "not_dict"
                        })
                        monitor.log_event("mistral_ocr_invalid_response", {"response": result})
                        raise Exception("Invalid response format from Mistral OCR API")
                        
                else:
                    # Handle API errors with detailed logging
                    error_msg = f"Mistral OCR API failed with status {response.status_code}"
                    try:
                        error_details = response.json()
                        error_msg += f": {error_details.get('message', 'Unknown error')}"
                        
                        # Log specific error types for debugging
                        if response.status_code == 401:
                            monitor.log_event("mistral_auth_error", {"error": "Invalid API key"})
                            error_msg = "Mistral OCR authentication failed - check API key"
                        elif response.status_code == 429:
                            monitor.log_event("mistral_rate_limit", {"error": "Rate limit exceeded"})
                            error_msg = "Mistral OCR rate limit exceeded - try again later"
                        elif response.status_code == 413:
                            monitor.log_event("mistral_file_too_large", {"mime_type": mime_type})
                            error_msg = "Document too large for Mistral OCR processing"
                        else:
                            monitor.log_event("mistral_api_error", {
                                "status_code": response.status_code,
                                "error": error_details
                            })
                            
                    except Exception:
                        error_text = response.text
                        error_msg += f": {error_text}"
                        monitor.log_event("mistral_unknown_error", {
                            "status_code": response.status_code,
                            "response": error_text
                        })
                    
                    raise Exception(error_msg)
                    
        except Exception as e:
            # 🔍 DEBUGGING: Log exception details
            monitor.log_event("mistral_ocr_debug", {
                "step": "exception_caught",
                "exception_type": type(e).__name__,
                "exception_message": str(e),
                "exception_details": {
                    "args": e.args if hasattr(e, 'args') else "no_args",
                    "traceback_summary": f"{type(e).__name__}: {str(e)}"
                }
            })
            
            # Re-raise with context for better debugging
            raise Exception(f"Mistral OCR processing failed: {str(e)}")
    
    def _clean_ocr_text(self, text: str) -> str:
        """Clean up OCR text output for medical documents"""
        # Remove common OCR artifacts while preserving medical formatting
        cleaned = text.strip()
        
        # Remove any instruction responses or commentary
        lines = cleaned.split('\n')
        cleaned_lines = []
        
        skip_patterns = [
            "here is the extracted text",
            "the extracted text is:",
            "extracted text:",
            "text content:",
            "document content:",
        ]
        
        for line in lines:
            line_lower = line.lower().strip()
            should_skip = any(pattern in line_lower for pattern in skip_patterns)
            
            if not should_skip and line.strip():
                cleaned_lines.append(line)
        
        return '\n'.join(cleaned_lines)
    
    async def _extract_with_multimodal(self, document_bytes: bytes) -> str:
        """Extract text using multimodal processor (simplified)"""
        import base64
        import sys
        import os
        
        # Add gaia system to path
        gaia_path = os.path.join(os.path.dirname(__file__), "..", "..", "..", "gaia_agentic_system")
        if gaia_path not in sys.path:
            sys.path.append(gaia_path)
        
        try:
            from mcp_servers.multi_modal_processor_server import MultiModalProcessorServer
            
            # Create processor instance
            processor = MultiModalProcessorServer()
            processor.initialize()
            
            # Convert to base64
            b64_data = base64.b64encode(document_bytes).decode()
            
            # Analyze image for text extraction
            result = await processor._analyze_image({
                "image_data": b64_data,
                "analysis_type": "text_extraction"
            })
            
            return result.get("extracted_text", "")
            
        except Exception as e:
            raise Exception(f"Multimodal processor failed: {str(e)}")
    
    # Mock text method removed - never return dummy data for real medical processing
    
    def _extract_medical_entities(self, text: str) -> dict:
        """Extract medical entities from actual OCR text using regex patterns"""
        import re
        
        entities = {
            "patient_name": "Undefined",
            "date_of_birth": "Undefined",
            "conditions": [],
            "medications": [],
            "vitals": [],
            "provider_name": "Undefined"
        }
        
        # Pattern for names (capitalized words, typically 2-3 parts)
        name_patterns = [
            r'Patient:?\s*([A-Z][a-z]+ [A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)',
            r'Name:?\s*([A-Z][a-z]+ [A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)',
            r'([A-Z][a-z]+,\s*[A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)',
        ]
        
        for pattern in name_patterns:
            match = re.search(pattern, text)
            if match:
                entities["patient_name"] = match.group(1).strip()
                break
        
        # Pattern for dates of birth
        dob_patterns = [
            r'(?:DOB|Date of Birth|Born):?\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})',
            r'(?:DOB|Date of Birth|Born):?\s*(\d{1,2}/\d{1,2}/\d{2,4})',
            r'(?:DOB|Date of Birth|Born):?\s*([A-Z][a-z]+ \d{1,2},? \d{4})'
        ]
        
        for pattern in dob_patterns:
            match = re.search(pattern, text, re.IGNORECASE)
            if match:
                entities["date_of_birth"] = match.group(1).strip()
                break
        
        # Pattern for medical conditions
        condition_keywords = [
            r'(?:Diagnosis|Condition|History):?\s*([A-Z][a-z]+(?: [a-z]+)*)',
            r'([A-Z][a-z]+(?:itis|osis|emia|pathy|trophy|plasia))',
            r'(Hypertension|Diabetes|Asthma|COPD|Depression|Anxiety)'
        ]
        
        for pattern in condition_keywords:
            matches = re.findall(pattern, text, re.IGNORECASE)
            for match in matches:
                condition = match if isinstance(match, str) else match[0]
                if condition and len(condition) > 2:
                    entities["conditions"].append(condition.strip())
        
        # Pattern for medications
        med_patterns = [
            r'(?:Medication|Med|Rx):?\s*([A-Z][a-z]+(?:ol|ine|ide|ate|pril|statin))',
            r'([A-Z][a-z]+(?:ol|ine|ide|ate|pril|statin))\s*\d+\s*mg',
            r'(Lisinopril|Metformin|Aspirin|Ibuprofen|Acetaminophen)'
        ]
        
        for pattern in med_patterns:
            matches = re.findall(pattern, text, re.IGNORECASE)
            for match in matches:
                medication = match if isinstance(match, str) else match[0]
                if medication and len(medication) > 2:
                    entities["medications"].append(medication.strip())
        
        # Pattern for vital signs
        vital_patterns = [
            r'(?:BP|Blood Pressure):?\s*(\d{2,3}/\d{2,3})',
            r'(?:Heart Rate|HR):?\s*(\d{2,3})\s*bpm',
            r'(?:Temperature|Temp):?\s*(\d{2,3}(?:\.\d)?)\s*°?F?',
            r'(?:Weight):?\s*(\d{2,3})\s*lbs?',
            r'(?:Height):?\s*(\d+)\'?\s*(\d+)"?'
        ]
        
        for pattern in vital_patterns:
            matches = re.findall(pattern, text, re.IGNORECASE)
            for match in matches:
                vital = match if isinstance(match, str) else ' '.join(filter(None, match))
                if vital:
                    entities["vitals"].append(vital.strip())
        
        # Pattern for provider/doctor names
        provider_patterns = [
            r'(?:Dr\.|Doctor|Physician):?\s*([A-Z][a-z]+ [A-Z][a-z]+)',
            r'Provider:?\s*([A-Z][a-z]+ [A-Z][a-z]+)',
            r'Attending:?\s*([A-Z][a-z]+ [A-Z][a-z]+)'
        ]
        
        for pattern in provider_patterns:
            match = re.search(pattern, text)
            if match:
                entities["provider_name"] = match.group(1).strip()
                break
        
        return entities
    
    def _create_simple_fhir_bundle(self, entities: dict, user_id: str) -> dict:
        """Create FHIR bundle from extracted entities"""
        bundle_id = f"local-{uuid.uuid4()}"
        
        # Parse patient name
        patient_name = entities.get("patient_name", "Undefined")
        if patient_name != "Undefined" and " " in patient_name:
            name_parts = patient_name.split()
            given_name = name_parts[0] if len(name_parts) > 0 else "Undefined"
            family_name = " ".join(name_parts[1:]) if len(name_parts) > 1 else "Undefined"
        else:
            given_name = "Undefined"
            family_name = "Undefined"
        
        # Create bundle entries
        entries = []
        
        # Patient resource
        patient_resource = {
            "resource": {
                "resourceType": "Patient",
                "id": "local-patient",
                "name": [{"given": [given_name], "family": family_name}]
            }
        }
        
        # Add birth date if available
        if entities.get("date_of_birth") != "Undefined":
            patient_resource["resource"]["birthDate"] = entities["date_of_birth"]
        
        entries.append(patient_resource)
        
        # Add conditions as Condition resources
        for i, condition in enumerate(entities.get("conditions", [])):
            if condition:
                entries.append({
                    "resource": {
                        "resourceType": "Condition",
                        "id": f"local-condition-{i}",
                        "subject": {"reference": "Patient/local-patient"},
                        "code": {
                            "text": condition
                        },
                        "clinicalStatus": {
                            "coding": [{
                                "system": "http://terminology.hl7.org/CodeSystem/condition-clinical",
                                "code": "active"
                            }]
                        }
                    }
                })
        
        # Add medications as MedicationStatement resources
        for i, medication in enumerate(entities.get("medications", [])):
            if medication:
                entries.append({
                    "resource": {
                        "resourceType": "MedicationStatement",
                        "id": f"local-medication-{i}",
                        "subject": {"reference": "Patient/local-patient"},
                        "medicationCodeableConcept": {
                            "text": medication
                        },
                        "status": "active"
                    }
                })
        
        # Add vitals as Observation resources
        for i, vital in enumerate(entities.get("vitals", [])):
            if vital:
                entries.append({
                    "resource": {
                        "resourceType": "Observation",
                        "id": f"local-vital-{i}",
                        "subject": {"reference": "Patient/local-patient"},
                        "status": "final",
                        "code": {
                            "text": "Vital Sign"
                        },
                        "valueString": vital
                    }
                })
        
        return {
            "resourceType": "Bundle",
            "id": bundle_id,
            "type": "document",
            "timestamp": datetime.now().isoformat(),
            "entry": entries,
            "_metadata": {
                "processing_mode": self._get_processing_mode(),
                "entities_found": len(entities.get("conditions", [])) + len(entities.get("medications", [])) + len(entities.get("vitals", [])),
                "processed_by": user_id,
                "patient_name": entities.get("patient_name", "Undefined"),
                "provider_name": entities.get("provider_name", "Undefined")
            }
        }
    
    def _get_processing_mode(self) -> str:
        """Determine current processing mode"""
        if self.use_mistral_fallback and self.mistral_api_key:
            return "local_processing_with_mistral_ocr"
        elif self.use_multimodal_fallback:
            return "local_processing_with_multimodal_fallback"
        else:
            return "local_processing_only"

# Global instance
local_processor = LocalProcessor()