OCR & NLP Module

# Automatic tesseract path resolution
candidates = [
    os.getenv("TESSERACT_CMD"),
    shutil.which("tesseract"),
    r"C:\Program Files\Tesseract-OCR\tesseract.exe",
]
pytesseract.pytesseract.tesseract_cmd = next(c for c in candidates if c and os.path.exists(c))

# OCR configuration
OCR_CONFIG = "--oem 3 --psm 6"
# OEM 3: Default LSTM neural net mode
# PSM 6: Assume uniform block of text

import cv2
from PIL import Image

def _ocr_image(image_path: str) -> str:
    # Load image
    img = cv2.imread(image_path)
    
    # Convert to grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Otsu's binarization for adaptive thresholding
    _, binary = cv2.threshold(
        gray, 0, 255, 
        cv2.THRESH_BINARY + cv2.THRESH_OTSU
    )
    
    # Convert to PIL for Tesseract
    pil_image = Image.fromarray(binary)
    
    # Multi-language OCR
    for lang in ("spa", "spa+eng", "eng"):
        try:
            return pytesseract.image_to_string(pil_image, lang=lang)
        except:
            continue

PROMPT_GATE = (
    "Eres un triage de farmacovigilancia.\n"
    "Responde SOLO JSON: {\"es_reporte\": true|false, \"razon\": \"string\"}\n"
    "Texto:\n"
)

# Usage
is_report, reason = gemini_should_ingest(email_text)
if not is_report:
    print(f"Rejected: {reason}")  # e.g., "No menciona medicamento ni síntomas"

SYMPTOMS_RE = re.compile(
    r"\b(erupci[oó]n|sarpullido|prurito|fiebre|dolor|v[oó]mit|"
    r"n[aá]usea|mareo|urticaria|shock|anafilax|sangrado|diarrea)",
    re.I
)

DRUG_FORM_RE = re.compile(
    r"\b(mg|ml|tableta|c[aá]psula|inyecci[oó]n|vacuna|gel|crema|spray)",
    re.I
)

# Positive if: 40+ chars + symptoms + drug form
if len(text) >= 40 and SYMPTOMS_RE.search(text) and DRUG_FORM_RE.search(text):
    return True, "heurística positiva"

PROMPT_EXTRACT = (
    "Eres un extractor ICSR.\n"
    "Devuelve SOLO JSON estricto con claves presentes (no inventes valores).\n"
    "Si puedes, incluye: paciente_iniciales, paciente_edad, paciente_sexo, "
    "paciente_gestante, paciente_peso, reportante_nombre, reportante_contacto, "
    "producto_sospechoso, fecha_inicio_evento (YYYY-MM-DD), descripcion_evento, "
    "gravedad (Leve/Moderada/Grave).\n"
    "Texto:\n"
)

# Example output
{
    "paciente_iniciales": "J.D.",
    "paciente_edad": 45,
    "paciente_sexo": "M",
    "paciente_peso": 72.5,
    "producto_sospechoso": "Ibuprofeno 400 mg",
    "fecha_inicio_evento": "2025-03-01",
    "descripcion_evento": "Presentó urticaria generalizada 2 horas después de la dosis",
    "gravedad": "Moderada",
    "reportante_nombre": "Dra. María García",
    "reportante_contacto": "[email protected]"
}

F_PRONOUNS_RE = re.compile(
    r"\b(ella|srta\.?|señora|la\s+paciente|mi\s+hermana)\b",
    re.I
)
M_PRONOUNS_RE = re.compile(
    r"\b(él|sr\.?|señor|el\s+paciente|mi\s+hermano)\b",
    re.I
)
PREGNANT_POS_RE = re.compile(
    r"\b(gestante|embarazada|embarazo|pregnant)\b",
    re.I
)

