rips_manager/app/routes/debug_fb.py

import traceback
from fastapi import APIRouter, Request, Depends, Query
from fastapi.responses import JSONResponse
from app.database import get_connection
from app.auth import get_current_user
from app.services.firebird_service import get_firebird_from_config

router = APIRouter(prefix="/debug-fb", tags=["debug"])


@router.get("/diagnosticos")
async def listar_diagnosticos(
    q: str = Query(default="", description="Filtro por código o concepto"),
    limit: int = Query(default=100, ge=1, le=5000),
    user: dict = Depends(get_current_user),
):
    """Lista diagnósticos CIE-10 desde Firebird DIAGNOSTICO."""
    try:
        conn = get_connection()
        cfg = {r["key"]: r["value"] for r in conn.execute("SELECT * FROM config").fetchall()}
        conn.close()

        fb, ok, msg = get_firebird_from_config(cfg)
        if not ok:
            return JSONResponse({"ok": False, "error": msg})

        # Estructura de la tabla
        ok_c, _, cols = fb.execute_query(
            "SELECT f.RDB$FIELD_NAME "
            "FROM RDB$RELATION_FIELDS f "
            "WHERE TRIM(f.RDB$RELATION_NAME) = 'DIAGNOSTICO' "
            "ORDER BY f.RDB$FIELD_POSITION", None
        )

        # Conteo total
        ok_n, _, cnt = fb.execute_query(
            "SELECT COUNT(*) AS TOTAL FROM DIAGNOSTICO", None
        )

        # Registros
        if q:
            q_up = q.upper()
            ok_r, _, rows = fb.execute_query(
                f"SELECT FIRST {limit} TRIM(d.COD_DIAG) AS COD_DIAG, TRIM(d.CONCEPTO) AS CONCEPTO "
                f"FROM DIAGNOSTICO d "
                f"WHERE UPPER(TRIM(d.COD_DIAG)) CONTAINING '{q_up}' "
                f"   OR UPPER(TRIM(d.CONCEPTO)) CONTAINING '{q_up}' "
                f"ORDER BY d.COD_DIAG", None
            )
        else:
            ok_r, _, rows = fb.execute_query(
                f"SELECT FIRST {limit} TRIM(d.COD_DIAG) AS COD_DIAG, TRIM(d.CONCEPTO) AS CONCEPTO "
                f"FROM DIAGNOSTICO d ORDER BY d.COD_DIAG", None
            )

        fb.disconnect()

        return JSONResponse({
            "ok":      True,
            "total":   cnt[0]["TOTAL"] if ok_n and cnt else "?",
            "columnas": [list(c.values())[0].strip() for c in cols] if ok_c and cols else [],
            "limite":  limit,
            "filtro":  q or None,
            "rows":    [{"cod": r["COD_DIAG"], "concepto": r["CONCEPTO"]} for r in (rows or [])],
        })
    except Exception:
        return JSONResponse({"ok": False, "traceback": traceback.format_exc()})


