"""Rutas de consulta a la API CRM externa."""

from fastapi import APIRouter, HTTPException, Query

from crm.client import CrmApiClient, CrmApiError
from crm.factory import resolve_crm_base_url
from config import get_settings

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


def create_crm_router(crm: CrmApiClient) -> APIRouter:
    @router.get("/status")
    async def crm_status() -> dict:
        settings = get_settings()
        try:
            base = resolve_crm_base_url(settings) if settings.crm_api_enabled else ""
        except ValueError as exc:
            base = ""
            error = str(exc)
        else:
            error = None
        return {
            "enabled": settings.crm_api_enabled and crm.enabled,
            "base_url": base or crm.base_url.rstrip("/"),
            "base_id": settings.crm_api_base_id,
            "endpoints": crm.endpoints,
            "error": error,
        }

    @router.get("/clientes")
    async def list_clientes(
        id: str | None = Query(None),
        documento: str | None = Query(None),
        search: str | None = Query(None),
    ) -> dict:
        params = {
            k: v
            for k, v in {"id": id, "documento": documento, "search": search}.items()
            if v
        }
        try:
            clientes = await crm.list_clientes(params=params or None)
        except CrmApiError as exc:
            raise HTTPException(status_code=502, detail=str(exc)) from exc
        return {
            "count": len(clientes),
            "clientes": [
                {
                    "id": c.id,
                    "nombre": c.nombre,
                    "apellido": c.apellido,
                    "nombre_completo": c.nombre_completo,
                    "raw": c.raw,
                }
                for c in clientes
            ],
        }

    @router.get("/clientes/{cliente_id}")
    async def get_cliente(cliente_id: str) -> dict:
        try:
            cliente = await crm.get_cliente(cliente_id)
        except CrmApiError as exc:
            raise HTTPException(status_code=502, detail=str(exc)) from exc
        if not cliente:
            raise HTTPException(status_code=404, detail="Cliente no encontrado")
        return {
            "id": cliente.id,
            "nombre": cliente.nombre,
            "apellido": cliente.apellido,
            "nombre_completo": cliente.nombre_completo,
            "raw": cliente.raw,
        }

    @router.get("/productos")
    async def list_productos() -> dict:
        try:
            productos = await crm.list_productos()
        except CrmApiError as exc:
            raise HTTPException(status_code=502, detail=str(exc)) from exc
        return {
            "count": len(productos),
            "productos": [
                {"id": p.id, "nombre": p.nombre, "raw": p.raw} for p in productos
            ],
        }

    @router.get("/productos/{producto_id}")
    async def get_producto(producto_id: str) -> dict:
        try:
            producto = await crm.get_producto(producto_id)
        except CrmApiError as exc:
            raise HTTPException(status_code=502, detail=str(exc)) from exc
        if not producto:
            raise HTTPException(status_code=404, detail="Producto no encontrado")
        return {
            "id": producto.id,
            "nombre": producto.nombre,
            "raw": producto.raw,
        }

    @router.get("/polizas")
    async def list_polizas() -> dict:
        try:
            polizas = await crm.list_polizas()
        except CrmApiError as exc:
            raise HTTPException(status_code=502, detail=str(exc)) from exc
        return {
            "count": len(polizas),
            "polizas": [{"id": p.id, 
            "nombre": p.nombre, 
            "apellido": p.apellido, 
            "poliza": p.poliza, 
            "producto": p.producto, 
            "plan_actual": p.plan_actual, 
            "precio_actual": p.precio_actual, 
            "moneda": p.moneda, 
            "creado": p.creado, 
            "plan_ofrecido": p.plan_ofrecido, 
            "precio_ofrecido": p.precio_ofrecido,            
            "precio_especial": p.precio_especial,
            "monto_asegurado": p.monto_asegurado,
            "raw": p.raw} for p in polizas
            ],
        }

    @router.get("/polizas/{poliza_id}")
    async def get_poliza(poliza_id: str) -> dict:
        try:
            poliza = await crm.get_poliza(poliza_id)
        except CrmApiError as exc:
            raise HTTPException(status_code=502, detail=str(exc)) from exc
        if not poliza:
            raise HTTPException(status_code=404, detail="Póliza no encontrada")
        return {
            "id": poliza.id,
            "nombre": poliza.nombre,
            "apellido": poliza.apellido,
            "poliza": poliza.poliza,
            "producto": poliza.producto,
            "plan_actual": poliza.plan_actual,
            "precio_actual": poliza.precio_actual,
            "plan_ofrecido": p.plan_ofrecido, 
            "precio_ofrecido": p.precio_ofrecido,
            "precio_especial": p.precio_especial, 
            "monto_asegurado": p.monto_asegurado,
            "moneda": poliza.moneda,
            "creado": poliza.creado,
            "monto_asegurado": poliza.monto_asegurado,
            "raw": poliza.raw,
        }

    return router