from typing import Dict, List

from fastapi import APIRouter, UploadFile, File, HTTPException, Depends

from app.auth import get_current_user
from app.config import config
from app.core.dependencies import get_services
from app.core.services import AppServices
from app.services.soat_processing import (
    _agente_codificar_desde_soat_item,
    _generar_resumen_validacion,
    _parsear_respuesta_gemini_codigos,
    _validar_codigo_soat_con_documento,
)
from modules.processing.soat.soat_indexer import build_soat_index_from_pdf
from modules.processing.soat.soat_retriever import SOATRetriever

router = APIRouter()
@router.post("/soat/indexar_pdf")
async def soat_indexar_pdf(file: UploadFile = File(...), current_user = Depends(get_current_user), services: AppServices = Depends(get_services)):
    base_dir = services.base_dir
    mongo_storage = services.mongo_storage
    mongo = services.mongo_analyses
    client_groq = services.client_groq
    client_gemini = services.client_gemini
    retriever = services.cie10_retriever
    cups_retriever = services.cups_retriever
    soat_retriever = services.soat_retriever
    colombia_tz = services.colombia_tz
    soat_index_dir = "soat_faiss"
    try:
        contents = await file.read()
        tmp_path = base_dir / "_tmp_soat.pdf"
        with open(tmp_path, "wb") as f:
            f.write(contents)
        index_dir = build_soat_index_from_pdf(str(tmp_path), str(base_dir / soat_index_dir))
        services.soat_retriever = SOATRetriever(
            faiss_index_path=index_dir,
            groq_api_key=config.GROQ_API_KEY,
        )
        return {"mensaje": "Índice SOAT construido", "index_dir": index_dir}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@router.post("/soat/codificar")
async def soat_codificar(data: dict, current_user = Depends(get_current_user), services: AppServices = Depends(get_services)):
    base_dir = services.base_dir
    mongo_storage = services.mongo_storage
    mongo = services.mongo_analyses
    client_groq = services.client_groq
    client_gemini = services.client_gemini
    retriever = services.cie10_retriever
    cups_retriever = services.cups_retriever
    soat_retriever = services.soat_retriever
    colombia_tz = services.colombia_tz
    soat_index_dir = "soat_faiss"
    if not soat_retriever:
        raise HTTPException(status_code=400, detail="Índice SOAT no inicializado")
    procedimientos = data.get("procedimientos") or []
    if not isinstance(procedimientos, list) or not procedimientos:
        raise HTTPException(status_code=400, detail="Procedimientos requeridos")
    resultados = soat_retriever.asignar_codigos(procedimientos)
    return {"resultados": resultados}

@router.post("/agente/codificar_desde_soat")
async def agente_codificar_desde_soat(payload: Dict, current_user = Depends(get_current_user), services: AppServices = Depends(get_services)):
    """Dado un conjunto de códigos/descripciones SOAT, propone CUPS y CIE‑10 óptimos con justificación y evidencia."""
    base_dir = services.base_dir
    mongo_storage = services.mongo_storage
    mongo = services.mongo_analyses
    client_groq = services.client_groq
    client_gemini = services.client_gemini
    retriever = services.cie10_retriever
    cups_retriever = services.cups_retriever
    soat_retriever = services.soat_retriever
    colombia_tz = services.colombia_tz
    soat_index_dir = "soat_faiss"
    items = payload.get("items") or []
    if not isinstance(items, list) or not items:
        raise HTTPException(status_code=400, detail="'items' debe ser una lista no vacía")
    resultados = []
    for item in items:
        try:
            resultados.append(_agente_codificar_desde_soat_item(item, soat_retriever, retriever, cups_retriever, client_groq, client_gemini))
        except Exception as e:
            resultados.append({"input": item, "error": str(e)})
    return {"resultados": resultados}