@router.get("/recepcion")
async def debug_recepcion(user: dict = Depends(get_current_user)):
    """Diagnóstico: columnas de RECEPCION, tabla EMPRESA y link a tarifa."""
    try:
        conn = get_connection()
        cfg = {r["key"]: r["value"] for r in conn.execute("SELECT * FROM config").fetchall()}
        conn.close()

        fb, ok, msg = get_firebird_from_config(cfg)
        if not ok:
            return JSONResponse({"error": msg})

        result = {}

        # Todas las columnas de RECEPCION
        ok_c, _, cols = fb.execute_query(
            "SELECT TRIM(f.RDB$FIELD_NAME) AS COL "
            "FROM RDB$RELATION_FIELDS f "
            "WHERE TRIM(f.RDB$RELATION_NAME) = 'RECEPCION' "
            "ORDER BY f.RDB$FIELD_POSITION", None
        )
        result["columnas_recepcion"] = [r["COL"] for r in (cols or [])] if ok_c else []

        # Tablas con EMPRESA o CONVENIO en el nombre
        ok_e, _, tabs = fb.execute_query(
            "SELECT TRIM(r.RDB$RELATION_NAME) AS TABLA FROM RDB$RELATIONS r "
            "WHERE r.RDB$SYSTEM_FLAG = 0 "
            "  AND (UPPER(TRIM(r.RDB$RELATION_NAME)) CONTAINING 'EMPRESA' "
            "    OR UPPER(TRIM(r.RDB$RELATION_NAME)) CONTAINING 'CONVENIO') "
            "ORDER BY TABLA", None
        )
        result["tablas_empresa_convenio"] = [r["TABLA"] for r in (tabs or [])] if ok_e else []

        # Columnas + muestra de cada tabla encontrada
        for t in result["tablas_empresa_convenio"][:4]:
            ok_tc, _, tcols = fb.execute_query(
                "SELECT TRIM(f.RDB$FIELD_NAME) AS COL FROM RDB$RELATION_FIELDS f "
                f"WHERE TRIM(f.RDB$RELATION_NAME) = '{t}' ORDER BY f.RDB$FIELD_POSITION", None
            )
            ok_tr, _, trows = fb.execute_query(f"SELECT FIRST 2 * FROM {t}", None)
            result[f"tabla_{t}"] = {
                "columnas": [c["COL"] for c in (tcols or [])] if ok_tc else [],
                "muestra": list(trows or []) if ok_tr else [],
            }

        # 1 recepción completa para ver si tiene COD_TARIFA o NIT_EMPRESA
        ok_r, _, rec = fb.execute_query(
            "SELECT FIRST 1 r.* FROM RECEPCION r ORDER BY r.IDRECEPCION DESC", None
        )
        result["recepcion_completa"] = dict(rec[0]) if ok_r and rec else {}

        fb.disconnect()
        return JSONResponse(result)
    except Exception:
        return JSONResponse({"traceback": traceback.format_exc()})


@router.get("/tarifas")
async def debug_tarifas(user: dict = Depends(get_current_user)):
    """Explora tablas de tarifas/precios en Firebird."""
    try:
        conn = get_connection()
        cfg = {r["key"]: r["value"] for r in conn.execute("SELECT * FROM config").fetchall()}
        conn.close()
        fb, ok, msg = get_firebird_from_config(cfg)
        if not ok:
            return JSONResponse({"ok": False, "error": msg})

        # Todas las tablas que contengan TARIF, PRECIO, ARANCEL, CONVENIO, ISS en el nombre
        ok_t, _, tablas = fb.execute_query(
            "SELECT TRIM(r.RDB$RELATION_NAME) AS TABLA "
            "FROM RDB$RELATIONS r "
            "WHERE r.RDB$SYSTEM_FLAG = 0 "
            "  AND (UPPER(TRIM(r.RDB$RELATION_NAME)) CONTAINING 'TARIF' "
            "    OR UPPER(TRIM(r.RDB$RELATION_NAME)) CONTAINING 'PRECIO' "
            "    OR UPPER(TRIM(r.RDB$RELATION_NAME)) CONTAINING 'ARANCEL' "
            "    OR UPPER(TRIM(r.RDB$RELATION_NAME)) CONTAINING 'CONVENIO' "
            "    OR UPPER(TRIM(r.RDB$RELATION_NAME)) CONTAINING 'VALOR') "
            "ORDER BY TABLA", None
        )

        result = {"tablas_encontradas": [r["TABLA"] for r in (tablas or [])] if ok_t else []}

        # Para cada tabla encontrada: columnas + 3 filas de muestra
        for t in result["tablas_encontradas"][:6]:
            ok_c, _, cols = fb.execute_query(
                "SELECT TRIM(f.RDB$FIELD_NAME) AS COL "
                "FROM RDB$RELATION_FIELDS f "
                f"WHERE TRIM(f.RDB$RELATION_NAME) = '{t}' "
                "ORDER BY f.RDB$FIELD_POSITION", None
            )
            ok_r, _, rows = fb.execute_query(
                f"SELECT FIRST 3 * FROM {t}", None
            )
            ok_n, _, cnt = fb.execute_query(
                f"SELECT COUNT(*) AS N FROM {t}", None
            )
            result[t] = {
                "columnas": [c["COL"] for c in (cols or [])] if ok_c else [],
                "total": cnt[0]["N"] if ok_n and cnt else "?",
                "muestra": list(rows or []) if ok_r else [],
            }

        fb.disconnect()
        return JSONResponse(result)
    except Exception:
        return JSONResponse({"ok": False, "traceback": traceback.format_exc()})


