┌─────────────────────────────────────────────────────────────────────────────┐
│                   EMERGENCY TRIAGE ASSISTANT ARCHITECTURE                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌───────────────────────────────────────────────────────────────────────┐  │
│  │ OFFLINE DEVICE (Tablet / Workstation)                                 │  │
│  │                                                                       │  │
│  │  ┌──────────────┐                                                     │  │
│  │  │ Patient      │  Touch-friendly symptom intake                      │  │
│  │  │ Intake UI    │                                                     │  │
│  │  └──────┬───────┘                                                     │  │
│  │         │                                                             │  │
│  │         ▼                                                             │  │
│  │  ┌──────────────────────────────────────────────────┐                 │  │
│  │  │ Conversational Engine (SLM + OPQRST)              │                 │  │
│  │  │ Onset → Provocation → Quality → Region →          │                 │  │
│  │  │ Severity → Timing                                 │                 │  │
│  │  └──────┬───────────────────────────────────────────┘                 │  │
│  │         │                                                             │  │
│  │    ┌────┴────────────────┐                                            │  │
│  │    │                     │                                            │  │
│  │    ▼                     ▼                                            │  │
│  │  ┌───────────────┐   ┌───────────────────────────┐                    │  │
│  │  │ RED FLAG       │   │ ESI CLASSIFICATION         │                    │  │
│  │  │ DETECTION      │   │                           │                    │  │
│  │  │ (Rules ONLY)   │   │ ESI-1/2: Rules (override) │                    │  │
│  │  │                │   │ ESI-3/4/5: SLM (classify) │                    │  │
│  │  └───────┬───────┘   └─────────────┬─────────────┘                    │  │
│  │          │                         │                                  │  │
│  │          └────────┬────────────────┘                                  │  │
│  │                   │                                                   │  │
│  │                   ▼                                                   │  │
│  │  ┌──────────────────────────────────────────────────┐                 │  │
│  │  │ Chief Complaint Generator                         │                 │  │
│  │  │ "[Age]yo [Sex] presenting with [complaint]..."   │                 │  │
│  │  └──────┬───────────────────────────────────────────┘                 │  │
│  │         │                                                             │  │
│  │         ▼                                                             │  │
│  │  ┌──────────────────────────────────────────────────┐                 │  │
│  │  │ Patient Queue (SQLite)                            │                 │  │
│  │  │ Sorted by: ESI level → Arrival time               │                 │  │
│  │  └──────────────────────────────────────────────────┘                 │  │
│  │                                                                       │  │
│  └───────────────────────────────────────────────────────────────────────┘  │
│                                                                             │
│  NO INTERNET ──── NO CLOUD ──── NO API CALLS ──── FULLY OFFLINE            │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

emergency-triage/
├── src/
│   ├── __init__.py
│   ├── config.py
│   ├── intake/
│   │   ├── __init__.py
│   │   ├── conversation.py      # OPQRST conversational engine
│   │   └── models.py            # Symptom intake data models
│   ├── assessment/
│   │   ├── __init__.py
│   │   ├── red_flags.py         # Rule-based red flag detection
│   │   ├── esi_classifier.py    # Hybrid ESI classification
│   │   └── chief_complaint.py   # Chief complaint generation
│   ├── models/
│   │   ├── __init__.py
│   │   └── slm_engine.py        # Local SLM inference
│   ├── queue/
│   │   ├── __init__.py
│   │   └── patient_queue.py     # SQLite priority queue
│   ├── protocols/
│   │   └── esi_algorithm.py     # ESI decision algorithm
│   └── app/
│       ├── __init__.py
│       └── tablet_ui.py          # Touch-friendly Gradio interface
├── models/                       # Downloaded GGUF models
├── data/
│   └── triage.db                # Patient queue database
├── tests/
└── requirements.txt

# src/config.py
from pydantic_settings import BaseSettings
from pathlib import Path

class Settings(BaseSettings):
    # SLM Settings (local, offline)
    slm_model_path: Path = Path("./models/qwen2.5-3b-instruct.Q4_K_M.gguf")
    slm_context_length: int = 4096
    slm_max_tokens: int = 256
    slm_temperature: float = 0.3
    slm_threads: int = 4

    # Triage Settings
    max_conversation_turns: int = 8
    default_esi_level: int = 3  # If classification fails, assume ESI-3
    red_flag_esi_override: int = 1  # Red flags → ESI-1

    # Queue Settings
    queue_db_path: Path = Path("./data/triage.db")
    re_triage_interval_minutes: int = 30

    # UI Settings
    ui_port: int = 7860
    large_font_size: int = 18  # Tablet-friendly
    button_height: int = 60    # Touch-friendly

    # ESI Color Coding
    esi_colors: dict = {
        1: "#FF0000",  # Red - Immediate
        2: "#FF6600",  # Orange - Emergent
        3: "#FFCC00",  # Yellow - Urgent
        4: "#00CC00",  # Green - Less Urgent
        5: "#0066FF",  # Blue - Non-Urgent
    }

    class Config:
        env_file = ".env"

settings = Settings()

┌─────────────────────────────────────────────────────────────────────┐
│ EMERGENCY SEVERITY INDEX (ESI) LEVELS                                 │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ESI-1  RED     Immediate    Requires immediate life-saving         │
│                              intervention (CPR, intubation)         │
│                              Example: cardiac arrest, respiratory   │
│                              failure                                │
│                                                                     │
│  ESI-2  ORANGE  Emergent     High risk, confused/lethargic,         │
│                              severe pain/distress                   │
│                              Example: chest pain, stroke symptoms   │
│                                                                     │
│  ESI-3  YELLOW  Urgent       Needs 2+ resources (labs, imaging,     │
│                              IV meds, specialist consult)           │
│                              Example: abdominal pain, fever         │
│                                                                     │
│  ESI-4  GREEN   Less Urgent  Needs 1 resource (X-ray OR labs        │
│                              OR simple procedure)                   │
│                              Example: ankle injury, laceration      │
│                                                                     │
│  ESI-5  BLUE    Non-Urgent   No resources needed (exam only)         │
│                              Example: prescription refill,          │
│                              minor cold symptoms                    │
│                                                                     │
│  CRITICAL SAFETY RULE:                                              │
│  ESI-1 and ESI-2 are ALWAYS determined by hardcoded rules.          │
│  The SLM only classifies ESI-3, ESI-4, and ESI-5.                  │
│  Misclassifying ESI-3 as ESI-4 causes a delay.                     │
│  Misclassifying ESI-1 as ESI-3 can cause death.                    │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/assessment/red_flags.py
from typing import List, Optional
from dataclasses import dataclass
from enum import Enum

