Part 3: Architecture & Internals

self.watch_directory(
    "./intake_forms",
    on_created=self._on_file_created,
    extensions=[".png", ".jpg", ".jpeg", ".pdf"],
    debounce_seconds=2.0,  # Wait for file to finish writing
)

def _convert_pdf_to_image(self, pdf_path: Path) -> bytes:
    import fitz  # PyMuPDF

    doc = fitz.open(pdf_path)
    page = doc[0]  # First page only

    # 2x zoom for better OCR quality
    matrix = fitz.Matrix(2.0, 2.0)
    pix = page.get_pixmap(matrix=matrix)

    return pix.tobytes("png")

EXTRACTION_PROMPT = """Extract patient data from this medical intake form.
Return ONLY valid JSON with these fields:
{
  "first_name": "", "last_name": "", "date_of_birth": "YYYY-MM-DD",
  "phone": "", "email": "", "address": "", "city": "", "state": "",
  "zip_code": "", "insurance_provider": "", "insurance_id": "",
  "reason_for_visit": "", "allergies": "", "medications": "",
  "emergency_contact_name": "", "emergency_contact_phone": ""
}
Use empty string "" for fields not found on the form."""

def _parse_json_safely(self, raw_text: str) -> Optional[Dict]:
    """Extract JSON even when surrounded by explanation text."""
    # Find JSON object boundaries
    brace_count = 0
    start_idx = None

    for i, char in enumerate(raw_text):
        if char == '{':
            if brace_count == 0:
                start_idx = i
            brace_count += 1
        elif char == '}':
            brace_count -= 1
            if brace_count == 0 and start_idx is not None:
                json_str = raw_text[start_idx:i+1]
                try:
                    return json.loads(json_str)
                except json.JSONDecodeError:
                    continue

    return None

def _find_existing_patient(self, data: Dict) -> Optional[int]:
    """Check if patient already exists."""
    result = self.query("""
        SELECT id FROM patients
        WHERE LOWER(first_name) = LOWER(:first_name)
          AND LOWER(last_name) = LOWER(:last_name)
          AND date_of_birth = :dob
    """, {
        "first_name": data.get("first_name", ""),
        "last_name": data.get("last_name", ""),
        "dob": data.get("date_of_birth", ""),
    })
    return result[0]["id"] if result else None

TRACKED_FIELDS = [
    "phone", "email", "address", "city", "state", "zip_code",
    "insurance_provider", "insurance_id", "medications", "allergies"
]

def _detect_changes(self, existing: Dict, new_data: Dict) -> Dict:
    """Find fields that changed since last visit."""
    changes = {}
    for field in TRACKED_FIELDS:
        old_val = existing.get(field, "")
        new_val = new_data.get(field, "")
        if old_val != new_val:
            changes[field] = {"old": old_val, "new": new_val}
    return changes

def _store_patient(self, data: Dict) -> int:
    existing_id = self._find_existing_patient(data)

    if existing_id:
        # Update returning patient
        changes = self._detect_changes(
            self._get_patient(existing_id),
            data
        )
        data["is_new_patient"] = False
        self.update("patients", existing_id, data)

        # Log changes for review
        self.insert("intake_sessions", {
            "patient_id": existing_id,
            "changes_detected": json.dumps(changes),
            "is_new_patient": False,
        })
        return existing_id
    else:
        # Insert new patient
        data["is_new_patient"] = True
        return self.insert("patients", data)

def _create_alerts(self, patient_id: int, data: Dict):
    # Allergy alert (critical)
    if data.get("allergies"):
        self.insert("alerts", {
            "patient_id": patient_id,
            "alert_type": "allergy",
            "priority": "critical",
            "message": f"Patient has allergies: {data['allergies']}",
            "acknowledged": False,
        })

    # Missing field alerts (high)
    for field in ["first_name", "last_name", "date_of_birth"]:
        if not data.get(field):
            self.insert("alerts", {
                "patient_id": patient_id,
                "alert_type": "missing_field",
                "priority": "high",
                "message": f"Missing required field: {field}",
                "acknowledged": False,
            })

# Success message
self.console.print_success(
    f"Patient record created: {data['first_name']} {data['last_name']} (ID: {patient_id})"
)

# Warning for returning patient with changes
if changes:
    self.console.print_warning(
        f"Returning patient with {len(changes)} field(s) changed - review required"
    )