@router.get("/cmxc")
async def debug_cmxc(
    fecha: str = Query(default="", description="YYYY-MM-DD, vacío = hoy"),
    user: dict = Depends(get_current_user),
):
    """Consulta directa a Firebird: recepciones CMXC para la fecha dada."""
    from datetime import date as date_cls
    if not fecha:
        fecha = date_cls.today().isoformat()
    fecha_ini = f"{fecha} 00:00:00"
    fecha_fin = f"{fecha} 23:59:59"
    try:
        conn = get_connection()
        cfg = {r["key"]: r["value"] for r in conn.execute("SELECT * FROM config").fetchall()}
        conn.close()
        fb, ok, msg = get_firebird_from_config(cfg)
        if not ok:
            return JSONResponse({"ok": False, "error": msg})

        ok1, _, rows = fb.execute_query("""
            SELECT
                r.IDRECEPCION, r.PREFIJO, r.NUM_FACTURA,
                CAST(r.FECHA_RECEPCION AS VARCHAR(30)) AS FECHA_RECEPCION,
                r.COD_PACIENTE, TRIM(r.NIT_EMPRESA) AS NIT_EMPRESA,
                TRIM(e.CODCONTRATO) AS CODCONTRATO, TRIM(e.NOMBRE) AS NOM_EMPRESA,
                (SELECT COUNT(*) FROM RELACION rel WHERE rel.IDRECEPCION = r.IDRECEPCION) AS N_EXAMENES
            FROM RECEPCION r
            LEFT JOIN EMPRESA e ON e.NIT = r.NIT_EMPRESA
            WHERE r.FECHA_RECEPCION BETWEEN :fi AND :ff
              AND r.PREFIJO = 'CMXC'
            ORDER BY r.IDRECEPCION
        """, {"fi": fecha_ini, "ff": fecha_fin})

        ok2, _, total = fb.execute_query("""
            SELECT COUNT(*) AS N FROM RECEPCION r
            WHERE r.FECHA_RECEPCION BETWEEN :fi AND :ff
        """, {"fi": fecha_ini, "ff": fecha_fin})

        # Correr el mismo _SQL_VENTAS que usa el preview
        ok3, err3, rows_vta = fb.execute_query("""
            SELECT
                r.IDRECEPCION, r.PREFIJO, r.NUM_FACTURA,
                CAST(r.FECHA_RECEPCION AS VARCHAR(30)) AS FECHA_RECEPCION,
                r.COD_PACIENTE, r.NIT_EMPRESA, r.VALORTOTAL,
                rel.COD_EXAMEN,
                TRIM(e.CODCONTRATO) AS CODCONTRATO
            FROM RECEPCION r
            JOIN RELACION rel ON rel.IDRECEPCION = r.IDRECEPCION
            LEFT JOIN EXAMEN ex ON TRIM(ex.CODIGO) = TRIM(rel.COD_EXAMEN)
            LEFT JOIN EMPRESA e ON e.NIT = r.NIT_EMPRESA
            LEFT JOIN TARIFA t ON TRIM(t.COD_EXAMEN) = TRIM(rel.COD_EXAMEN) AND t.TARIFA = e.TARIFA
            WHERE r.FECHA_RECEPCION BETWEEN :fecha_ini AND :fecha_fin
              AND r.PREFIJO = 'CMXC'
            ORDER BY r.IDRECEPCION
        """, {"fecha_ini": fecha_ini, "fecha_fin": fecha_fin})

        fb.disconnect()

        # Estado de contratos en SQLite (excluir_ventas)
        conn2 = get_connection()
        contratos_excluidos_vta = [
            r["numero_contrato"]
            for r in conn2.execute(
                "SELECT numero_contrato FROM contratos WHERE excluir_ventas=1 ORDER BY numero_contrato"
            ).fetchall()
        ]
        contratos_activos_vta = [
            r["numero_contrato"]
            for r in conn2.execute(
                "SELECT numero_contrato FROM contratos WHERE excluir_ventas=0 ORDER BY numero_contrato"
            ).fetchall()
        ]
        conn2.close()

        return JSONResponse({
            "ok": True,
            "fecha": fecha,
            "total_recepcion_del_dia": total[0]["N"] if ok2 and total else "?",
            "cmxc_count": len(rows or []),
            "cmxc_rows": list(rows or []),
            "sql_ventas_ok": ok3,
            "sql_ventas_error": err3 if not ok3 else None,
            "sql_ventas_count": len(rows_vta or []),
            "sql_ventas_rows": list(rows_vta or [])[:10],
            "contratos_excluidos_ventas": contratos_excluidos_vta,
            "contratos_activos_ventas": contratos_activos_vta,
        })
    except Exception:
        return JSONResponse({"ok": False, "traceback": traceback.format_exc()})