class RedFlagCategory(str, Enum):
    CARDIAC = "cardiac"
    NEUROLOGICAL = "neurological"
    RESPIRATORY = "respiratory"
    TRAUMA = "trauma"
    SEPSIS = "sepsis"
    OBSTETRIC = "obstetric"
    ANAPHYLAXIS = "anaphylaxis"

@dataclass
class RedFlag:
    """A detected red flag finding."""
    name: str
    category: RedFlagCategory
    esi_override: int  # 1 or 2
    description: str
    immediate_action: str

# LIFE-THREATENING RED FLAG RULES
# THESE ARE HARDCODED - NEVER DELEGATED TO SLM
# Each rule specifies primary symptoms and associated findings

RED_FLAG_RULES = [
    # Cardiac
    {
        "name": "Acute Coronary Syndrome",
        "category": RedFlagCategory.CARDIAC,
        "primary": ["chest pain", "chest pressure", "chest tightness"],
        "associated": ["shortness of breath", "diaphoresis", "sweating",
                       "nausea", "jaw pain", "left arm pain", "arm numbness"],
        "min_associated": 1,
        "esi_override": 1,
        "action": "STAT ECG, IV access, cardiac monitor, cardiology alert"
    },
    {
        "name": "Cardiac Arrest / Unresponsive",
        "category": RedFlagCategory.CARDIAC,
        "primary": ["unresponsive", "not breathing", "no pulse",
                     "cardiac arrest", "collapsed"],
        "associated": [],
        "min_associated": 0,
        "esi_override": 1,
        "action": "Activate code blue, begin CPR, defibrillator"
    },

    # Neurological
    {
        "name": "Stroke (FAST Criteria)",
        "category": RedFlagCategory.NEUROLOGICAL,
        "primary": ["facial droop", "face drooping", "arm weakness",
                     "arm drift", "speech difficulty", "slurred speech",
                     "sudden confusion", "sudden numbness"],
        "associated": ["headache", "vision loss", "vision changes",
                       "dizziness", "loss of balance", "difficulty walking"],
        "min_associated": 0,
        "esi_override": 1,
        "action": "FAST assessment, STAT CT head, neurology alert, "
                  "document last known well time"
    },
    {
        "name": "Severe Head Injury",
        "category": RedFlagCategory.NEUROLOGICAL,
        "primary": ["head injury", "head trauma"],
        "associated": ["loss of consciousness", "vomiting", "confusion",
                       "seizure", "clear fluid from nose", "clear fluid from ear"],
        "min_associated": 1,
        "esi_override": 1,
        "action": "C-spine precautions, STAT CT head, neurosurgery consult"
    },

    # Respiratory
    {
        "name": "Respiratory Failure",
        "category": RedFlagCategory.RESPIRATORY,
        "primary": ["cannot breathe", "severe difficulty breathing",
                     "gasping", "choking", "airway obstruction"],
        "associated": ["cyanosis", "blue lips", "stridor",
                       "accessory muscle use", "tripod position"],
        "min_associated": 0,
        "esi_override": 1,
        "action": "Airway management, oxygen, prepare for intubation"
    },

    # Anaphylaxis
    {
        "name": "Anaphylaxis",
        "category": RedFlagCategory.ANAPHYLAXIS,
        "primary": ["throat swelling", "tongue swelling", "difficulty breathing",
                     "can't swallow", "allergic reaction severe"],
        "associated": ["hives", "rash", "itching", "wheezing",
                       "hypotension", "dizziness", "abdominal pain"],
        "min_associated": 1,
        "esi_override": 1,
        "action": "Epinephrine IM STAT, IV access, airway management, "
                  "monitor for biphasic reaction"
    },

    # Sepsis
    {
        "name": "Sepsis / Severe Infection",
        "category": RedFlagCategory.SEPSIS,
        "primary": ["high fever", "fever with confusion",
                     "fever with low blood pressure"],
        "associated": ["confusion", "altered mental status",
                       "rapid heart rate", "rapid breathing",
                       "cold extremities", "mottled skin"],
        "min_associated": 2,
        "esi_override": 2,
        "action": "Blood cultures STAT, lactate, broad-spectrum antibiotics, "
                  "IV fluid bolus"
    },

    # Trauma
    {
        "name": "Major Trauma",
        "category": RedFlagCategory.TRAUMA,
        "primary": ["motor vehicle accident", "mva", "fall from height",
                     "gunshot", "stabbing", "pedestrian struck"],
        "associated": ["bleeding", "deformity", "loss of consciousness",
                       "unable to move", "severe pain"],
        "min_associated": 0,
        "esi_override": 1,
        "action": "Trauma team activation, primary survey (ABCDE), "
                  "C-spine precautions"
    },

    # Obstetric
    {
        "name": "Obstetric Emergency",
        "category": RedFlagCategory.OBSTETRIC,
        "primary": ["pregnant", "pregnancy"],
        "associated": ["heavy bleeding", "vaginal bleeding",
                       "contractions", "water broke", "seizure",
                       "severe headache", "blurred vision"],
        "min_associated": 1,
        "esi_override": 2,
        "action": "OB consult STAT, fetal monitoring, IV access"
    },
]


