"""
Output template: canonical dict → lops_api (schema v1.0)

Serializa o canonical para o formato esperado pela lops_api,
incluindo schema_version e bloco _etl de rastreabilidade.
"""

from datetime import datetime, timezone

SCHEMA_VERSION = "1.0"

# ---------------------------------------------------------------------------
# Serializer
# ---------------------------------------------------------------------------

def serialize(canonical: dict, etl_version: str) -> dict:
    """
    Canonical dict → lops_api output (schema v1.0).
    Adiciona schema_version e _etl; remove campos internos (prefixo '_').
    """
    now_utc = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")

    out = {k: v for k, v in canonical.items() if not k.startswith("_")}
    out["schema_version"] = SCHEMA_VERSION
    out["_etl"] = {
        "processado_em": now_utc,
        "versao_etl": etl_version,
        "fonte_origem": canonical.get("_fonte_origem", "desconhecido"),
    }
    return out


# ---------------------------------------------------------------------------
# Persistência — upsert em cases_legalcase
# ---------------------------------------------------------------------------

UPSERT_SQL = """
    UPDATE cases_legalcase
    SET
        tipo_principal                = %(tipo_principal)s,
        fase_atual                    = %(fase_atual)s,
        status_juridico               = %(status_juridico)s,
        polo_ativo_nome               = %(polo_ativo_nome)s,
        polo_passivo_nome             = %(polo_passivo_nome)s,
        segredo_justica               = %(segredo_justica)s,
        capa_disponivel               = %(capa_disponivel)s,
        tem_audiencia                 = %(tem_audiencia)s,
        tem_multiplas_instancias_ativas = %(tem_multiplas_instancias_ativas)s,
        total_instancias              = %(total_instancias)s,
        instancias                    = %(instancias)s::jsonb,
        fenomenos_detectados          = %(fenomenos_detectados)s::text[],
        schema_version                = %(schema_version)s,
        etl_versao                    = %(etl_versao)s,
        etl_processado_em             = NOW(),
        etl_status                    = 'OK',
        atualizado_em                 = NOW(),
        data_distribuicao             = COALESCE(%(data_distribuicao)s, data_distribuicao),
        data_ultima_movimentacao      = COALESCE(%(data_ultima_movimentacao)s, data_ultima_movimentacao),
        data_verificacao_escavador    = COALESCE(%(data_verificacao_escavador)s, data_verificacao_escavador),
        valor_causa                   = COALESCE(%(valor_causa)s, valor_causa)
    WHERE numero_cnj = %(numero_cnj)s
    RETURNING id, numero_cnj, etl_status
"""


def build_upsert_params(etl_output: dict) -> dict:
    """
    Converte o output do serialize() para parâmetros do upsert SQL.
    Valores None são preservados — o SQL usa COALESCE para campos sensíveis.
    """
    import json
    inst_principal = (etl_output.get("instancias") or [{}])[0]
    return {
        "numero_cnj":                    etl_output.get("numero_cnj"),
        "tipo_principal":                etl_output.get("tipo_principal"),
        "fase_atual":                    etl_output.get("fase_atual"),
        "status_juridico":               etl_output.get("status_geral"),
        "polo_ativo_nome":               etl_output.get("polo_ativo"),
        "polo_passivo_nome":             etl_output.get("polo_passivo"),
        "segredo_justica":               etl_output.get("segredo_justica", False),
        "capa_disponivel":               etl_output.get("capa_disponivel", False),
        "tem_audiencia":                 etl_output.get("tem_audiencia", False),
        "tem_multiplas_instancias_ativas": etl_output.get("tem_multiplas_instancias_ativas", False),
        "total_instancias":              etl_output.get("total_instancias", 0),
        "instancias":                    json.dumps(etl_output.get("instancias", []), ensure_ascii=False),
        "fenomenos_detectados":          etl_output.get("fenomenos_detectados", []),
        "schema_version":                etl_output.get("schema_version"),
        "etl_versao":                    (etl_output.get("_etl") or {}).get("versao_etl"),
        "data_distribuicao":             etl_output.get("data_inicio"),
        "data_ultima_movimentacao":      etl_output.get("data_ultima_movimentacao"),
        "data_verificacao_escavador":    etl_output.get("data_ultima_verificacao"),
        "valor_causa":                   inst_principal.get("valor_causa"),
    }


def upsert_case(conn, etl_output: dict) -> dict | None:
    """
    Persiste o output do ETL em cases_legalcase.
    Retorna o registro atualizado ou None se o numero_cnj não existir.
    """
    params = build_upsert_params(etl_output)
    with conn.cursor() as cur:
        cur.execute(UPSERT_SQL, params)
        row = cur.fetchone()
    return {"id": row[0], "numero_cnj": row[1], "etl_status": row[2]} if row else None
