rips_manager/app/routes/pacientes.py

from fastapi import APIRouter, Request, Form, Depends
from fastapi.responses import JSONResponse

from app.auth import get_current_user
from app.database import get_connection
from app.services.firebird_service import get_firebird_from_config
from app.services.whatsapp_sync import sync_todos, guardar_sync_log

router = APIRouter(prefix="/pacientes", tags=["pacientes"])

# Trae todos los pacientes distintos en un rango de fechas de recepción.
# Reutiliza la misma query de automation para no duplicar lógica.
_SQL_TODOS = """
SELECT DISTINCT
    p.CODIGO,
    p.TIPOIDENT,
    p.DOCIDENT,
    p.NOMBRES,
    p.APELLIDOS,
    p.DIRECCION,
    p.CIUDAD        AS COD_CIUDAD,
    c.NOMBRE        AS NOM_CIUDAD,
    p.TELEFONOS,
    p.EMAIL,
    p.F_NACIMIENTO,
    p.SEXO,
    p.TIPORES,
    p.CODETNIA
FROM PACIENTE p
LEFT JOIN CIUDAD c ON c.CODIGO = p.CIUDAD
LEFT JOIN RECEPCION r ON r.COD_PACIENTE = p.CODIGO
WHERE (:fecha_ini IS NULL OR r.FECHA_RECEPCION BETWEEN :fecha_ini AND :fecha_fin)
  AND r.NUM_FACTURA > 0
"""

_SQL_SIN_FILTRO = """
SELECT DISTINCT
    p.CODIGO,
    p.TIPOIDENT,
    p.DOCIDENT,
    p.NOMBRES,
    p.APELLIDOS,
    p.DIRECCION,
    p.CIUDAD        AS COD_CIUDAD,
    c.NOMBRE        AS NOM_CIUDAD,
    p.TELEFONOS,
    p.EMAIL,
    p.F_NACIMIENTO,
    p.SEXO,
    p.TIPORES,
    p.CODETNIA
FROM PACIENTE p
LEFT JOIN CIUDAD c ON c.CODIGO = p.CIUDAD
WHERE p.DOCIDENT IS NOT NULL AND p.NOMBRES IS NOT NULL
"""


@router.get("")
async def pacientes_page(request: Request, user: dict = Depends(get_current_user)):
    conn = get_connection()
    configs = {row["key"]: row["value"] for row in conn.execute("SELECT * FROM config").fetchall()}
    conn.close()
    wa_url = configs.get("whatsapp_url", "")
    wa_key = configs.get("whatsapp_api_key", "")
    return request.app.state.templates.TemplateResponse("pacientes.html", {
        "request": request,
        "user": user,
        "wa_configurado": bool(wa_url and wa_key),
        "wa_url": wa_url,
    })


@router.post("/sync-all")
async def sync_all(
    request: Request,
    user: dict = Depends(get_current_user),
    fecha_ini: str = Form(""),
    fecha_fin: str = Form(""),
    todos: str = Form(""),
):
    conn = get_connection()
    configs = {row["key"]: row["value"] for row in conn.execute("SELECT * FROM config").fetchall()}
    conn.close()

    wa_url = configs.get("whatsapp_url", "").rstrip("/")
    wa_key = configs.get("whatsapp_api_key", "")

    if not wa_url or not wa_key:
        return JSONResponse({
            "success": False,
            "message": "Configura la URL y API Key de WhatsApp Lab antes de sincronizar.",
        })

    ingest_url = f"{wa_url}/api/lab/ingest_paciente.php"

    fb, ok, msg = get_firebird_from_config(configs)
    if not ok:
        return JSONResponse({"success": False, "message": f"Error Firebird: {msg}"})

    if todos == "1" or (not fecha_ini and not fecha_fin):
        ok_q, err_q, rows = fb.execute_query(_SQL_SIN_FILTRO, None)
    else:
        if not fecha_ini or not fecha_fin:
            fb.disconnect()
            return JSONResponse({"success": False, "message": "Indica fecha inicio y fecha fin."})
        params = {
            "fecha_ini": f"{fecha_ini} 00:00:00",
            "fecha_fin":  f"{fecha_fin} 23:59:59",
        }
        ok_q, err_q, rows = fb.execute_query(_SQL_TODOS, params)

    fb.disconnect()

    if not ok_q:
        return JSONResponse({"success": False, "message": f"Error al consultar Firebird: {err_q}"})
    if not rows:
        return JSONResponse({"success": False, "message": "No se encontraron pacientes con esos criterios."})

    timeout = int(configs.get("api_timeout", 30))
    resultado = await sync_todos(rows, ingest_url, wa_key, timeout, modo="insertar")

    guardar_sync_log(resultado, user["user_id"], origen="manual", modo="insertar")

    resultado["success"] = True
    resultado["message"] = (
        f"{resultado['total']} procesados — "
        f"{resultado['created']} nuevos, "
        f"{resultado['skipped']} ya existían, "
        f"{resultado['errores']} errores."
    )
    return JSONResponse(resultado)


@router.get("/historial")
async def historial(request: Request, user: dict = Depends(get_current_user)):
    conn = get_connection()
    rows = conn.execute("""
        SELECT l.*, u.username
        FROM sync_wa_log l
        LEFT JOIN users u ON u.id = l.user_id
        ORDER BY l.created_at DESC
        LIMIT 100
    """).fetchall()
    conn.close()
    return JSONResponse([dict(r) for r in rows])