"""Formato compacto do estado mutavel persistido por lote.

As leituras completas ficam em ``lote_leituras``. O estado do lote guarda apenas
o snapshot necessario para abrir a Validacao rapidamente, sem repetir respostas
brutas da API nem campos que podem ser reconstruidos durante a leitura.
"""
from __future__ import annotations

from copy import deepcopy
from typing import Any


_CAMPOS_ALUNO_API = (
    "encontrado",
    "id",
    "ra",
    "nome",
    "motivo",
    "status_code",
)

_CAMPOS_VALIDACAO = (
    "arquivo_original",
    "ra_detectado",
    "nome_detectado",
    "id_final",
    "codigo_barras_final",
    "origem_id",
    "status_validacao",
    "motivo",
)

_CAMPOS_VALIDACAO_MANUAL = (
    "id_final",
    "codigo_barras_final",
    "origem_id",
    "status_validacao",
    "motivo",
)


def _tem_conteudo(valor: Any) -> bool:
    return valor is not None and valor != "" and valor != [] and valor != {}


def _copiar_campos(registro: dict, campos: tuple[str, ...]) -> dict:
    resultado: dict[str, Any] = {}
    for campo in campos:
        if campo in registro and _tem_conteudo(registro[campo]):
            resultado[campo] = deepcopy(registro[campo])
    return resultado


def compactar_aluno_api(aluno: dict | None) -> dict | None:
    """Remove o corpo bruto da API e conserva os dados normalizados usados."""
    if not isinstance(aluno, dict):
        return None

    compacto = _copiar_campos(aluno, _CAMPOS_ALUNO_API)
    if "encontrado" in aluno:
        compacto["encontrado"] = bool(aluno.get("encontrado"))
    return compacto or None


def compactar_registro_validacao(registro: dict) -> dict:
    """Mantem somente dados persistentes; rotulos e envios sao derivados."""
    if not isinstance(registro, dict):
        return {}

    compacto = _copiar_campos(registro, _CAMPOS_VALIDACAO)
    compacto["precisa_validacao_manual"] = bool(
        registro.get("precisa_validacao_manual")
    )
    aluno = compactar_aluno_api(registro.get("aluno_api"))
    if aluno:
        compacto["aluno_api"] = aluno
    return compacto


def compactar_validacao_cadastral(snapshot: dict) -> dict:
    if not isinstance(snapshot, dict):
        return {}

    # Preserva metadados de nivel superior atuais e futuros. Somente os itens
    # volumosos da validacao possuem um contrato compacto proprio.
    compacto = {
        chave: deepcopy(valor)
        for chave, valor in snapshot.items()
        if chave != "validacoes"
    }
    validacoes = snapshot.get("validacoes")
    if isinstance(validacoes, dict):
        compacto["validacoes"] = {
            str(chave): compactar_registro_validacao(registro)
            for chave, registro in validacoes.items()
            if isinstance(registro, dict)
        }
    return compacto


def compactar_validacao_manual(registros: dict) -> dict:
    if not isinstance(registros, dict):
        return {}

    resultado: dict[str, Any] = {}
    for chave, registro in registros.items():
        if not isinstance(registro, dict):
            resultado[str(chave)] = deepcopy(registro)
            continue
        compacto = _copiar_campos(registro, _CAMPOS_VALIDACAO_MANUAL)
        aluno = compactar_aluno_api(registro.get("aluno_api"))
        if aluno:
            compacto["aluno_api"] = aluno
        resultado[str(chave)] = compacto
    return resultado


def compactar_estado_lote(estado: dict | None) -> dict:
    """Retorna uma copia compacta e retrocompativel do estado do lote."""
    if not isinstance(estado, dict):
        return {}

    compacto = deepcopy(estado)
    if isinstance(compacto.get("validacao_cadastral"), dict):
        compacto["validacao_cadastral"] = compactar_validacao_cadastral(
            compacto["validacao_cadastral"]
        )
    if isinstance(compacto.get("validacao_manual"), dict):
        compacto["validacao_manual"] = compactar_validacao_manual(
            compacto["validacao_manual"]
        )
    return compacto