class RedFlagDetector:
    """Detects life-threatening red flags using RULES ONLY.

    CRITICAL SAFETY DESIGN:
    Red flag detection is NEVER delegated to an LLM/SLM because:
    1. LLMs can miss critical patterns (hallucination/omission)
    2. Rule-based detection is deterministic and auditable
    3. Response time: rules execute in <1ms vs >1s for SLM
    4. Patient life depends on reliable detection
    5. Rules can be formally verified and tested exhaustively
    """

    def detect(
        self,
        symptoms: List[str],
        vital_signs: dict = None
    ) -> List[RedFlag]:
        """Detect red flags from symptoms and vitals."""
        detected = []

        # Normalize all symptoms to lowercase
        symptom_text = " ".join(s.lower() for s in symptoms)

        # Check each rule
        for rule in RED_FLAG_RULES:
            primary_match = any(
                primary in symptom_text
                for primary in rule["primary"]
            )

            if primary_match:
                associated_count = sum(
                    1 for assoc in rule["associated"]
                    if assoc in symptom_text
                )

                if associated_count >= rule["min_associated"]:
                    detected.append(RedFlag(
                        name=rule["name"],
                        category=RedFlagCategory(rule["category"]),
                        esi_override=rule["esi_override"],
                        description=f"Matched: primary symptom + "
                                   f"{associated_count} associated findings",
                        immediate_action=rule["action"]
                    ))

        # Vital sign red flags
        if vital_signs:
            vital_flags = self._check_vitals(vital_signs)
            detected.extend(vital_flags)

        return detected

    def _check_vitals(self, vitals: dict) -> List[RedFlag]:
        """Check vital signs for critical values."""
        flags = []

        # SpO2
        spo2 = vitals.get("spo2")
        if spo2 is not None:
            try:
                spo2_val = int(str(spo2).replace("%", ""))
                if spo2_val < 90:
                    flags.append(RedFlag(
                        name="Critical Hypoxemia",
                        category=RedFlagCategory.RESPIRATORY,
                        esi_override=1,
                        description=f"SpO2 {spo2_val}% (critical)",
                        immediate_action="High-flow O2, ABG, "
                                        "prepare for intubation"
                    ))
            except ValueError:
                pass

        # Heart Rate
        hr = vitals.get("heart_rate") or vitals.get("hr")
        if hr is not None:
            try:
                hr_val = int(str(hr).replace("bpm", ""))
                if hr_val > 150 or hr_val < 40:
                    flags.append(RedFlag(
                        name="Critical Heart Rate",
                        category=RedFlagCategory.CARDIAC,
                        esi_override=1,
                        description=f"HR {hr_val} bpm (critical range)",
                        immediate_action="12-lead ECG STAT, "
                                        "cardiac monitor"
                    ))
            except ValueError:
                pass

        # Systolic BP
        bp = vitals.get("blood_pressure") or vitals.get("bp")
        if bp is not None and "/" in str(bp):
            try:
                systolic = int(str(bp).split("/")[0])
                if systolic < 90:
                    flags.append(RedFlag(
                        name="Hypotension",
                        category=RedFlagCategory.CARDIAC,
                        esi_override=2,
                        description=f"SBP {systolic} mmHg (hypotension)",
                        immediate_action="IV fluid bolus, vasopressors "
                                        "if needed, identify cause"
                    ))
            except (ValueError, IndexError):
                pass

        # Temperature
        temp = vitals.get("temperature") or vitals.get("temp")
        if temp is not None:
            try:
                temp_val = float(str(temp).replace("°F", "").replace("°C", ""))
                # Assume Fahrenheit if > 45 (reasonable body temp in C is < 45)
                if temp_val > 45:
                    if temp_val > 104.0:  # >40°C
                        flags.append(RedFlag(
                            name="Hyperthermia",
                            category=RedFlagCategory.SEPSIS,
                            esi_override=2,
                            description=f"Temp {temp_val}°F (critical)",
                            immediate_action="Active cooling, blood cultures, "
                                            "broad-spectrum antibiotics"
                        ))
            except ValueError:
                pass

        return flags

    def get_highest_override(self, red_flags: List[RedFlag]) -> Optional[int]:
        """Get the most critical ESI override from detected red flags."""
        if not red_flags:
            return None
        return min(rf.esi_override for rf in red_flags)

┌─────────────────────────────────────────────────────────────────────┐
│ WHY RULES FOR LIFE-THREATENING CONDITIONS                              │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Scenario: Patient presents with chest pain + shortness of breath   │
│                                                                     │
│  RULE-BASED approach:                                               │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │ IF "chest pain" IN symptoms                                  │   │
│  │    AND ("shortness of breath" IN symptoms                    │   │
│  │         OR "diaphoresis" IN symptoms)                        │   │
│  │ THEN → ESI-1, activate cardiac protocol                     │   │
│  │                                                              │   │
│  │ Execution time: <1ms                                      │   │
│  │ Reliability: 100% for defined patterns                       │   │
│  │ False negative rate: 0% for defined patterns                 │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                     │
│  SLM-BASED approach (NOT USED for ESI-1/2):                         │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │ Prompt: "Is this life-threatening? chest pain + SOB"         │   │
│  │ SLM: "This could be cardiac in nature..." (maybe)           │   │
│  │                                                              │   │
│  │ Execution time: ~2 seconds                                   │   │
│  │ Reliability: ~90-95% (can miss, can hallucinate)             │   │
│  │ False negative rate: 5-10% (UNACCEPTABLE for ESI-1)          │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                     │
│  In emergency medicine, a 5% miss rate on critical patients         │
│  means 1 in 20 heart attacks gets delayed triage.                   │
│  This is why rules OVERRIDE the SLM for ESI-1 and ESI-2.           │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/assessment/esi_classifier.py
from typing import Optional, List, Tuple
from dataclasses import dataclass
from llama_cpp import Llama
from .red_flags import RedFlagDetector, RedFlag
from ..config import settings

@dataclass
class ESIResult:
    """ESI classification result."""
    level: int  # 1-5
    label: str  # "Immediate", "Emergent", "Urgent", etc.
    reasoning: str
    confidence: float  # 0-1
    method: str  # "rule" or "slm"
    red_flags: List[RedFlag]
    resource_estimate: int  # Expected number of ED resources needed

ESI_LABELS = {
    1: "Immediate",
    2: "Emergent",
    3: "Urgent",
    4: "Less Urgent",
    5: "Non-Urgent"
}


