Update api/routes.py

api/routes.py

@@ -1,944 +1,9 @@
-from fastapi import APIRouter, HTTPException, Depends, Query, status, Response
-from fastapi.security import OAuth2PasswordRequestForm
-from models.schemas import SignupForm, TokenResponse, PatientCreate, DoctorCreate, AppointmentCreate
-from db.mongo import users_collection, patients_collection, appointments_collection
-from core.security import hash_password, verify_password, create_access_token, get_current_user
-from datetime import datetime, timedelta
-from bson import ObjectId
-from bson.errors import InvalidId
-from typing import Optional, List, Dict
-from pydantic import BaseModel, Field
-from pymongo import UpdateOne, InsertOne, IndexModel
-from pymongo.errors import BulkWriteError
-import httpx
-import os
-import json
-from pathlib import Path
-import glob
-from motor.motor_asyncio import AsyncIOMotorClient
-import logging
-import time
-import uuid
-import re
-import subprocess
-from tempfile import NamedTemporaryFile, TemporaryDirectory
-from string import Template
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(name)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
+from fastapi import APIRouter
+from .routes import auth, patients, pdf
 
 router = APIRouter()
 
-# Configuration
-BASE_DIR = Path(__file__).resolve().parent.parent
-SYNTHEA_DATA_DIR = BASE_DIR / "output" / "fhir"
-os.makedirs(SYNTHEA_DATA_DIR, exist_ok=True)
-
-# Models
-class Note(BaseModel):
-    date: str = Field(..., example="2023-01-01T12:00:00Z")
-    type: str = Field(..., example="Progress Note")
-    text: str = Field(..., example="Patient reported improvement in symptoms")
-    author: Optional[str] = Field(None, example="Dr. Smith")
-
-class Condition(BaseModel):
-    id: str = Field(..., example="cond123")
-    code: str = Field(..., example="Hypertension")
-    status: str = Field(..., example="Active")
-    onset_date: str = Field(..., example="2020-05-15")
-    recorded_date: Optional[str] = Field(None, example="2020-05-16")
-    verification_status: Optional[str] = Field(None, example="Confirmed")
-
-class Medication(BaseModel):
-    id: str = Field(..., example="med123")
-    name: str = Field(..., example="Lisinopril 10mg")
-    status: str = Field(..., example="Active")
-    prescribed_date: str = Field(..., example="2021-02-10")
-    requester: Optional[str] = Field(None, example="Dr. Smith")
-    dosage: Optional[str] = Field(None, example="10mg daily")
-
-class Encounter(BaseModel):
-    id: str = Field(..., example="enc123")
-    type: str = Field(..., example="Outpatient Visit")
-    status: str = Field(..., example="Finished")
-    period: Dict = Field(..., example={"start": "2023-01-01T10:00:00Z"})
-    service_provider: Optional[str] = Field(None, example="City Hospital")
-
-class PatientUpdate(BaseModel):
-    notes: Optional[List[Note]] = None
-    conditions: Optional[List[Condition]] = None
-    medications: Optional[List[Medication]] = None
-
-# Language mapping for MongoDB compatibility
-LANGUAGE_MAP = {
-    'English (United States)': 'en',
-    'English': 'en',
-    'Spanish (United States)': 'es',
-    'Spanish': 'es',
-    # Add more mappings as needed
-}
-
-# Indexes
-async def create_indexes():
-    try:
-        await patients_collection.create_indexes([
-            IndexModel([("fhir_id", 1)], unique=True),
-            IndexModel([("full_name", "text")]),
-            IndexModel([("date_of_birth", 1)]),
-            IndexModel([("notes.date", -1)])
-        ])
-        logger.info("Database indexes created successfully")
-    except Exception as e:
-        logger.error(f"Failed to create indexes: {str(e)}")
-        raise
-
-# Helper Functions
-def calculate_age(birth_date: str) -> Optional[int]:
-    if not birth_date:
-        return None
-    try:
-        birth_date = datetime.strptime(birth_date.split('T')[0], "%Y-%m-%d")
-        today = datetime.now()
-        return today.year - birth_date.year - (
-            (today.month, today.day) < (birth_date.month, birth_date.day))
-    except ValueError as e:
-        logger.warning(f"Invalid birth date format: {birth_date}, error: {str(e)}")
-        return None
-
-def standardize_language(language: str) -> str:
-    """Convert language to MongoDB-compatible language code."""
-    if not language:
-        return 'en'  # Default to English
-    return LANGUAGE_MAP.get(language, 'en')
-
-def escape_latex_special_chars(text: str) -> str:
-    """Escape special LaTeX characters to prevent compilation errors."""
-    if not isinstance(text, str):
-        return ""
-    replacements = {
-        "&": "\\&",
-        "%": "\\%",
-        "$": "\\$",
-        "#": "\\#",
-        "_": "\\_",
-        "{": "\\{",
-        "}": "\\}",
-        "~": "\\textasciitilde{}",
-        "^": "\\textasciicircum{}",
-        "\\": "\\textbackslash{}"
-    }
-    for char, escape in replacements.items():
-        text = text.replace(char, escape)
-    return text
-
-def hyphenate_long_strings(text: str, max_length: int = 10) -> str:
-    """Insert LaTeX hyphenation points into long strings to prevent overfull hboxes."""
-    if not isinstance(text, str) or len(text) <= max_length:
-        return text
-    result = ""
-    for i, char in enumerate(text):
-        result += char
-        if (i + 1) % max_length == 0 and (i + 1) != len(text):
-            result += "\\-"
-    return result
-
-def format_timestamp(timestamp: str) -> str:
-    """Shorten a timestamp to YYYY-MM-DD format."""
-    if not isinstance(timestamp, str):
-        return ""
-    try:
-        dt = datetime.strptime(timestamp, "%Y-%m-%dT%H:%M:%S%z")
-        return dt.strftime("%Y-%m-%d")
-    except ValueError:
-        return timestamp
-
-async def process_synthea_patient(bundle: dict, file_path: str) -> Optional[dict]:
-    logger.debug(f"Processing patient from file: {file_path}")
-    patient_data = {}
-    notes = []
-    conditions = []
-    medications = []
-    encounters = []
-    
-    # Validate bundle structure
-    if not isinstance(bundle, dict) or 'entry' not in bundle:
-        logger.error(f"Invalid FHIR bundle structure in {file_path}")
-        return None
-    
-    for entry in bundle.get('entry', []):
-        resource = entry.get('resource', {})
-        resource_type = resource.get('resourceType')
-        
-        if not resource_type:
-            logger.warning(f"Skipping entry with missing resourceType in {file_path}")
-            continue
-            
-        try:
-            if resource_type == 'Patient':
-                name = resource.get('name', [{}])[0]
-                address = resource.get('address', [{}])[0]
-                
-                patient_data = {
-                    'fhir_id': resource.get('id'),
-                    'full_name': f"{' '.join(name.get('given', ['']))} {name.get('family', '')}".strip(),
-                    'gender': resource.get('gender', 'unknown'),
-                    'date_of_birth': resource.get('birthDate', ''),
-                    'address': ' '.join(address.get('line', [''])),
-                    'city': address.get('city', ''),
-                    'state': address.get('state', ''),
-                    'postal_code': address.get('postalCode', ''),
-                    'country': address.get('country', ''),
-                    'marital_status': resource.get('maritalStatus', {}).get('text', ''),
-                    'language': standardize_language(resource.get('communication', [{}])[0].get('language', {}).get('text', '')),
-                    'source': 'synthea',
-                    'last_updated': datetime.utcnow().isoformat()
-                }
-                
-            elif resource_type == 'Encounter':
-                encounter = {
-                    'id': resource.get('id'),
-                    'type': resource.get('type', [{}])[0].get('text', ''),
-                    'status': resource.get('status'),
-                    'period': resource.get('period', {}),
-                    'service_provider': resource.get('serviceProvider', {}).get('display', '')
-                }
-                encounters.append(encounter)
-                
-                for note in resource.get('note', []):
-                    if note.get('text'):
-                        notes.append({
-                            'date': resource.get('period', {}).get('start', datetime.utcnow().isoformat()),
-                            'type': resource.get('type', [{}])[0].get('text', 'Encounter Note'),
-                            'text': note.get('text'),
-                            'context': f"Encounter: {encounter.get('type')}",
-                            'author': 'System Generated'
-                        })
-                
-            elif resource_type == 'Condition':
-                conditions.append({
-                    'id': resource.get('id'),
-                    'code': resource.get('code', {}).get('text', ''),
-                    'status': resource.get('clinicalStatus', {}).get('text', ''),
-                    'onset_date': resource.get('onsetDateTime'),
-                    'recorded_date': resource.get('recordedDate'),
-                    'verification_status': resource.get('verificationStatus', {}).get('text', '')
-                })
-                
-            elif resource_type == 'MedicationRequest':
-                medications.append({
-                    'id': resource.get('id'),
-                    'name': resource.get('medicationCodeableConcept', {}).get('text', ''),
-                    'status': resource.get('status'),
-                    'prescribed_date': resource.get('authoredOn'),
-                    'requester': resource.get('requester', {}).get('display', ''),
-                    'dosage': resource.get('dosageInstruction', [{}])[0].get('text', '')
-                })
-                
-        except Exception as e:
-            logger.error(f"Error processing {resource_type} in {file_path}: {str(e)}")
-            continue
-    
-    if patient_data:
-        patient_data.update({
-            'notes': notes,
-            'conditions': conditions,
-            'medications': medications,
-            'encounters': encounters,
-            'import_date': datetime.utcnow().isoformat()
-        })
-        logger.info(f"Successfully processed patient {patient_data.get('fhir_id')} from {file_path}")
-        return patient_data
-    logger.warning(f"No valid patient data found in {file_path}")
-    return None
-
-# Routes
-@router.post("/ehr/import", status_code=status.HTTP_201_CREATED)
-async def import_patients(
-    limit: int = Query(100, ge=1, le=1000),
-    current_user: dict = Depends(get_current_user)
-):
-    request_id = str(uuid.uuid4())
-    logger.info(f"Starting import request {request_id} by user {current_user.get('email')}")
-    start_time = time.time()
-    
-    if current_user.get('role') not in ['admin', 'doctor']:
-        logger.warning(f"Unauthorized import attempt by {current_user.get('email')}")
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Only administrators and doctors can import data"
-        )
-    
-    try:
-        await create_indexes()
-        
-        if not SYNTHEA_DATA_DIR.exists():
-            logger.error(f"Synthea data directory not found: {SYNTHEA_DATA_DIR}")
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="Data directory not found"
-            )
-            
-        # Filter out non-patient files
-        files = [
-            f for f in glob.glob(str(SYNTHEA_DATA_DIR / "*.json"))
-            if not re.search(r'(hospitalInformation|practitionerInformation)\d+\.json$', f)
-        ]
-        if not files:
-            logger.warning("No valid patient JSON files found in synthea data directory")
-            return {
-                "status": "success",
-                "message": "No patient data files found",
-                "imported": 0,
-                "request_id": request_id
-            }
-            
-        operations = []
-        imported = 0
-        errors = []
-        
-        for file_path in files[:limit]:
-            try:
-                logger.debug(f"Processing file: {file_path}")
-                
-                # Check file accessibility
-                if not os.path.exists(file_path):
-                    logger.error(f"File not found: {file_path}")
-                    errors.append(f"File not found: {file_path}")
-                    continue
-                    
-                # Check file size
-                file_size = os.path.getsize(file_path)
-                if file_size == 0:
-                    logger.warning(f"Empty file: {file_path}")
-                    errors.append(f"Empty file: {file_path}")
-                    continue
-                    
-                with open(file_path, 'r', encoding='utf-8') as f:
-                    try:
-                        bundle = json.load(f)
-                    except json.JSONDecodeError as je:
-                        logger.error(f"Invalid JSON in {file_path}: {str(je)}")
-                        errors.append(f"Invalid JSON in {file_path}: {str(je)}")
-                        continue
-                        
-                patient = await process_synthea_patient(bundle, file_path)
-                if patient:
-                    if not patient.get('fhir_id'):
-                        logger.warning(f"Missing FHIR ID in patient data from {file_path}")
-                        errors.append(f"Missing FHIR ID in {file_path}")
-                        continue
-                        
-                    operations.append(UpdateOne(
-                        {"fhir_id": patient['fhir_id']},
-                        {"$setOnInsert": patient},
-                        upsert=True
-                    ))
-                    imported += 1
-                else:
-                    logger.warning(f"No valid patient data in {file_path}")
-                    errors.append(f"No valid patient data in {file_path}")
-                    
-            except Exception as e:
-                logger.error(f"Error processing {file_path}: {str(e)}")
-                errors.append(f"Error in {file_path}: {str(e)}")
-                continue
-        
-        response = {
-            "status": "success",
-            "imported": imported,
-            "errors": errors,
-            "request_id": request_id,
-            "duration_seconds": time.time() - start_time
-        }
-        
-        if operations:
-            try:
-                result = await patients_collection.bulk_write(operations, ordered=False)
-                response.update({
-                    "upserted": result.upserted_count,
-                    "existing": len(operations) - result.upserted_count
-                })
-                logger.info(f"Import request {request_id} completed: {imported} patients processed, "
-                           f"{result.upserted_count} upserted, {len(errors)} errors")
-            except BulkWriteError as bwe:
-                logger.error(f"Partial bulk write failure for request {request_id}: {str(bwe.details)}")
-                response.update({
-                    "upserted": bwe.details.get('nUpserted', 0),
-                    "existing": len(operations) - bwe.details.get('nUpserted', 0),
-                    "write_errors": [
-                        f"Index {err['index']}: {err['errmsg']}" for err in bwe.details.get('writeErrors', [])
-                    ]
-                })
-                logger.info(f"Import request {request_id} partially completed: {imported} patients processed, "
-                           f"{response['upserted']} upserted, {len(errors)} errors")
-            except Exception as e:
-                logger.error(f"Bulk write failed for request {request_id}: {str(e)}")
-                raise HTTPException(
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    detail=f"Database operation failed: {str(e)}"
-                )
-        else:
-            logger.info(f"Import request {request_id} completed: No new patients to import, {len(errors)} errors")
-            response["message"] = "No new patients found to import"
-            
-        return response
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Import request {request_id} failed: {str(e)}", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Import failed: {str(e)}"
-        )
-
-@router.get("/ehr/patients", response_model=List[dict])
-async def list_patients(
-    search: Optional[str] = Query(None),
-    min_notes: int = Query(0, ge=0),
-    min_conditions: int = Query(0, ge=0),
-    limit: int = Query(100, ge=1, le=500),
-    skip: int = Query(0, ge=0)
-):
-    logger.info(f"Listing patients with search: {search}, limit: {limit}, skip: {skip}")
-    query = {"source": "synthea"}
-    
-    if search:
-        query["$or"] = [
-            {"full_name": {"$regex": search, "$options": "i"}},
-            {"fhir_id": search}
-        ]
-    
-    if min_notes > 0:
-        query[f"notes.{min_notes-1}"] = {"$exists": True}
-    
-    if min_conditions > 0:
-        query[f"conditions.{min_conditions-1}"] = {"$exists": True}
-    
-    # Removed $slice to return full arrays for the frontend
-    projection = {
-        "fhir_id": 1,
-        "full_name": 1,
-        "gender": 1,
-        "date_of_birth": 1,
-        "city": 1,
-        "state": 1,
-        "conditions": 1,
-        "medications": 1,
-        "encounters": 1,
-        "notes": 1
-    }
-    
-    try:
-        cursor = patients_collection.find(query, projection).skip(skip).limit(limit)
-        patients = []
-        
-        async for patient in cursor:
-            patients.append({
-                "id": str(patient["_id"]),
-                "fhir_id": patient.get("fhir_id"),
-                "full_name": patient.get("full_name"),
-                "gender": patient.get("gender"),
-                "date_of_birth": patient.get("date_of_birth"),
-                "city": patient.get("city"),
-                "state": patient.get("state"),
-                "conditions": patient.get("conditions", []),
-                "medications": patient.get("medications", []),
-                "encounters": patient.get("encounters", []),
-                "notes": patient.get("notes", []),
-                "age": calculate_age(patient.get("date_of_birth")),
-                "stats": {
-                    "notes": len(patient.get("notes", [])),
-                    "conditions": len(patient.get("conditions", [])),
-                    "medications": len(patient.get("medications", []))
-                }
-            })
-        
-        logger.info(f"Retrieved {len(patients)} patients")
-        return patients
-        
-    except Exception as e:
-        logger.error(f"Failed to list patients: {str(e)}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to retrieve patients: {str(e)}"
-        )
-
-@router.get("/ehr/patients/{patient_id}", response_model=dict)
-async def get_patient(patient_id: str):
-    logger.info(f"Retrieving patient: {patient_id}")
-    try:
-        patient = await patients_collection.find_one({
-            "$or": [
-                {"_id": ObjectId(patient_id)},
-                {"fhir_id": patient_id}
-            ]
-        })
-        
-        if not patient:
-            logger.warning(f"Patient not found: {patient_id}")
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail="Patient not found"
-            )
-        
-        response = {
-            "demographics": {
-                "id": str(patient["_id"]),
-                "fhir_id": patient.get("fhir_id"),
-                "full_name": patient.get("full_name"),
-                "gender": patient.get("gender"),
-                "date_of_birth": patient.get("date_of_birth"),
-                "age": calculate_age(patient.get("date_of_birth")),
-                "address": {
-                    "line": patient.get("address"),
-                    "city": patient.get("city"),
-                    "state": patient.get("state"),
-                    "postal_code": patient.get("postal_code"),
-                    "country": patient.get("country")
-                },
-                "marital_status": patient.get("marital_status"),
-                "language": patient.get("language")
-            },
-            "clinical_data": {
-                "notes": patient.get("notes", []),
-                "conditions": patient.get("conditions", []),
-                "medications": patient.get("medications", []),
-                "encounters": patient.get("encounters", [])
-            },
-            "metadata": {
-                "source": patient.get("source"),
-                "import_date": patient.get("import_date"),
-                "last_updated": patient.get("last_updated")
-            }
-        }
-        
-        logger.info(f"Successfully retrieved patient: {patient_id}")
-        return response
-        
-    except ValueError as ve:
-        logger.error(f"Invalid patient ID format: {patient_id}, error: {str(ve)}")
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Invalid patient ID format"
-        )
-    except Exception as e:
-        logger.error(f"Failed to retrieve patient {patient_id}: {str(e)}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to retrieve patient: {str(e)}"
-        )
-
-@router.post("/ehr/patients/{patient_id}/notes", status_code=status.HTTP_201_CREATED)
-async def add_note(
-    patient_id: str,
-    note: Note,
-    current_user: dict = Depends(get_current_user)
-):
-    logger.info(f"Adding note for patient {patient_id} by user {current_user.get('email')}")
-    if current_user.get('role') not in ['doctor', 'admin']:
-        logger.warning(f"Unauthorized note addition attempt by {current_user.get('email')}")
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Only clinicians can add notes"
-        )
-    
-    try:
-        note_data = note.dict()
-        note_data.update({
-            "author": current_user.get('full_name', 'System'),
-            "timestamp": datetime.utcnow().isoformat()
-        })
-        
-        result = await patients_collection.update_one(
-            {"$or": [
-                {"_id": ObjectId(patient_id)},
-                {"fhir_id": patient_id}
-            ]},
-            {
-                "$push": {"notes": note_data},
-                "$set": {"last_updated": datetime.utcnow().isoformat()}
-            }
-        )
-        
-        if result.modified_count == 0:
-            logger.warning(f"Patient not found for note addition: {patient_id}")
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail="Patient not found"
-            )
-        
-        logger.info(f"Note added successfully for patient {patient_id}")
-        return {"status": "success", "message": "Note added"}
-        
-    except ValueError as ve:
-        logger.error(f"Invalid patient ID format: {patient_id}, error: {str(ve)}")
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Invalid patient ID format"
-        )
-    except Exception as e:
-        logger.error(f"Failed to add note for patient {patient_id}: {str(e)}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to add note: {str(e)}"
-        )
-
-@router.get("/ehr/patients/{patient_id}/pdf", response_class=Response)
-async def generate_patient_pdf(patient_id: str, current_user: dict = Depends(get_current_user)):
-    # Suppress logging for this route
-    logger.setLevel(logging.CRITICAL)
-
-    try:
-        if current_user.get('role') not in ['doctor', 'admin']:
-            raise HTTPException(status_code=403, detail="Only clinicians can generate patient PDFs")
-
-        # Determine if patient_id is ObjectId or fhir_id
-        try:
-            obj_id = ObjectId(patient_id)
-            query = {"$or": [{"_id": obj_id}, {"fhir_id": patient_id}]}
-        except InvalidId:
-            query = {"fhir_id": patient_id}
-
-        patient = await patients_collection.find_one(query)
-        if not patient:
-            raise HTTPException(status_code=404, detail="Patient not found")
-
-        # Prepare table content
-        notes = patient.get("notes", [])
-        notes_content = ""
-        if notes:
-            notes_content = "\\toprule\n" + " \\\\\n".join(
-                "{} & {} & {}".format(
-                    escape_latex_special_chars(hyphenate_long_strings(format_timestamp(n.get("date", "") or ""))),
-                    escape_latex_special_chars(hyphenate_long_strings(n.get("type", "") or "")),
-                    escape_latex_special_chars(hyphenate_long_strings(n.get("text", "") or ""))
-                )
-                for n in notes
-            ) + "\n\\bottomrule"
-        else:
-            notes_content = "\\multicolumn{3}{l}{No notes available}"
-
-        conditions = patient.get("conditions", [])
-        conditions_content = ""
-        if conditions:
-            conditions_content = "\\toprule\n" + " \\\\\n".join(
-                "{} & {} & {} & {} & {}".format(
-                    escape_latex_special_chars(hyphenate_long_strings(c.get("id", "") or "")),
-                    escape_latex_special_chars(hyphenate_long_strings(c.get("code", "") or "")),
-                    escape_latex_special_chars(hyphenate_long_strings(c.get("status", "") or "")),
-                    escape_latex_special_chars(hyphenate_long_strings(format_timestamp(c.get("onset_date", "") or ""))),
-                    escape_latex_special_chars(hyphenate_long_strings(c.get("verification_status", "") or ""))
-                )
-                for c in conditions
-            ) + "\n\\bottomrule"
-        else:
-            conditions_content = "\\multicolumn{5}{l}{No conditions available}"
-
-        medications = patient.get("medications", [])
-        medications_content = ""
-        if medications:
-            medications_content = "\\toprule\n" + " \\\\\n".join(
-                "{} & {} & {} & {} & {}".format(
-                    escape_latex_special_chars(hyphenate_long_strings(m.get("id", "") or "")),
-                    escape_latex_special_chars(hyphenate_long_strings(m.get("name", "") or "")),
-                    escape_latex_special_chars(hyphenate_long_strings(m.get("status", "") or "")),
-                    escape_latex_special_chars(hyphenate_long_strings(format_timestamp(m.get("prescribed_date", "") or ""))),
-                    escape_latex_special_chars(hyphenate_long_strings(m.get("dosage", "") or ""))
-                )
-                for m in medications
-            ) + "\n\\bottomrule"
-        else:
-            medications_content = "\\multicolumn{5}{l}{No medications available}"
-
-        encounters = patient.get("encounters", [])
-        encounters_content = ""
-        if encounters:
-            encounters_content = "\\toprule\n" + " \\\\\n".join(
-                "{} & {} & {} & {} & {}".format(
-                    escape_latex_special_chars(hyphenate_long_strings(e.get("id", "") or "")),
-                    escape_latex_special_chars(hyphenate_long_strings(e.get("type", "") or "")),
-                    escape_latex_special_chars(hyphenate_long_strings(e.get("status", "") or "")),
-                    escape_latex_special_chars(hyphenate_long_strings(format_timestamp(e.get("period", {}).get("start", "") or ""))),
-                    escape_latex_special_chars(hyphenate_long_strings(e.get("service_provider", "") or ""))
-                )
-                for e in encounters
-            ) + "\n\\bottomrule"
-        else:
-            encounters_content = "\\multicolumn{5}{l}{No encounters available}"
-
-        # Use Template for safe insertion
-        latex_template = Template(r"""
-\documentclass[a4paper,12pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{geometry}
-\geometry{margin=1in}
-\usepackage{booktabs,longtable,fancyhdr}
-\usepackage{array}
-\usepackage{microtype}
-\microtypesetup{expansion=false}  % Disable font expansion to avoid errors
-\setlength{\headheight}{14.5pt}  % Fix fancyhdr warning
-\pagestyle{fancy}
-\fancyhf{}
-\fancyhead[L]{Patient Report}
-\fancyhead[R]{Generated: \today}
-\fancyfoot[C]{\thepage}
-
-\begin{document}
-
-\begin{center}
-    \Large\textbf{Patient Medical Report} \\
-    \vspace{0.2cm}
-    \textit{Generated on $generated_on}
-\end{center}
-
-\section*{Demographics}
-\begin{itemize}
-    \item \textbf{FHIR ID:} $fhir_id
-    \item \textbf{Full Name:} $full_name
-    \item \textbf{Gender:} $gender
-    \item \textbf{Date of Birth:} $dob
-    \item \textbf{Age:} $age
-    \item \textbf{Address:} $address
-    \item \textbf{Marital Status:} $marital_status
-    \item \textbf{Language:} $language
-\end{itemize}
-
-\section*{Clinical Notes}
-\begin{longtable}{>{\raggedright\arraybackslash}p{3.5cm}>{\raggedright\arraybackslash}p{3cm}>{\raggedright\arraybackslash}p{6.5cm}}
-\textbf{Date} & \textbf{Type} & \textbf{Text} \\
-\endhead
-$notes
-\end{longtable}
-
-\section*{Conditions}
-\begin{longtable}{>{\raggedright\arraybackslash}p{2cm}>{\raggedright\arraybackslash}p{3cm}>{\raggedright\arraybackslash}p{2cm}>{\raggedright\arraybackslash}p{3.5cm}>{\raggedright\arraybackslash}p{3cm}}
-\textbf{ID} & \textbf{Code} & \textbf{Status} & \textbf{Onset} & \textbf{Verification} \\
-\endhead
-$conditions
-\end{longtable}
-
-\section*{Medications}
-\begin{longtable}{>{\raggedright\arraybackslash}p{2cm}>{\raggedright\arraybackslash}p{4cm}>{\raggedright\arraybackslash}p{2cm}>{\raggedright\arraybackslash}p{3.5cm}>{\raggedright\arraybackslash}p{3cm}}
-\textbf{ID} & \textbf{Name} & \textbf{Status} & \textbf{Date} & \textbf{Dosage} \\
-\endhead
-$medications
-\end{longtable}
-
-\section*{Encounters}
-\begin{longtable}{>{\raggedright\arraybackslash}p{2.5cm}>{\raggedright\arraybackslash}p{4.5cm}>{\raggedright\arraybackslash}p{2.5cm}>{\raggedright\arraybackslash}p{4.5cm}>{\raggedright\arraybackslash}p{3.5cm}}
-\textbf{ID} & \textbf{Type} & \textbf{Status} & \textbf{Start} & \textbf{Provider} \\
-\endhead
-$encounters
-\end{longtable}
-
-\end{document}
-""")
-
-        # Set the generated_on date to 05:26 PM CET, May 16, 2025
-        generated_on = datetime.strptime("2025-05-16 17:26:00+01:00", "%Y-%m-%d %H:%M:%S%z").strftime("%A, %B %d, %Y at %I:%M %p")
-
-        latex_filled = latex_template.substitute(
-            generated_on=generated_on,
-            fhir_id=escape_latex_special_chars(hyphenate_long_strings(patient.get("fhir_id", "") or "")),
-            full_name=escape_latex_special_chars(patient.get("full_name", "") or ""),
-            gender=escape_latex_special_chars(patient.get("gender", "") or ""),
-            dob=escape_latex_special_chars(patient.get("date_of_birth", "") or ""),
-            age=escape_latex_special_chars(str(calculate_age(patient.get("date_of_birth", "")) or "N/A")),
-            address=escape_latex_special_chars(", ".join(filter(None, [
-                patient.get("address", ""),
-                patient.get("city", ""),
-                patient.get("state", ""),
-                patient.get("postal_code", ""),
-                patient.get("country", "")
-            ]))),
-            marital_status=escape_latex_special_chars(patient.get("marital_status", "") or ""),
-            language=escape_latex_special_chars(patient.get("language", "") or ""),
-            notes=notes_content,
-            conditions=conditions_content,
-            medications=medications_content,
-            encounters=encounters_content
-        )
-
-        # Compile LaTeX in a temporary directory
-        with TemporaryDirectory() as tmpdir:
-            tex_path = os.path.join(tmpdir, "report.tex")
-            pdf_path = os.path.join(tmpdir, "report.pdf")
-
-            with open(tex_path, "w", encoding="utf-8") as f:
-                f.write(latex_filled)
-
-            try:
-                subprocess.run(
-                    ["latexmk", "-pdf", "-interaction=nonstopmode", tex_path],
-                    cwd=tmpdir,
-                    check=True,
-                    capture_output=True,
-                    text=True
-                )
-            except subprocess.CalledProcessError as e:
-                raise HTTPException(
-                    status_code=500,
-                    detail=f"LaTeX compilation failed: stdout={e.stdout}, stderr={e.stderr}"
-                )
-
-            if not os.path.exists(pdf_path):
-                raise HTTPException(
-                    status_code=500,
-                    detail="PDF file was not generated"
-                )
-
-            with open(pdf_path, "rb") as f:
-                pdf_bytes = f.read()
-
-            response = Response(
-                content=pdf_bytes,
-                media_type="application/pdf",
-                headers={"Content-Disposition": f"attachment; filename=patient_{patient.get('fhir_id', 'unknown')}_report.pdf"}
-            )
-            return response
-
-    except HTTPException as http_error:
-        raise http_error
-    except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Unexpected error generating PDF: {str(e)}"
-        )
-    finally:
-        # Restore the logger level for other routes
-        logger.setLevel(logging.INFO)
-
-@router.post("/signup", status_code=status.HTTP_201_CREATED)
-async def signup(data: SignupForm):
-    logger.info(f"Signup attempt for email: {data.email}")
-    email = data.email.lower().strip()
-    existing = await users_collection.find_one({"email": email})
-    if existing:
-        logger.warning(f"Signup failed: Email already exists: {email}")
-        raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT,
-            detail="Email already exists"
-        )
-    
-    hashed_pw = hash_password(data.password)
-    user_doc = {
-        "email": email,
-        "full_name": data.full_name.strip(),
-        "password": hashed_pw,
-        "role": "patient",
-        "created_at": datetime.utcnow().isoformat(),
-        "updated_at": datetime.utcnow().isoformat()
-    }
-    
-    try:
-        result = await users_collection.insert_one(user_doc)
-        logger.info(f"User created successfully: {email}")
-        return {
-            "status": "success",
-            "id": str(result.inserted_id),
-            "email": email
-        }
-    except Exception as e:
-        logger.error(f"Failed to create user {email}: {str(e)}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to create user: {str(e)}"
-        )
-
-@router.post("/admin/doctors", status_code=status.HTTP_201_CREATED)
-async def create_doctor(
-    data: DoctorCreate,
-    current_user: dict = Depends(get_current_user)
-):
-    logger.info(f"Doctor creation attempt by {current_user.get('email')}")
-    if current_user.get('role') != 'admin':
-        logger.warning(f"Unauthorized doctor creation attempt by {current_user.get('email')}")
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Only admins can create doctor accounts"
-        )
-    
-    email = data.email.lower().strip()
-    existing = await users_collection.find_one({"email": email})
-    if existing:
-        logger.warning(f"Doctor creation failed: Email already exists: {email}")
-        raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT,
-            detail="Email already exists"
-        )
-    
-    hashed_pw = hash_password(data.password)
-    doctor_doc = {
-        "email": email,
-        "full_name": data.full_name.strip(),
-        "password": hashed_pw,
-        "role": "doctor",
-        "specialty": data.specialty,
-        "license_number": data.license_number,
-        "created_at": datetime.utcnow().isoformat(),
-        "updated_at": datetime.utcnow().isoformat()
-    }
-    
-    try:
-        result = await users_collection.insert_one(doctor_doc)
-        logger.info(f"Doctor created successfully: {email}")
-        return {
-            "status": "success",
-            "id": str(result.inserted_id),
-            "email": email
-        }
-    except Exception as e:
-        logger.error(f"Failed to create doctor {email}: {str(e)}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to create doctor: {str(e)}"
-        )
-
-@router.post("/login", response_model=TokenResponse)
-async def login(form_data: OAuth2PasswordRequestForm = Depends()):
-    logger.info(f"Login attempt for email: {form_data.username}")
-    user = await users_collection.find_one({"email": form_data.username.lower()})
-    if not user or not verify_password(form_data.password, user["password"]):
-        logger.warning(f"Login failed for {form_data.username}: Invalid credentials")
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid credentials",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
-    
-    access_token = create_access_token(data={"sub": user["email"]})
-    logger.info(f"Successful login for {form_data.username}")
-    return {
-        "access_token": access_token,
-        "token_type": "bearer",
-        "role": user.get("role", "patient")
-    }
-
-@router.get("/me")
-async def get_me(current_user: dict = Depends(get_current_user)):
-    logger.info(f"Fetching user profile for {current_user['email']}")
-    user = await users_collection.find_one({"email": current_user["email"]})
-    if not user:
-        logger.warning(f"User not found: {current_user['email']}")
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="User not found"
-        )
-    
-    response = {
-        "id": str(user["_id"]),
-        "email": user["email"],
-        "full_name": user.get("full_name", ""),
-        "role": user.get("role", "patient"),
-        "specialty": user.get("specialty"),
-        "created_at": user.get("created_at"),
-        "updated_at": user.get("updated_at")
-    }
-    logger.info(f"User profile retrieved for {current_user['email']}")
-    return response
+# Include sub-routers
+router.include_router(auth.router, prefix="/auth", tags=["auth"])
+router.include_router(patients.router, prefix="/ehr", tags=["patients"])
+router.include_router(pdf.router, prefix="/ehr/patients", tags=["pdf"])