CRM_AGENTES_CARGA/backend/api/v1/modules/crm/expedientes/service.py

"""Servicio del expediente del CRM.

Funciones libres que reciben ``db, tenant_id, company_id``, como el resto de los módulos del repo.
"""

from datetime import datetime, timezone

from fastapi import HTTPException, status
from sqlalchemy.orm import Session

from ..expediente_gateway import service as gateway
from ..service_requests.models import ServiceRequest
from .dto import ExpedienteCompleteInput
from .folio import next_folio, storage_token
from .models import Expediente


def _get_service_request(db: Session, service_request_id: int, tenant_id: int, company_id: int) -> ServiceRequest:
    obj = (
        db.query(ServiceRequest)
        .filter(
            ServiceRequest.id == service_request_id,
            ServiceRequest.tenant_id == tenant_id,
            ServiceRequest.company_id == company_id,
            ServiceRequest.deleted_at.is_(None),
        )
        .first()
    )
    if not obj:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Solicitud no encontrada")
    return obj


def get_expediente(db: Session, expediente_id: int, tenant_id: int, company_id: int) -> Expediente:
    obj = (
        db.query(Expediente)
        .filter(
            Expediente.id == expediente_id,
            Expediente.tenant_id == tenant_id,
            Expediente.company_id == company_id,
            Expediente.deleted_at.is_(None),
        )
        .first()
    )
    if not obj:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Expediente no encontrado")
    return obj


def list_expedientes(
    db: Session,
    tenant_id: int,
    company_id: int,
    service_request_id: int | None = None,
    account_id: int | None = None,
    exp_status: str | None = None,
) -> list[Expediente]:
    query = db.query(Expediente).filter(
        Expediente.tenant_id == tenant_id,
        Expediente.company_id == company_id,
        Expediente.deleted_at.is_(None),
    )
    if service_request_id is not None:
        query = query.filter(Expediente.service_request_id == service_request_id)
    if account_id is not None:
        query = query.filter(Expediente.account_id == account_id)
    if exp_status:
        query = query.filter(Expediente.status == exp_status)
    return query.order_by(Expediente.created_at.desc()).all()


def find_by_service_request(
    db: Session, service_request_id: int, tenant_id: int, company_id: int
) -> Expediente | None:
    return (
        db.query(Expediente)
        .filter(
            Expediente.service_request_id == service_request_id,
            Expediente.tenant_id == tenant_id,
            Expediente.company_id == company_id,
            Expediente.deleted_at.is_(None),
        )
        .first()
    )


def ensure_expediente_for_service_request(
    db: Session,
    service_request_id: int,
    tenant_id: int,
    company_id: int,
    user_id: str | None = None,
    account_id: int | None = None,
) -> Expediente:
    """Devuelve el expediente de esa solicitud, creándolo si todavía no existe. **Idempotente.**

    **No hace commit**: hace ``flush`` sobre la sesión que recibe. La razón es que sus dos
    llamadores —``create_service_request`` y ``create_from_opportunity``— lo invocan ANTES de su
    propio commit, dentro de la misma transacción. Si esto commiteara por su cuenta, un fallo
    posterior en el alta de la solicitud dejaría un expediente huérfano con su folio ya quemado.
    Es la misma disciplina de ``next_folio`` y la del asignador de folios de Anexo22.
    """
    existing = find_by_service_request(db, service_request_id, tenant_id, company_id)
    if existing is not None:
        return existing

    folio, year, month, sequence = next_folio(db, tenant_id, company_id)
    expediente = Expediente(
        folio=folio,
        period_year=year,
        period_month=month,
        sequence=sequence,
        service_request_id=service_request_id,
        account_id=account_id,
        status="abierto",
        efc_storage_token=storage_token(company_id, folio),
        efc_link_state="PENDING",
        tenant_id=tenant_id,
        company_id=company_id,
        created_by=user_id,
        updated_by=user_id,
    )
    db.add(expediente)
    db.flush()
    # Réplica hacia EFC: best-effort y en la MISMA transacción. Si EFC está apagado
    # (``EFC_API_URL`` vacía) esto es un no-op y el expediente vive igual, solo en el CRM.
    gateway.replicate_expediente_best_effort(db, expediente)
    return expediente


def ensure_expediente(
    db: Session,
    service_request_id: int,
    tenant_id: int,
    company_id: int,
    user_id: str | None = None,
) -> Expediente:
    """Variante de cara al usuario: valida la solicitud, asegura el expediente y **sí** commitea.

    La usa el endpoint ``POST /expedientes/ensure``, donde la transacción empieza y termina aquí.
    """
    solicitud = _get_service_request(db, service_request_id, tenant_id, company_id)
    expediente = ensure_expediente_for_service_request(
        db, solicitud.id, tenant_id, company_id, user_id, account_id=solicitud.account_id
    )
    db.commit()
    db.refresh(expediente)
    return expediente


def _campos_para_efc(campos: dict) -> dict:
    """Traduce los campos del expediente al vocabulario del contrato de EFC.

    Las fechas van en ISO porque el payload del outbox se serializa a JSON, y un ``date`` de Python
    no es serializable: sin esto la fila se encolaría bien y **fallaría al entregar**, que es el peor
    momento para descubrirlo.
    """
    salida = {}
    for clave, valor in campos.items():
        salida[clave] = valor.isoformat() if hasattr(valor, "isoformat") else valor
    return salida


def complete_expediente(
    db: Session,
    expediente_id: int,
    payload: ExpedienteCompleteInput,
    tenant_id: int,
    company_id: int,
    user_id: str | None = None,
) -> Expediente:
    """Registra en el CRM la data aduanera real de un expediente.

    Solo toca la fila del CRM. Completar el pedimento provisional del lado de EFC es una operación
    aparte, del carril del gateway, porque puede fallar por causas de EFC —un pedimento real que ya
    existe con esa llave— y eso no debe impedir que el CRM guarde lo que el usuario capturó.
    """
    expediente = get_expediente(db, expediente_id, tenant_id, company_id)
    if expediente.status == "completado":
        raise HTTPException(
            status_code=status.HTTP_409_CONFLICT, detail="El expediente ya está completado"
        )

    campos = payload.model_dump(exclude_unset=True)
    for field, value in campos.items():
        setattr(expediente, field, value)
    expediente.status = "completado"
    expediente.updated_by = user_id

    # El completado del provisional en EFC va por el outbox, no inline: puede devolver 409 si allá
    # ya existe ese pedimento real, y eso no debe impedir que el CRM guarde lo que se capturó.
    gateway.enqueue_completar_best_effort(db, expediente, _campos_para_efc(campos))

    db.commit()
    db.refresh(expediente)
    return expediente


def delete_expediente(db: Session, expediente_id: int, tenant_id: int, company_id: int) -> None:
    """Baja lógica. No propaga nada a EFC: el expediente electrónico se conserva."""
    expediente = get_expediente(db, expediente_id, tenant_id, company_id)
    expediente.deleted_at = datetime.now(timezone.utc)
    db.commit()