class ESIClassifier:
    """Hybrid ESI classifier: rules for ESI-1/2, SLM for ESI-3/4/5.

    The ESI algorithm is a 5-level triage system:
    - ESI-1/2: Based on acuity (is it life-threatening?)
    - ESI-3/4/5: Based on expected resource needs

    Safety design:
    - Rules ALWAYS override SLM for life-threatening conditions
    - SLM only classifies when rules confirm no emergency
    - Default to ESI-3 if SLM classification fails
    """

    def __init__(self):
        self.red_flag_detector = RedFlagDetector()
        self.llm = Llama(
            model_path=str(settings.slm_model_path),
            n_ctx=settings.slm_context_length,
            n_threads=settings.slm_threads,
            n_gpu_layers=0,
            verbose=False
        )

    def classify(
        self,
        symptoms: List[str],
        vital_signs: dict = None,
        age: int = None,
        sex: str = None
    ) -> ESIResult:
        """Classify patient ESI level."""
        # Step 1: ALWAYS check red flags first (rules)
        red_flags = self.red_flag_detector.detect(symptoms, vital_signs)
        esi_override = self.red_flag_detector.get_highest_override(red_flags)

        # Step 2: If red flags detected, use rule-based ESI
        if esi_override is not None:
            return ESIResult(
                level=esi_override,
                label=ESI_LABELS[esi_override],
                reasoning=f"Red flags detected: "
                         f"{', '.join(rf.name for rf in red_flags)}",
                confidence=1.0,  # Rules are deterministic
                method="rule",
                red_flags=red_flags,
                resource_estimate=5  # Assume max resources for ESI-1/2
            )

        # Step 3: No red flags → SLM classifies ESI-3/4/5
        return self._slm_classify(symptoms, vital_signs, age, sex)

    def _slm_classify(
        self,
        symptoms: List[str],
        vital_signs: dict = None,
        age: int = None,
        sex: str = None
    ) -> ESIResult:
        """Classify ESI-3/4/5 using SLM based on resource needs."""
        symptoms_text = ", ".join(symptoms)
        vitals_text = ", ".join(
            f"{k}: {v}" for k, v in (vital_signs or {}).items()
        ) or "within normal limits"

        demographics = ""
        if age:
            demographics += f"Age: {age}"
        if sex:
            demographics += f", Sex: {sex}"

        prompt = f"""<|im_start|>system
You are an emergency department triage assistant. Classify the patient's
ESI level based on expected resource needs.

ESI-3 (Urgent): Needs 2+ resources (labs AND imaging, IV meds AND consult)
ESI-4 (Less Urgent): Needs 1 resource (X-ray OR labs OR simple procedure)
ESI-5 (Non-Urgent): No resources needed (exam only, prescription refill)

Resources include: labs, imaging (X-ray/CT/MRI), IV medications,
specialist consult, procedures (sutures, splinting).

IMPORTANT: Only classify as ESI-3, ESI-4, or ESI-5. Life-threatening
conditions have already been ruled out.

Respond with JSON: {{"esi_level": 3|4|5, "resources": N, "reasoning": "..."}}
<|im_end|>
<|im_start|>user
Patient: {demographics}
Symptoms: {symptoms_text}
Vitals: {vitals_text}

Classify ESI level based on expected resource needs.
<|im_end|>
<|im_start|>assistant
"""

        response = self.llm(
            prompt,
            max_tokens=150,
            temperature=0.1,
            stop=["<|im_end|>", "</s>"]
        )

        result_text = response["choices"][0]["text"].strip()

        # Parse SLM response
        try:
            import json
            parsed = json.loads(result_text)
            esi_level = int(parsed.get("esi_level", 3))

            # Safety: SLM can only assign ESI-3, 4, or 5
            if esi_level not in (3, 4, 5):
                esi_level = settings.default_esi_level

            resources = int(parsed.get("resources", 2))
            reasoning = parsed.get("reasoning", "")

            return ESIResult(
                level=esi_level,
                label=ESI_LABELS[esi_level],
                reasoning=reasoning,
                confidence=0.8,  # SLM classification
                method="slm",
                red_flags=[],
                resource_estimate=resources
            )
        except (json.JSONDecodeError, ValueError, KeyError):
            # Fallback: default to ESI-3 (safest non-emergency default)
            return ESIResult(
                level=settings.default_esi_level,
                label=ESI_LABELS[settings.default_esi_level],
                reasoning="Classification uncertain, defaulting to ESI-3",
                confidence=0.5,
                method="slm_fallback",
                red_flags=[],
                resource_estimate=2
            )

┌─────────────────────────────────────────────────────────────────────┐
│ ESI TRIAGE DECISION FLOW                                              │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Patient presents                                                   │
│       │                                                             │
│       ▼                                                             │
│  ┌──────────────────────────────────────┐                           │
│  │ RED FLAG CHECK (Rules)               │                           │
│  │ Life-threatening condition?           │                           │
│  └───────────┬──────────────────────────┘                           │
│         YES  │  NO                                                  │
│       ┌──────┘  └──────┐                                            │
│       ▼                ▼                                            │
│  ┌─────────┐    ┌──────────────────────────────────────┐            │
│  │ ESI-1   │    │ HIGH RISK? (Rules)                    │            │
│  │ or      │    │ Confused, lethargic, severe distress? │            │
│  │ ESI-2   │    └───────────┬──────────────────────────┘            │
│  │ (RULE)  │          YES   │  NO                                   │
│  └─────────┘        ┌──────┘  └──────┐                              │
│                     ▼                ▼                              │
│                ┌─────────┐    ┌──────────────────────────┐          │
│                │ ESI-2   │    │ HOW MANY RESOURCES?       │          │
│                │ (RULE)  │    │ (SLM classifies)          │          │
│                └─────────┘    └───────────┬──────────────┘          │
│                                      ┌────┼────┐                    │
│                                      ▼    ▼    ▼                    │
│                                   2+     1    0                    │
│                                  ESI-3  ESI-4  ESI-5               │
│                                  (SLM)  (SLM)  (SLM)              │
│                                                                     │
│  SAFETY: Rules handle ESI-1/2 (life-threatening)                    │
│  SLM handles ESI-3/4/5 (resource-based classification)              │
│  If SLM fails → default to ESI-3 (safest assumption)               │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/intake/models.py
from pydantic import BaseModel, Field
from typing import List, Optional, Dict
from datetime import datetime

class SymptomIntake(BaseModel):
    """Complete symptom intake from OPQRST assessment."""
    onset: Optional[str] = Field(None, description="When did it start?")
    provocation: Optional[str] = Field(
        None, description="What makes it better/worse?"
    )
    quality: Optional[str] = Field(
        None, description="What does it feel like?"
    )
    region: Optional[str] = Field(
        None, description="Where is it? Does it radiate?"
    )
    severity: Optional[int] = Field(
        None, ge=0, le=10, description="Pain scale 0-10"
    )
    timing: Optional[str] = Field(
        None, description="Constant, intermittent, worsening?"
    )
    additional_symptoms: List[str] = Field(default_factory=list)
    vital_signs: Dict[str, str] = Field(default_factory=dict)