@router.post("/agente/analizar_hallazgos_qx")
async def agente_analizar_hallazgos_qx(payload: Dict, current_user = Depends(get_current_user), services: AppServices = Depends(get_services)):
    """
    Analiza Hallazgos y Descripción Quirúrgica para proponer CIE-10 y CUPS
    y devolverlos en formato compatible con la lista seleccionable de epicrisis.
    """
    hallazgos = str(payload.get("hallazgos") or "").strip()
    descripcion_procedimiento = str(payload.get("descripcion_procedimiento") or "").strip()
    max_chars = int(payload.get("max_chars") or 1800)

    if not hallazgos and not descripcion_procedimiento:
        raise HTTPException(
            status_code=400,
            detail="Debe enviar 'hallazgos' o 'descripcion_procedimiento'.",
        )

    partes = []
    if hallazgos:
        partes.append(f"Hallazgos quirurgicos: {hallazgos}")
    if descripcion_procedimiento:
        partes.append(f"Descripcion del procedimiento: {descripcion_procedimiento}")

    descripcion_agente = " | ".join(partes).strip()
    if len(descripcion_agente) > max_chars:
        descripcion_agente = descripcion_agente[:max_chars]

    resultado = await generar_codigos_desde_soat_gemini(
        {
            "descripciones": [
                {
                    "codigo_soat": "QX-HALLAZGOS",
                    "descripcion": descripcion_agente,
                }
            ]
        },
        current_user,
        services,
    )

    resultados = []
    for item in (resultado.get("resultados") or []):
        if not isinstance(item, dict):
            continue
        if item.get("error"):
            continue
        resultados.append(
            {
                **item,
                "fuente": "agente_hallazgos_qx",
            }
        )

    total_diagnosticos = 0
    total_procedimientos = 0
    for item in resultados:
        if item.get("cie10_principal"):
            total_diagnosticos += 1
        total_diagnosticos += len(item.get("cie10_secundarios") or [])

        if item.get("cups_principal"):
            total_procedimientos += 1
        total_procedimientos += len(item.get("cups_alternativos") or [])

    return {
        "mensaje": "Analisis de hallazgos quirurgicos completado",
        "fuente": "agente_hallazgos_qx",
        "resultados": resultados,
        "total_resultados": len(resultados),
        "total_diagnosticos": total_diagnosticos,
        "total_procedimientos": total_procedimientos,
    }

@router.post("/soat/chat")
async def soat_chat(payload: dict, current_user = Depends(get_current_user), services: AppServices = Depends(get_services)):
    base_dir = services.base_dir
    mongo_storage = services.mongo_storage
    mongo = services.mongo_analyses
    client_groq = services.client_groq
    client_gemini = services.client_gemini
    retriever = services.cie10_retriever
    cups_retriever = services.cups_retriever
    soat_retriever = services.soat_retriever
    colombia_tz = services.colombia_tz
    soat_index_dir = "soat_faiss"
    if not soat_retriever:
        raise HTTPException(status_code=400, detail="Índice SOAT no inicializado")
    mensaje = (payload.get("mensaje") or "").strip()
    if not mensaje:
        raise HTTPException(status_code=400, detail="'mensaje' es requerido")
    try:
        docs = soat_retriever.buscar(mensaje, k=15)
        contexto = "\n\n".join([f"(p.{d.metadata.get('page')}) {d.page_content[:1100]}" for d in docs])
        prompt = f"""
Eres un especialista en auditoría y codificación médica en Colombia. Responde usando EXCLUSIVAMENTE el contexto proporcionado del Manual SOAT 2024, citando páginas cuando corresponda. Si no hay información suficiente, dilo explícitamente.

Pregunta del usuario:
{mensaje}

Contexto SOAT (extractos):
{contexto}
"""
        resp = client_groq.chat.completions.create(
            model=config.GROQ_MODEL_SOAT,
            temperature=0.0,
            messages=[
                {"role": "system", "content": "Eres un asistente RAG estricto. No inventes contenido fuera del contexto."},
                {"role": "user", "content": prompt}
            ],
        )
        respuesta = resp.choices[0].message.content
        fuentes = [{"page": d.metadata.get("page"), "source": d.metadata.get("source")} for d in docs[:10]]
        return {"respuesta": respuesta, "fuentes": fuentes}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@router.post("/soat/validar_factura")