@router.get("/preview-ventas")
async def debug_preview_ventas(
    fecha: str = Query(default="", description="YYYY-MM-DD"),
    user: dict = Depends(get_current_user),
):
    """Corre la lógica completa de ventas del preview y muestra cada paso."""
    from datetime import date as date_cls
    from collections import defaultdict
    if not fecha:
        fecha = date_cls.today().isoformat()
    fecha_ini = f"{fecha} 00:00:00"
    fecha_fin = f"{fecha} 23:59:59"
    try:
        conn = get_connection()
        cfg = {r["key"]: r["value"] for r in conn.execute("SELECT * FROM config").fetchall()}
        excluded_ventas = set(
            r["numero_contrato"]
            for r in conn.execute("SELECT numero_contrato FROM contratos WHERE excluir_ventas=1").fetchall()
        )
        conn.close()

        fb, ok, msg = get_firebird_from_config(cfg)
        if not ok:
            return JSONResponse({"ok": False, "error": msg})

        ok_vta, err_vta, rows_vta = fb.execute_query("""
            SELECT
                r.IDRECEPCION, r.PREFIJO, r.NUM_FACTURA,
                r.COD_PACIENTE, r.NIT_EMPRESA, r.VALORTOTAL,
                rel.COD_EXAMEN,
                TRIM(e.CODCONTRATO) AS CODCONTRATO
            FROM RECEPCION r
            JOIN RELACION rel ON rel.IDRECEPCION = r.IDRECEPCION
            LEFT JOIN EXAMEN ex ON TRIM(ex.CODIGO) = TRIM(rel.COD_EXAMEN)
            LEFT JOIN EMPRESA e ON e.NIT = r.NIT_EMPRESA
            LEFT JOIN TARIFA t ON TRIM(t.COD_EXAMEN) = TRIM(rel.COD_EXAMEN) AND t.TARIFA = e.TARIFA
            WHERE r.FECHA_RECEPCION BETWEEN :fecha_ini AND :fecha_fin
              AND r.PREFIJO = 'CMXC'
            ORDER BY r.IDRECEPCION
        """, {"fecha_ini": fecha_ini, "fecha_fin": fecha_fin})
        fb.disconnect()

        if not ok_vta:
            return JSONResponse({"ok": False, "sql_error": err_vta})

        # Agrupar por NUM_FACTURA
        grupos: dict = defaultdict(list)
        for row in (rows_vta or []):
            key = str(row.get("NUM_FACTURA") or "")
            grupos[key].append(dict(row))

        pasos = []
        grupos_finales = {}
        for k, v in grupos.items():
            paso = {"key": k, "filas": len(v),
                    "num_factura": v[0].get("NUM_FACTURA"),
                    "codcontrato": v[0].get("CODCONTRATO"),
                    "es_lista": isinstance(v, list),
                    "motivo_exclusion": None}
            if not isinstance(v, list) or not v:
                paso["motivo_exclusion"] = "no_es_lista_o_vacia"
            elif int(v[0].get("NUM_FACTURA") or 0) == 0:
                paso["motivo_exclusion"] = "num_factura_cero"
            elif str(v[0].get("CODCONTRATO") or "").strip() in excluded_ventas:
                paso["motivo_exclusion"] = f"contrato_excluido ({v[0].get('CODCONTRATO')})"
            else:
                grupos_finales[k] = v
            pasos.append(paso)

        return JSONResponse({
            "ok": True,
            "fecha": fecha,
            "rows_vta_count": len(rows_vta or []),
            "grupos_count": len(grupos),
            "grupos_finales_count": len(grupos_finales),
            "pasos": pasos,
            "excluded_ventas_set": sorted(excluded_ventas),
        })
    except Exception:
        return JSONResponse({"ok": False, "traceback": traceback.format_exc()})