class PatientRecord(BaseModel):
    """Complete patient triage record."""
    patient_id: str
    age: int
    sex: str
    chief_complaint: str
    symptom_intake: SymptomIntake
    esi_level: int
    esi_label: str
    esi_method: str
    red_flags: List[str] = Field(default_factory=list)
    chief_complaint_formatted: str = ""
    arrival_time: datetime = Field(default_factory=datetime.now)
    triage_time: Optional[datetime] = None
    status: str = "waiting"  # waiting, in_treatment, discharged

# src/intake/conversation.py
from typing import List, Dict, Optional, Tuple
from llama_cpp import Llama
from .models import SymptomIntake
from ..config import settings

class ConversationEngine:
    """Structured symptom intake using OPQRST framework.

    OPQRST is a standard triage assessment mnemonic:
    - Onset: When did it start?
    - Provocation/Palliation: What makes it better or worse?
    - Quality: What does it feel like? (sharp, dull, burning...)
    - Region/Radiation: Where is it? Does it spread?
    - Severity: Pain scale 0-10
    - Timing: Constant? Intermittent? Getting worse?
    """

    OPQRST_QUESTIONS = [
        {
            "phase": "onset",
            "question": "When did this start? How long have you been "
                       "experiencing this?",
            "follow_up": "Did it come on suddenly or gradually?"
        },
        {
            "phase": "provocation",
            "question": "Is there anything that makes it better or worse? "
                       "Any activity that triggers it?",
            "follow_up": "Does rest help? Does movement make it worse?"
        },
        {
            "phase": "quality",
            "question": "Can you describe what it feels like? "
                       "For example: sharp, dull, burning, pressure?",
            "follow_up": None
        },
        {
            "phase": "region",
            "question": "Where exactly do you feel it? "
                       "Does it spread to any other area?",
            "follow_up": "Can you point to the area?"
        },
        {
            "phase": "severity",
            "question": "On a scale of 0 to 10, where 0 is no pain and "
                       "10 is the worst pain imaginable, how would you rate it?",
            "follow_up": None
        },
        {
            "phase": "timing",
            "question": "Is it constant or does it come and go? "
                       "Is it getting better, worse, or staying the same?",
            "follow_up": None
        },
        {
            "phase": "additional",
            "question": "Are you experiencing any other symptoms? "
                       "Such as nausea, dizziness, fever, or shortness of breath?",
            "follow_up": "Any recent injuries, surgeries, or new medications?"
        }
    ]

    def __init__(self):
        self.llm = Llama(
            model_path=str(settings.slm_model_path),
            n_ctx=settings.slm_context_length,
            n_threads=settings.slm_threads,
            n_gpu_layers=0,
            verbose=False
        )
        self.conversation_history: List[Dict] = []
        self.current_phase_index: int = 0
        self.intake: SymptomIntake = SymptomIntake()

    def get_next_question(self) -> Optional[str]:
        """Get the next OPQRST question."""
        if self.current_phase_index >= len(self.OPQRST_QUESTIONS):
            return None

        phase = self.OPQRST_QUESTIONS[self.current_phase_index]
        return phase["question"]

    def process_response(
        self,
        patient_response: str
    ) -> Tuple[str, bool]:
        """Process patient response and return next question or summary.

        Returns:
            Tuple of (next_question_or_summary, is_complete)
        """
        if self.current_phase_index >= len(self.OPQRST_QUESTIONS):
            return self._generate_summary(), True

        phase = self.OPQRST_QUESTIONS[self.current_phase_index]
        phase_name = phase["phase"]

        # Store response in intake
        self._store_response(phase_name, patient_response)

        # Store in conversation history
        self.conversation_history.append({
            "role": "assistant",
            "content": phase["question"]
        })
        self.conversation_history.append({
            "role": "user",
            "content": patient_response
        })

        # Check if follow-up is needed
        if (phase.get("follow_up") and
                self._needs_follow_up(phase_name, patient_response)):
            return phase["follow_up"], False

        # Move to next phase
        self.current_phase_index += 1

        # Check if intake is complete
        if self.current_phase_index >= len(self.OPQRST_QUESTIONS):
            return self._generate_summary(), True

        # Return next question
        next_question = self.OPQRST_QUESTIONS[
            self.current_phase_index
        ]["question"]
        return next_question, False

    def _store_response(self, phase: str, response: str):
        """Store patient response in the intake model."""
        if phase == "onset":
            self.intake.onset = response
        elif phase == "provocation":
            self.intake.provocation = response
        elif phase == "quality":
            self.intake.quality = response
        elif phase == "region":
            self.intake.region = response
        elif phase == "severity":
            try:
                # Extract number from response
                import re
                numbers = re.findall(r'\d+', response)
                if numbers:
                    severity = int(numbers[0])
                    self.intake.severity = min(max(severity, 0), 10)
            except ValueError:
                pass
        elif phase == "timing":
            self.intake.timing = response
        elif phase == "additional":
            # Parse additional symptoms using SLM
            additional = self._extract_additional_symptoms(response)
            self.intake.additional_symptoms = additional

    def _needs_follow_up(self, phase: str, response: str) -> bool:
        """Determine if a follow-up question is needed."""
        response_lower = response.lower()

        # Very short or vague responses may need follow-up
        if len(response.split()) < 3:
            return True

        # "I don't know" type responses
        if any(phrase in response_lower for phrase in [
            "don't know", "not sure", "i guess", "maybe"
        ]):
            return True

        return False

    def _extract_additional_symptoms(
        self,
        response: str
    ) -> List[str]:
        """Extract symptom list from free-text response using SLM."""
        prompt = f"""<|im_start|>system
Extract individual symptoms from the patient's response.
Return a JSON array of symptoms. Only include symptoms explicitly mentioned.
<|im_end|>
<|im_start|>user
Patient said: "{response}"

Extract symptoms as JSON array.
<|im_end|>
<|im_start|>assistant
"""

        result = self.llm(
            prompt,
            max_tokens=100,
            temperature=0.1,
            stop=["<|im_end|>", "</s>"]
        )

        text = result["choices"][0]["text"].strip()

        try:
            import json
            symptoms = json.loads(text)
            if isinstance(symptoms, list):
                return [s for s in symptoms if isinstance(s, str)]
        except Exception:
            pass

        # Fallback: split by commas
        return [s.strip() for s in response.split(",") if s.strip()]

    def _generate_summary(self) -> str:
        """Generate intake summary."""
        parts = []
        if self.intake.onset:
            parts.append(f"Onset: {self.intake.onset}")
        if self.intake.quality:
            parts.append(f"Quality: {self.intake.quality}")
        if self.intake.region:
            parts.append(f"Location: {self.intake.region}")
        if self.intake.severity is not None:
            parts.append(f"Severity: {self.intake.severity}/10")
        if self.intake.timing:
            parts.append(f"Timing: {self.intake.timing}")
        if self.intake.additional_symptoms:
            parts.append(
                f"Additional: {', '.join(self.intake.additional_symptoms)}"
            )

        return "Intake complete.\n" + "\n".join(parts)

    def get_all_symptoms(self) -> List[str]:
        """Get all symptoms collected during intake."""
        symptoms = []
        if self.intake.quality:
            symptoms.append(self.intake.quality)
        if self.intake.region:
            symptoms.append(f"pain in {self.intake.region}")
        symptoms.extend(self.intake.additional_symptoms)
        return symptoms

    def reset(self):
        """Reset for a new patient."""
        self.conversation_history = []
        self.current_phase_index = 0
        self.intake = SymptomIntake()

