import logging from typing import Annotated, Any import anyio from fastapi import APIRouter, Depends, File, HTTPException, Security, UploadFile from starlette import status from app.auth import get_current_user from app.case_epicrisis.domain.curation import CodeSystem from app.core.dependencies import get_services from app.core.services import AppServices from app.llm import LLMTask from app.llm.task_text import generate_task_text from app.models import UserInDB from app.services.soat_processing import ( _agente_codificar_desde_soat_item, _extraer_seccion_documento, _generar_resumen_validacion, _validar_codigo_soat_con_documento, generar_codigos_desde_soat_con_gemini, ) from app.soat_crosswalk.application.resolution import ( SUPPORTED_CROSSWALK_YEAR, CupsCodeNotFoundError, CupsSoatResolver, InvalidCupsCodeError, ) from app.soat_crosswalk.domain.models import CrosswalkStatus from app.soat_crosswalk.infrastructure.catalogs import JsonCupsSoatCrosswalk, XlsxCupsCatalog from app.soat_tariffs.application.valuation import tariff_entry_values from app.soat_tariffs.infrastructure.json_catalog import JsonSoatTariffCatalog from modules.processing.soat.soat_indexer import build_soat_index_from_pdf router = APIRouter() logger = logging.getLogger(__name__) SoatPdfFile = Annotated[UploadFile, File(...)] CurrentUser = Annotated[UserInDB, Security(get_current_user)] ServicesDep = Annotated[AppServices, Depends(get_services)] @router.get("/api/soat/cups/{cups_code}/tariff") async def consultar_tarifa_por_cups( cups_code: str, year: int, current_user: CurrentUser, ): if year != SUPPORTED_CROSSWALK_YEAR: raise HTTPException( status_code=status.HTTP_422_UNPROCESSABLE_CONTENT, detail="La vigencia del cruce CUPS-SOAT solo está disponible para 2026.", ) cups_catalog = XlsxCupsCatalog() tariff_catalog = JsonSoatTariffCatalog() crosswalk = JsonCupsSoatCrosswalk( cups_catalog=cups_catalog, tariff_catalog=tariff_catalog, ) resolver = CupsSoatResolver( cups_catalog=cups_catalog, crosswalk=crosswalk, tariff_catalog=tariff_catalog, ) try: result = resolver.resolve(cups_code, year) except InvalidCupsCodeError as exc: raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_CONTENT, detail=str(exc)) from exc except CupsCodeNotFoundError as exc: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc response = result.model_dump(mode="json") if result.status == CrosswalkStatus.RESOLVED and result.selected_soat_code: catalog = tariff_catalog.load(year) entry = tariff_catalog.find_exact(year, result.selected_soat_code) if entry is None: # El adaptador valida esto; protege el contrato HTTP frente a archivos manipulados. raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Cruce inconsistente") base, components = tariff_entry_values(entry, catalog.unit_value) response["valuation"] = { "soat_code": entry.code, "description": entry.description, "surgical_group": entry.surgical_group, "unit": catalog.unit, "unit_value": catalog.unit_value, "base_tariff": base, "components": components, "note": "Valoración SOAT de referencia; no modifica importes facturados.", } return response @router.post("/soat/indexar_pdf") async def soat_indexar_pdf( file: SoatPdfFile, *, current_user: CurrentUser, services: ServicesDep, ): base_dir = services.base_dir soat_index_dir = "soat_faiss" try: contents = await file.read() tmp_path = base_dir / "_tmp_soat.pdf" async with await anyio.open_file(tmp_path, "wb") as f: await f.write(contents) index_dir = build_soat_index_from_pdf(str(tmp_path), str(base_dir / soat_index_dir)) services.configure_soat_index(index_dir) return {"mensaje": "Índice SOAT construido", "index_dir": index_dir} except Exception as e: raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)) @router.post("/soat/codificar") async def soat_codificar( data: dict, current_user: CurrentUser, services: ServicesDep, ): soat_retriever = services.soat_retriever if not soat_retriever: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Índice SOAT no inicializado") procedimientos = data.get("procedimientos") or [] if not isinstance(procedimientos, list) or not procedimientos: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, 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[str, Any], current_user: CurrentUser, services: ServicesDep, ): """Dado un conjunto de códigos/descripciones SOAT, propone CUPS y CIE‑10 óptimos con justificación y evidencia.""" client_groq = services.client_groq client_gemini = services.client_gemini retriever = services.cie10_retriever cups_retriever = services.cups_retriever soat_retriever = services.soat_retriever items = payload.get("items") or [] if not isinstance(items, list) or not items: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, 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, llm_router=services.llm_router, ) ) 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[str, Any], current_user: CurrentUser, services: ServicesDep, ): """ 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=status.HTTP_400_BAD_REQUEST, 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": "Análisis de hallazgos quirúrgicos 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[str, Any], current_user: CurrentUser, services: ServicesDep, ): soat_retriever = services.soat_retriever if not soat_retriever: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Índice SOAT no inicializado") if not services.llm_router: raise HTTPException( status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="No hay capacidad LLM configurada para el chat SOAT.", ) mensaje = (payload.get("mensaje") or "").strip() if not mensaje: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, 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]) catalog_registry = getattr(services, "catalog_registry", None) catalog_reference = ( catalog_registry.reference(CodeSystem.SOAT) if catalog_registry is not None else None ) catalog_label = ( f"{catalog_reference.index_name} ({catalog_reference.source_name})" if catalog_reference is not None and catalog_reference.available else "índice SOAT vigente" ) prompt = f""" Eres un especialista en auditoría y codificación médica en Colombia. Responde usando EXCLUSIVAMENTE el contexto proporcionado de {catalog_label}, citando páginas cuando corresponda. Si no hay información suficiente, dilo explícitamente. Pregunta del usuario: {mensaje} Contexto SOAT (extractos): {contexto} """ resp = generate_task_text( services.llm_router, task=LLMTask.SOAT_CHAT, prompt=prompt, system_prompt="Eres un asistente RAG estricto. No inventes contenido fuera del contexto.", metadata={"operation": "soat_chat", "username": current_user.username, "query": mensaje[:200]}, generation_config={"temperature": 0.0}, ) respuesta = resp.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=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)) @router.post("/soat/validar_factura") async def validar_factura_soat( payload: dict[str, Any], current_user: CurrentUser, services: ServicesDep, ): """ Valida códigos SOAT de una factura contra documentación quirúrgica. Propone CIE-10 y CUPS que justifiquen los códigos SOAT facturados. """ client_groq = services.client_groq client_gemini = services.client_gemini retriever = services.cie10_retriever cups_retriever = services.cups_retriever soat_retriever = services.soat_retriever documento_quirurgico = payload.get("documento_quirurgico", "").strip() codigos_soat_factura = payload.get("codigos_soat_factura", []) if not documento_quirurgico: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="Documento quirúrgico es requerido" ) if not codigos_soat_factura or not isinstance(codigos_soat_factura, list): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, 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, llm_router=services.llm_router, ) 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=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Error validando factura SOAT: {str(e)}", ) @router.post("/soat/generar_codigos_gemini") async def generar_codigos_desde_soat_gemini( payload: dict[str, Any], current_user: CurrentUser, services: ServicesDep, ): """ 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. """ client_gemini = services.client_gemini descripciones_soat = payload.get("descripciones", []) if not descripciones_soat or not isinstance(descripciones_soat, list): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="Se requiere una lista de descripciones SOAT" ) if not client_gemini and not services.llm_router: raise HTTPException( status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="No hay capacidad LLM configurada para generar códigos SOAT.", ) try: resultados = generar_codigos_desde_soat_con_gemini( descripciones_soat, client_gemini=client_gemini, llm_router=services.llm_router, cache_repository=services.llm_task_cache_repository, username=current_user.username, ) return { "mensaje": "Códigos generados exitosamente", "total_procesados": len(resultados), "resultados": resultados, } except Exception as e: logger.exception("Error generando códigos con Gemini") raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Error al generar códigos: {str(e)}" )