@router.get("/facturas")
async def debug_facturas(
    desde: int = Query(..., description="NUM_FACTURA desde"),
    hasta: int = Query(..., description="NUM_FACTURA hasta"),
    user: dict = Depends(get_current_user),
):
    """Busca recepciones por rango de NUM_FACTURA en Firebird."""
    try:
        conn = get_connection()
        cfg = {r["key"]: r["value"] for r in conn.execute("SELECT * FROM config").fetchall()}
        conn.close()
        fb, ok, msg = get_firebird_from_config(cfg)
        if not ok:
            return JSONResponse({"ok": False, "error": msg})

        ok1, _, rows = fb.execute_query("""
            SELECT
                r.IDRECEPCION, TRIM(r.PREFIJO) AS PREFIJO, r.NUM_FACTURA,
                CAST(r.FECHA_RECEPCION AS VARCHAR(30)) AS FECHA_RECEPCION,
                r.COD_PACIENTE,
                TRIM(r.NIT_EMPRESA) AS NIT_EMPRESA,
                TRIM(e.CODCONTRATO) AS CODCONTRATO,
                TRIM(e.NOMBRE) AS NOM_EMPRESA,
                (SELECT COUNT(*) FROM RELACION rel WHERE rel.IDRECEPCION = r.IDRECEPCION) AS N_EXAMENES
            FROM RECEPCION r
            LEFT JOIN EMPRESA e ON e.NIT = r.NIT_EMPRESA
            WHERE r.NUM_FACTURA BETWEEN ? AND ?
            ORDER BY r.NUM_FACTURA, r.IDRECEPCION
        """, (desde, hasta))
        fb.disconnect()

        return JSONResponse({
            "ok": ok1,
            "desde": desde,
            "hasta": hasta,
            "count": len(rows or []),
            "rows": list(rows or []),
        })
    except Exception:
        return JSONResponse({"ok": False, "traceback": traceback.format_exc()})


@router.get("/cups")
async def find_cups(request: Request, user: dict = Depends(get_current_user)):
    try:
        conn = get_connection()
        cfg = {r["key"]: r["value"] for r in conn.execute("SELECT * FROM config").fetchall()}
        conn.close()

        fb, ok, msg = get_firebird_from_config(cfg)
        if not ok:
            return JSONResponse({"error": msg})

        results = {}

        BUSCAR = "903967"

        # Tablas y sus campos de texto para buscar
        tablas_candidatas = [
            ("PROTOCOLO", ["CODIGO", "NOMBRE"]),
            ("ITEM", ["COD_PROTOCOLO", "CUPS_DETALLE", "CODITEMINTERFACE"]),
            ("RELACION", ["COD_EXAMEN"]),
            ("RELACION_HIMS", ["CUPS_REF"]),
            ("ARTICULO", ["CODIGO", "CUPS"]),
            ("SERVICIO", ["CODIGO", "CUPS", "COD_CUPS"]),
            ("PROCEDIMIENTO", ["CODIGO", "CUPS"]),
        ]

        encontrado = {}
        for tabla, campos in tablas_candidatas:
            for campo in campos:
                ok_t, _, rows_t = fb.execute_query(
                    f"SELECT FIRST 3 t.* FROM {tabla} t "
                    f"WHERE TRIM(t.{campo}) = '{BUSCAR}'"
                )
                if ok_t and rows_t:
                    encontrado[f"{tabla}.{campo}"] = list(rows_t)

        results["valor_903967_encontrado_en"] = encontrado if encontrado else "no encontrado en tablas comunes"

        # Buscar en campos de tipo char/varchar de PROTOCOLO e ITEM que no conocemos
        for tabla in ["PROTOCOLO", "ITEM"]:
            ok_c, _, rows_c = fb.execute_query(
                f"SELECT TRIM(f.RDB$FIELD_NAME) AS c FROM RDB$RELATION_FIELDS f "
                f"WHERE TRIM(f.RDB$RELATION_NAME)='{tabla}' ORDER BY f.RDB$FIELD_POSITION"
            )
            if ok_c:
                results[f"columnas_{tabla.lower()}"] = [r["c"] for r in rows_c]

        fb.disconnect()
        return JSONResponse(results)
    except Exception:
        return JSONResponse({"traceback": traceback.format_exc()})