def _sexo_detalle_label(sexo_char, email_text, model_gestante):
    if sexo_char == "M":
        return "Masculino"
    
    if sexo_char == "F":
        if model_gestante is True:
            return "Femenino gestante"
        if model_gestante is False:
            return "Femenino no gestante"
        if PREGNANT_POS_RE.search(email_text):
            return "Femenino gestante"
        return "Femenino"
    
    # Inference from text
    if F_PRONOUNS_RE.search(email_text):
        if PREGNANT_POS_RE.search(email_text):
            return "Femenino gestante"
        return "Femenino"
    
    if M_PRONOUNS_RE.search(email_text):
        return "Masculino"
    
    return "Desconocido"

def _norm_peso(v: Any) -> Optional[float]:
    """Normalize weight, handle g→kg conversion"""
    if isinstance(v, (int, float)):
        f = float(v)
        if f > 300:  # Likely grams
            return round(f / 1000.0, 2)
        return round(f, 2)
    
    # Parse from string
    s = str(v).lower()
    num = _to_number(s)  # Extract first number
    if "g" in s or "gramo" in s:
        return round(num / 1000.0, 2)
    return round(num, 2)

def _norm_edad(v: Any) -> int:
    """Validate age, use 30 as default"""
    n = _to_number(v)
    if n is None or n < 0 or n > 120:
        return 30
    return int(round(n))

def _norm_fecha(fecha_str, email_text):
    """Parse dates with 'este año' context awareness"""
    force_current_year = ("este año" in email_text.lower())
    
    # Try ISO format first
    try:
        d = datetime.fromisoformat(fecha_str).date()
        if force_current_year and d.year != datetime.now().year:
            d = d.replace(year=datetime.now().year)
        return d.strftime("%Y-%m-%d")
    except:
        pass
    
    # Try DMY format
    m = re.match(r"(\d{1,2})[/-](\d{1,2})[/-](\d{2,4})$", fecha_str)
    if m:
        day, month, year = map(int, m.groups())
        if force_current_year:
            year = datetime.now().year
        elif year < 100:
            year += 2000
        return datetime(year, month, day).strftime("%Y-%m-%d")

def _norm_gravedad(g, source_text):
    """Classify severity with text analysis"""
    val = str(g or "").strip().lower()
    
    # Explicit values
    if val in {"leve", "ligera", "mild"}:
        return "Leve"
    if val.startswith("modera"):
        return "Moderada"
    if val in {"grave", "severa", "severe"}:
        return "Grave"
    
    # Context clues
    txt = source_text.lower()
    if re.search(r"\bhospital|uci|urgencia|shock|muerte\b", txt):
        return "Grave"
    if re.search(r"\bmoderad", txt):
        return "Moderada"
    
    return "Leve"  # Conservative default

# Single model (fallback)
OPENAI_MODEL_EXTRACT="gpt-4o-mini"
OPENAI_MODEL_GATE="gpt-4o-mini"

# Multi-model cascade (recommended)
OPENAI_MODEL_LIST_EXTRACT="gpt-4.1,gpt-4o,gpt-4o-mini"
OPENAI_MODEL_LIST_GATE="gpt-4o-mini,gpt-4.1"

# Timeout & retries
OPENAI_TIMEOUT="20"  # seconds
OPENAI_MAX_RETRIES="2"

from app.services.gemini_extractor import current_llm_info

# After extraction
info = current_llm_info()
print(info)
# {"provider": "openai", "model": "gpt-4.1"}

# Self-test endpoint
from app.services.gemini_extractor import llm_selftest

result = llm_selftest("Paciente con urticaria tras Ibuprofeno 400mg")
print(result)
# {
#   "gate_ok": True,
#   "gate_reason": "Menciona medicamento y síntoma",
#   "extract": {"paciente_edad": 30, "producto_sospechoso": "Ibuprofeno 400mg", ...},
#   "llm": {"provider": "openai", "model": "gpt-4.1"}
# }

import pytesseract
from PIL import Image

# Get detailed OCR data
data = pytesseract.image_to_data(
    Image.open("report.jpg"),
    lang="spa",
    output_type=pytesseract.Output.DICT
)

# Filter low-confidence words
for i, conf in enumerate(data['conf']):
    if int(conf) < 60:  # 0-100 scale
        print(f"Low confidence: {data['text'][i]} ({conf}%)")