┌─────────────────────────────────────────────────────────────────────┐
│ OPQRST TRIAGE ASSESSMENT FRAMEWORK                                    │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  O - Onset          "When did it start?"                            │
│  │                  └── Sudden onset → more urgent                  │
│  │                                                                  │
│  P - Provocation    "What makes it better/worse?"                   │
│  │                  └── Worse with exertion → cardiac concern       │
│  │                                                                  │
│  Q - Quality        "What does it feel like?"                       │
│  │                  └── "Pressure/squeezing" → cardiac              │
│  │                     "Sharp/stabbing" → pleuritic/MSK             │
│  │                                                                  │
│  R - Region         "Where? Does it spread?"                        │
│  │                  └── Radiates to arm/jaw → cardiac concern       │
│  │                                                                  │
│  S - Severity       "Scale 0-10?"                                   │
│  │                  └── 8-10 → likely ESI-2 or ESI-3                │
│  │                                                                  │
│  T - Timing         "Constant or intermittent?"                     │
│                     └── Worsening → higher acuity                   │
│                                                                     │
│  WHY STRUCTURED INTAKE:                                             │
│  • Ensures no critical questions are missed                         │
│  • Standard format recognized by all ED staff                       │
│  • Reproducible assessment regardless of who triages                │
│  • SLM asks questions in order, patient responds naturally          │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/assessment/chief_complaint.py
from llama_cpp import Llama
from ..intake.models import SymptomIntake
from ..config import settings

class ChiefComplaintGenerator:
    """Generate standard ED chief complaint format.

    Standard format:
    "[Age]yo [Sex] presenting with [complaint] for [duration],
     associated with [associated symptoms]."

    This is the first line of the medical record and must be
    clear, concise, and in standard medical terminology.
    """

    def __init__(self):
        self.llm = Llama(
            model_path=str(settings.slm_model_path),
            n_ctx=settings.slm_context_length,
            n_threads=settings.slm_threads,
            n_gpu_layers=0,
            verbose=False
        )

    def generate(
        self,
        age: int,
        sex: str,
        intake: SymptomIntake,
        raw_complaint: str = ""
    ) -> str:
        """Generate a formatted chief complaint."""
        sex_full = "male" if sex.upper() == "M" else "female"

        symptoms_info = []
        if intake.quality:
            symptoms_info.append(f"character: {intake.quality}")
        if intake.region:
            symptoms_info.append(f"location: {intake.region}")
        if intake.onset:
            symptoms_info.append(f"onset: {intake.onset}")
        if intake.severity is not None:
            symptoms_info.append(f"severity: {intake.severity}/10")
        if intake.additional_symptoms:
            symptoms_info.append(
                f"associated: {', '.join(intake.additional_symptoms)}"
            )

        prompt = f"""<|im_start|>system
Generate a standard emergency department chief complaint in this format:
"[Age]yo [Sex] presenting with [primary complaint] for [duration], [additional details]."

Rules:
- Use standard medical abbreviations (yo, M/F, c/o, w/)
- One sentence, concise
- Include duration if known
- Include key associated symptoms
- Use medical terminology
<|im_end|>
<|im_start|>user
Age: {age}, Sex: {sex_full}
Raw complaint: {raw_complaint}
Assessment details: {'; '.join(symptoms_info)}

Generate the chief complaint line.
<|im_end|>
<|im_start|>assistant
"""

        response = self.llm(
            prompt,
            max_tokens=100,
            temperature=0.2,
            stop=["<|im_end|>", "</s>", "\n\n"]
        )

        result = response["choices"][0]["text"].strip()

        # Ensure it starts with age/sex if SLM didn't format correctly
        if not result.startswith(str(age)):
            sex_abbr = "M" if sex.upper() == "M" else "F"
            result = f"{age}yo {sex_abbr} presenting with {result}"

        return result

# src/queue/patient_queue.py
import sqlite3
import json
from typing import List, Optional, Dict
from datetime import datetime
from ..intake.models import PatientRecord
from ..config import settings