async def validar_factura_soat(payload: Dict, current_user = Depends(get_current_user), services: AppServices = Depends(get_services)):
    """
    Valida códigos SOAT de una factura contra documentación quirúrgica.
    Propone CIE-10 y CUPS que justifiquen los códigos SOAT facturados.
    """
    base_dir = services.base_dir
    mongo_storage = services.mongo_storage
    mongo = services.mongo_analyses
    client_groq = services.client_groq
    client_gemini = services.client_gemini
    retriever = services.cie10_retriever
    cups_retriever = services.cups_retriever
    soat_retriever = services.soat_retriever
    colombia_tz = services.colombia_tz
    soat_index_dir = "soat_faiss"
    documento_quirurgico = payload.get("documento_quirurgico", "").strip()
    codigos_soat_factura = payload.get("codigos_soat_factura", [])
    
    if not documento_quirurgico:
        raise HTTPException(status_code=400, detail="Documento quirúrgico es requerido")
    
    if not codigos_soat_factura or not isinstance(codigos_soat_factura, list):
        raise HTTPException(status_code=400, detail="Códigos SOAT de factura son requeridos")
    
    try:
        # Extraer información estructurada del documento quirúrgico
        diagnosticos_prequx = _extraer_seccion_documento(documento_quirurgico, "DIAGNÓSTICOS PREQUIRÚRGICO")
        procedimientos = _extraer_seccion_documento(documento_quirurgico, "PROCEDIMIENTOS REALIZADOS")
        hallazgos = _extraer_seccion_documento(documento_quirurgico, "HALLAZGOS QUIRÚRGICOS")
        descripcion_proc = _extraer_seccion_documento(documento_quirurgico, "DESCRIPCIÓN DEL PROCEDIMIENTO")
        justificacion = _extraer_seccion_documento(documento_quirurgico, "JUSTIFICACIÓN DEL PROCEDIMIENTO")
        diagnosticos_postqx = _extraer_seccion_documento(documento_quirurgico, "DIAGNÓSTICOS POSTQUIRÚRGICO")
        
        # Procesar cada código SOAT de la factura
        resultados_validacion = []
        
        for codigo_soat_item in codigos_soat_factura:
            codigo_soat = codigo_soat_item.get("codigo", "").strip()
            descripcion_soat = codigo_soat_item.get("descripcion", "").strip()
            fecha = codigo_soat_item.get("fecha", "")
            cantidad = codigo_soat_item.get("cantidad", 1)
            valor = codigo_soat_item.get("valor", "")
            
            # Validar el código SOAT contra la documentación
            resultado_validacion = await _validar_codigo_soat_con_documento(
                codigo_soat=codigo_soat,
                descripcion_soat=descripcion_soat,
                diagnosticos_prequx=diagnosticos_prequx,
                procedimientos=procedimientos,
                hallazgos=hallazgos,
                descripcion_proc=descripcion_proc,
                justificacion=justificacion,
                diagnosticos_postqx=diagnosticos_postqx,
                soat_retriever=soat_retriever,
                retriever=retriever,
                cups_retriever=cups_retriever,
                client_groq=client_groq,
                client_gemini=client_gemini
            )
            
            resultado_validacion.update({
                "codigo_soat": codigo_soat,
                "descripcion_soat": descripcion_soat,
                "fecha": fecha,
                "cantidad": cantidad,
                "valor": valor
            })
            
            resultados_validacion.append(resultado_validacion)
        
        # Generar resumen de validación
        resumen = _generar_resumen_validacion(resultados_validacion, documento_quirurgico)
        
        return {
            "mensaje": "Validación de factura SOAT completada",
            "documento_quirurgico_procesado": {
                "diagnosticos_prequx": diagnosticos_prequx,
                "procedimientos": procedimientos,
                "hallazgos": hallazgos,
                "justificacion": justificacion
            },
            "validaciones": resultados_validacion,
            "resumen": resumen
        }
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error validando factura SOAT: {str(e)}")