class PatientQueue:
    """SQLite-based patient priority queue.

    Patients are sorted by:
    1. ESI level (1 = highest priority)
    2. Arrival time (FIFO within same ESI level)

    This matches standard ED triage practice: sickest patients
    are seen first, and among equally sick patients, the one
    who arrived first is seen first.
    """

    def __init__(self):
        self.db_path = str(settings.queue_db_path)
        self._init_db()

    def _init_db(self):
        """Initialize queue database."""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute("""
            CREATE TABLE IF NOT EXISTS patient_queue (
                patient_id TEXT PRIMARY KEY,
                age INTEGER,
                sex TEXT,
                chief_complaint TEXT,
                chief_complaint_formatted TEXT,
                esi_level INTEGER NOT NULL,
                esi_label TEXT,
                esi_method TEXT,
                red_flags TEXT,
                symptom_data TEXT,
                arrival_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                triage_time TIMESTAMP,
                status TEXT DEFAULT 'waiting',
                notes TEXT DEFAULT ''
            )
        """)

        cursor.execute("""
            CREATE INDEX IF NOT EXISTS idx_esi_arrival
            ON patient_queue(esi_level, arrival_time)
        """)

        conn.commit()
        conn.close()

    def add_patient(self, record: PatientRecord):
        """Add a patient to the queue."""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute("""
            INSERT OR REPLACE INTO patient_queue
            (patient_id, age, sex, chief_complaint,
             chief_complaint_formatted, esi_level, esi_label,
             esi_method, red_flags, symptom_data,
             arrival_time, triage_time, status)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        """, (
            record.patient_id,
            record.age,
            record.sex,
            record.chief_complaint,
            record.chief_complaint_formatted,
            record.esi_level,
            record.esi_label,
            record.esi_method,
            json.dumps(record.red_flags),
            json.dumps(record.symptom_intake.model_dump()),
            record.arrival_time.isoformat(),
            record.triage_time.isoformat() if record.triage_time else None,
            record.status
        ))

        conn.commit()
        conn.close()

    def get_queue(self, status: str = "waiting") -> List[Dict]:
        """Get current queue sorted by ESI level then arrival time."""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute("""
            SELECT patient_id, age, sex, chief_complaint_formatted,
                   esi_level, esi_label, esi_method, red_flags,
                   arrival_time, status
            FROM patient_queue
            WHERE status = ?
            ORDER BY esi_level ASC, arrival_time ASC
        """, (status,))

        rows = cursor.fetchall()
        conn.close()

        return [
            {
                "patient_id": r[0],
                "age": r[1],
                "sex": r[2],
                "chief_complaint": r[3],
                "esi_level": r[4],
                "esi_label": r[5],
                "esi_method": r[6],
                "red_flags": json.loads(r[7] or "[]"),
                "arrival_time": r[8],
                "status": r[9]
            }
            for r in rows
        ]

    def update_status(self, patient_id: str, status: str):
        """Update patient status."""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute(
            "UPDATE patient_queue SET status = ? WHERE patient_id = ?",
            (status, patient_id)
        )

        conn.commit()
        conn.close()

    def re_triage(self, patient_id: str, new_esi: int):
        """Re-triage a patient with a new ESI level."""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute("""
            UPDATE patient_queue
            SET esi_level = ?, esi_label = ?, triage_time = ?
            WHERE patient_id = ?
        """, (
            new_esi,
            {1: "Immediate", 2: "Emergent", 3: "Urgent",
             4: "Less Urgent", 5: "Non-Urgent"}.get(new_esi, "Unknown"),
            datetime.now().isoformat(),
            patient_id
        ))

        conn.commit()
        conn.close()

    def get_stats(self) -> Dict:
        """Get queue statistics."""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute("""
            SELECT esi_level, COUNT(*), status
            FROM patient_queue
            WHERE status = 'waiting'
            GROUP BY esi_level
        """)
        by_esi = {}
        for row in cursor.fetchall():
            by_esi[f"ESI-{row[0]}"] = row[1]

        cursor.execute(
            "SELECT COUNT(*) FROM patient_queue WHERE status = 'waiting'"
        )
        total_waiting = cursor.fetchone()[0]

        cursor.execute(
            "SELECT COUNT(*) FROM patient_queue WHERE status = 'in_treatment'"
        )
        total_in_treatment = cursor.fetchone()[0]

        conn.close()

        return {
            "total_waiting": total_waiting,
            "total_in_treatment": total_in_treatment,
            "by_esi_level": by_esi
        }

    def remove_patient(self, patient_id: str):
        """Remove a patient from the queue (discharged/left)."""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute(
            "UPDATE patient_queue SET status = 'discharged' "
            "WHERE patient_id = ?",
            (patient_id,)
        )

        conn.commit()
        conn.close()

# src/app/tablet_ui.py
import gradio as gr
import uuid
from datetime import datetime

from ..intake.conversation import ConversationEngine
from ..assessment.esi_classifier import ESIClassifier
from ..assessment.chief_complaint import ChiefComplaintGenerator
from ..intake.models import PatientRecord
from ..queue.patient_queue import PatientQueue
from ..config import settings

# Initialize components
esi_classifier = ESIClassifier()
complaint_gen = ChiefComplaintGenerator()
queue = PatientQueue()

# Session state
conversation_engines = {}


def start_triage(age, sex, chief_complaint):
    """Start a new triage session."""
    session_id = str(uuid.uuid4())[:8]

    engine = ConversationEngine()
    conversation_engines[session_id] = {
        "engine": engine,
        "age": age,
        "sex": sex,
        "chief_complaint": chief_complaint,
        "started": datetime.now()
    }

    first_question = engine.get_next_question()
    history = [
        (None, f"Starting triage for {age}yo {sex} - "
               f"Chief complaint: {chief_complaint}"),
        (None, first_question)
    ]

    return session_id, history, gr.update(interactive=True)