@router.post("/soat/generar_codigos_gemini")
async def generar_codigos_desde_soat_gemini(payload: Dict, current_user = Depends(get_current_user), services: AppServices = Depends(get_services)):
    """
    Nueva feature: Genera códigos CIE-10 y CUPS directamente desde descripciones SOAT usando Gemini.
    Este endpoint NO usa RAG, sino que confía en el conocimiento de Gemini para codificación médica.
    """
    base_dir = services.base_dir
    mongo_storage = services.mongo_storage
    mongo = services.mongo_analyses
    client_groq = services.client_groq
    client_gemini = services.client_gemini
    retriever = services.cie10_retriever
    cups_retriever = services.cups_retriever
    soat_retriever = services.soat_retriever
    colombia_tz = services.colombia_tz
    soat_index_dir = "soat_faiss"
    descripciones_soat = payload.get("descripciones", [])
    
    if not descripciones_soat or not isinstance(descripciones_soat, list):
        raise HTTPException(
            status_code=400, 
            detail="Se requiere una lista de descripciones SOAT"
        )
    
    if not client_gemini:
        raise HTTPException(
            status_code=503,
            detail="Gemini no está configurado. Configure GEMINI_API_KEY."
        )
    
    try:
        resultados = []
        
        for item in descripciones_soat:
            descripcion = item.get("descripcion", "").strip()
            codigo_soat = item.get("codigo_soat", "").strip()
            
            if not descripcion:
                resultados.append({
                    "codigo_soat": codigo_soat,
                    "descripcion": descripcion,
                    "error": "Descripción vacía"
                })
                continue
            
            # Prompt optimizado para que Gemini genere códigos médicos
            prompt = f"""
Eres un especialista en codificación médica en Colombia con conocimiento experto en:
- Sistema CIE-10 (Clasificación Internacional de Enfermedades)
- Sistema CUPS (Clasificación Única de Procedimientos en Salud)
- Manual SOAT 2024 y codificación de accidentes de tránsito

Se te proporciona una descripción de un procedimiento o diagnóstico del sistema SOAT.

╔══════════════════════════════════════════════════════════════╗
║ INFORMACIÓN DEL PROCEDIMIENTO/DIAGNÓSTICO                    ║
╚══════════════════════════════════════════════════════════════╝

Código SOAT: {codigo_soat if codigo_soat else "No especificado"}
Descripción: {descripcion}

╔══════════════════════════════════════════════════════════════╗
║ TU TAREA                                                      ║
╚══════════════════════════════════════════════════════════════╝

Genera los códigos médicos correspondientes siguiendo ESTRICTAMENTE este formato:

CÓDIGOS CIE-10 RECOMENDADOS:
----------------------------
PRINCIPAL:
• Código: [CIE-10]
  Descripción: [Descripción completa oficial CIE-10]
  Justificación: [Por qué este código es el más apropiado]

SECUNDARIOS:
• Código: [CIE-10]
  Descripción: [Descripción completa oficial CIE-10]
  Justificación: [Relación con el diagnóstico/procedimiento]

• Código: [CIE-10]
  Descripción: [Descripción completa oficial CIE-10]
  Justificación: [Relación con el diagnóstico/procedimiento]

CÓDIGOS CUPS RECOMENDADOS:
----------------------------
PRINCIPAL:
• Código: [6 dígitos CUPS]
  Descripción: [Descripción completa oficial CUPS]
  Justificación: [Por qué este procedimiento es el indicado]

ALTERNATIVOS:
• Código: [6 dígitos CUPS]
  Descripción: [Descripción completa oficial CUPS]
  Justificación: [Cuándo considerar este procedimiento]

• Código: [6 dígitos CUPS]
  Descripción: [Descripción completa oficial CUPS]
  Justificación: [Cuándo considerar este procedimiento]

ANÁLISIS CLÍNICO:
----------------------------
Coherencia diagnóstico-procedimiento:
[Explicación de por qué los códigos CIE-10 y CUPS propuestos son coherentes entre sí]

Consideraciones SOAT:
[Aspectos específicos relevantes para facturación SOAT]

Prevención de glosas:
[Recomendaciones para documentar adecuadamente estos códigos]

IMPORTANTE:
- Usa SOLO códigos reales y oficiales de CIE-10 y CUPS
- Los códigos CUPS deben tener exactamente 6 dígitos
- Los códigos CIE-10 deben seguir el formato estándar (letra + números + punto si aplica)
- Proporciona al menos 1 código principal de cada tipo
- Sé específico y preciso en las justificaciones
"""

            # Llamar a Gemini
            response = client_gemini.generate_content(prompt)
            respuesta_gemini = response.text
            
            # Parsear la respuesta para extraer códigos estructurados
            codigos_parseados = _parsear_respuesta_gemini_codigos(respuesta_gemini)
            
            resultados.append({
                "codigo_soat": codigo_soat,
                "descripcion": descripcion,
                "cie10_principal": codigos_parseados["cie10_principal"],
                "cie10_secundarios": codigos_parseados["cie10_secundarios"],
                "cups_principal": codigos_parseados["cups_principal"],
                "cups_alternativos": codigos_parseados["cups_alternativos"],
                "analisis_clinico": codigos_parseados["analisis_clinico"],
                "respuesta_completa": respuesta_gemini
            })
        
        return {
            "mensaje": "Códigos generados exitosamente",
            "total_procesados": len(resultados),
            "resultados": resultados
        }
        
    except Exception as e:
        print(f"❌ Error generando códigos con Gemini: {e}")
        raise HTTPException(
            status_code=500,
            detail=f"Error al generar códigos: {str(e)}"
        )