def process_intake(session_id, patient_response, chat_history):
    """Process patient response during intake."""
    if session_id not in conversation_engines:
        return chat_history + [
            (patient_response, "Session expired. Please start new triage.")
        ], "", gr.update()

    session = conversation_engines[session_id]
    engine = session["engine"]

    # Process response
    next_output, is_complete = engine.process_response(patient_response)

    # Update chat
    chat_history = chat_history + [(patient_response, next_output)]

    if is_complete:
        # Run ESI classification
        symptoms = engine.get_all_symptoms()
        symptoms.append(session["chief_complaint"])

        esi_result = esi_classifier.classify(
            symptoms=symptoms,
            vital_signs=engine.intake.vital_signs,
            age=session["age"],
            sex=session["sex"]
        )

        # Generate chief complaint
        formatted_cc = complaint_gen.generate(
            age=session["age"],
            sex=session["sex"],
            intake=engine.intake,
            raw_complaint=session["chief_complaint"]
        )

        # Create patient record
        patient_id = f"PT-{session_id}"
        record = PatientRecord(
            patient_id=patient_id,
            age=session["age"],
            sex=session["sex"],
            chief_complaint=session["chief_complaint"],
            symptom_intake=engine.intake,
            esi_level=esi_result.level,
            esi_label=esi_result.label,
            esi_method=esi_result.method,
            red_flags=[rf.name for rf in esi_result.red_flags],
            chief_complaint_formatted=formatted_cc,
            triage_time=datetime.now()
        )

        # Add to queue
        queue.add_patient(record)

        # Format result
        esi_color = settings.esi_colors.get(esi_result.level, "#888888")
        result_text = (
            f"\n---\n"
            f"**TRIAGE RESULT**\n\n"
            f"**ESI Level: {esi_result.level} - {esi_result.label}**\n"
            f"Method: {esi_result.method}\n"
            f"Confidence: {esi_result.confidence:.0%}\n\n"
            f"**Chief Complaint:** {formatted_cc}\n"
        )

        if esi_result.red_flags:
            result_text += "\n**RED FLAGS:**\n"
            for rf in esi_result.red_flags:
                result_text += f"- {rf.name}: {rf.immediate_action}\n"

        result_text += f"\nPatient added to queue as {patient_id}"

        chat_history = chat_history + [(None, result_text)]

        # Cleanup session
        del conversation_engines[session_id]

    return chat_history, "", gr.update()


def get_queue_display():
    """Get formatted queue display."""
    patients = queue.get_queue()
    stats = queue.get_stats()

    if not patients:
        return "No patients in queue."

    display = f"**Queue: {stats['total_waiting']} waiting, "
    display += f"{stats['total_in_treatment']} in treatment**\n\n"

    for p in patients:
        esi = p["esi_level"]
        color = settings.esi_colors.get(esi, "#888888")
        flags = " [RED FLAGS]" if p["red_flags"] else ""

        display += (
            f"**ESI-{esi}** | {p['patient_id']} | "
            f"{p['chief_complaint'] or 'No CC'}{flags} | "
            f"Arrived: {p['arrival_time'][:16]}\n\n"
        )

    return display


def update_patient_status(patient_id, new_status):
    """Update a patient's status."""
    if patient_id and new_status:
        queue.update_status(patient_id.strip(), new_status)
    return get_queue_display()


def create_tablet_interface():
    """Create touch-friendly tablet interface."""
    with gr.Blocks(
        title="Emergency Triage",
        css="""
        .gradio-container { font-size: 18px !important; }
        button { min-height: 60px !important; font-size: 18px !important; }
        input, textarea { font-size: 18px !important; }
        """
    ) as demo:
        gr.Markdown("# Emergency Triage Assistant")
        gr.Markdown(
            "_Offline triage support - All classifications must be "
            "verified by triage nurse_"
        )

        with gr.Tabs():
            # Tab 1: Patient Intake
            with gr.Tab("New Patient"):
                with gr.Row():
                    age_input = gr.Number(
                        label="Age", value=45, minimum=0, maximum=120
                    )
                    sex_input = gr.Radio(
                        ["M", "F"], label="Sex", value="M"
                    )
                complaint_input = gr.Textbox(
                    label="Chief Complaint",
                    placeholder="e.g., chest pain, headache, fall..."
                )
                start_btn = gr.Button(
                    "Start Triage",
                    variant="primary"
                )

                session_state = gr.State("")
                chatbot = gr.Chatbot(
                    label="Triage Assessment",
                    height=400
                )
                response_input = gr.Textbox(
                    label="Patient Response",
                    placeholder="Enter patient's response..."
                )
                submit_btn = gr.Button("Submit Response")

                start_btn.click(
                    start_triage,
                    inputs=[age_input, sex_input, complaint_input],
                    outputs=[session_state, chatbot, submit_btn]
                )

                submit_btn.click(
                    process_intake,
                    inputs=[session_state, response_input, chatbot],
                    outputs=[chatbot, response_input, submit_btn]
                )

            # Tab 2: Patient Queue
            with gr.Tab("Queue"):
                refresh_btn = gr.Button("Refresh Queue")
                queue_display = gr.Markdown(
                    value=get_queue_display()
                )

                with gr.Row():
                    patient_id_input = gr.Textbox(
                        label="Patient ID",
                        placeholder="PT-xxxxxxxx"
                    )
                    status_select = gr.Radio(
                        ["in_treatment", "discharged"],
                        label="New Status"
                    )
                    update_btn = gr.Button("Update Status")

                refresh_btn.click(
                    get_queue_display,
                    outputs=[queue_display]
                )
                update_btn.click(
                    update_patient_status,
                    inputs=[patient_id_input, status_select],
                    outputs=[queue_display]
                )

            # Tab 3: Statistics
            with gr.Tab("Stats"):
                stats_btn = gr.Button("Refresh Stats")
                stats_display = gr.JSON(label="Queue Statistics")

                stats_btn.click(
                    lambda: queue.get_stats(),
                    outputs=[stats_display]
                )

        gr.Markdown("""
        ### Notice
        - This system assists trained triage personnel
        - All ESI classifications must be verified by qualified staff
        - Red flag alerts require immediate clinical attention
        - System operates fully offline
        """)

    return demo


if __name__ == "__main__":
    demo = create_tablet_interface()
    demo.launch(
        server_name="0.0.0.0",
        server_port=settings.ui_port
    )

# docker-compose.yml
version: '3.8'

services:
  triage-app:
    build: .
    ports:
      - "7860:7860"
    volumes:
      - ./models:/app/models
      - ./data:/app/data
    environment:
      - SLM_MODEL_PATH=/app/models/qwen2.5-3b-instruct.Q4_K_M.gguf

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY src/ ./src/

EXPOSE 7860

CMD ["python", "-m", "src.app.tablet_ui"]

# build_tablet.py
"""Build standalone application for tablet deployment."""
import PyInstaller.__main__

PyInstaller.__main__.run([
    'src/app/tablet_ui.py',
    '--name=TriageAssistant',
    '--onedir',
    '--add-data=models:models',
    '--add-data=data:data',
    '--hidden-import=llama_cpp',
    '--hidden-import=sentence_transformers',
])

# requirements.txt
llama-cpp-python>=0.3.0
sentence-transformers>=3.0.0
gradio>=4.40.0
pydantic>=2.9.0
pydantic-settings>=2.5.0
numpy>=1.26.0