"""
Testes para as melhorias de schema (Task 2):
  1. classe_codigo — extração de código TPU numérico da classe
  2. tribunal.sistema — inferência por sigla (e-SAJ / PJe / eproc)
  3. nivel_sigilo — derivado de segredo_justica no parser Escavador
"""

import json
import pytest
from pathlib import Path
from pyjuris import normalizar_processo
from pyjuris.inputs.escavador import _extract_classe_codigo

FIXTURES = Path(__file__).parent / "fixtures"


def load(name: str) -> dict:
    return json.loads((FIXTURES / name).read_text())


def make_payload(sigla: str = "TJSP", grau: int = 1, classe: str = "Procedimento Comum Cível",
                 segredo: bool = False) -> dict:
    return {
        "numero_cnj": "1234567-89.2025.8.26.0100",
        "ano_inicio": 2025,
        "fontes": [{
            "id": 1,
            "sigla": sigla,
            "nome": f"Tribunal {sigla}",
            "grau": grau,
            "grau_formatado": "Primeiro Grau",
            "status_predito": "ATIVO",
            "arquivado": False,
            "segredo_justica": segredo,
            "capa": {"classe": classe},
            "envolvidos": [],
        }],
    }


# ---------------------------------------------------------------------------
# 1. classe_codigo
# ---------------------------------------------------------------------------

class TestExtractClasseCodigo:
    def test_codigo_sufixo_parenteses(self):
        assert _extract_classe_codigo("Procedimento Comum Cível (436)") == 436

    def test_codigo_prefixo_traco(self):
        assert _extract_classe_codigo("436 - Procedimento Comum Cível") == 436

    def test_sem_codigo_retorna_none(self):
        assert _extract_classe_codigo("Procedimento Comum Cível") is None

    def test_none_retorna_none(self):
        assert _extract_classe_codigo(None) is None

    def test_codigo_dois_digitos(self):
        assert _extract_classe_codigo("Recurso Especial (85)") == 85

    def test_codigo_varios_digitos(self):
        assert _extract_classe_codigo("1723 - Rescisão do Contrato de Trabalho") == 1723


def test_classe_codigo_no_resultado_escavador():
    payload = make_payload(classe="Procedimento Comum Cível (436)")
    result = normalizar_processo(payload, input_template="escavador")
    inst = result["instancias"][0]
    assert inst["classe_codigo"] == 436


def test_classe_codigo_none_quando_ausente():
    payload = make_payload(classe="Procedimento Comum Cível")
    result = normalizar_processo(payload, input_template="escavador")
    inst = result["instancias"][0]
    assert inst["classe_codigo"] is None


def test_classe_codigo_prefixo_numerico():
    payload = make_payload(classe="436 - Procedimento Comum Cível")
    result = normalizar_processo(payload, input_template="escavador")
    inst = result["instancias"][0]
    assert inst["classe_codigo"] == 436


def test_classe_codigo_preservado_output_lops_api():
    payload = make_payload(classe="Procedimento Comum Cível (436)")
    result = normalizar_processo(payload, input_template="escavador", output_template="lops_api")
    inst = result["instancias"][0]
    assert inst["classe_codigo"] == 436


# ---------------------------------------------------------------------------
# 2. tribunal.sistema
# ---------------------------------------------------------------------------

@pytest.mark.parametrize("sigla,sistema_esperado", [
    ("TJSP", "e-SAJ"),
    ("TJBA", "e-SAJ"),
    ("TJSC", "e-SAJ"),
    ("TJRJ", "PJe"),
    ("TJMG", "PJe"),
    ("STJ",  "PJe"),
    ("STF",  "PJe"),
    ("TST",  "PJe"),
    ("TRT15", "PJe"),
    ("TRF1", "PJe"),
    ("TRF4", "eproc"),
    ("TJRS", "eproc"),
])
def test_tribunal_sistema_por_sigla(sigla, sistema_esperado):
    payload = make_payload(sigla=sigla)
    result = normalizar_processo(payload, input_template="escavador")
    inst = result["instancias"][0]
    assert inst["tribunal"]["sistema"] == sistema_esperado, (
        f"{sigla}: esperado={sistema_esperado}, obtido={inst['tribunal']['sistema']}"
    )


def test_tribunal_sistema_desconhecido_retorna_none():
    # Sigla inexistente → None (sem falha)
    payload = make_payload(sigla="TJXX")
    result = normalizar_processo(payload, input_template="escavador")
    inst = result["instancias"][0]
    assert inst["tribunal"]["sistema"] is None


def test_tribunal_sistema_fixture_simples():
    # payload_simples usa TJSP → e-SAJ
    result = normalizar_processo(load("payload_simples.json"), input_template="escavador")
    assert result["instancias"][0]["tribunal"]["sistema"] == "e-SAJ"


def test_tribunal_sistema_fixture_stj():
    result = normalizar_processo(load("payload_stj_recurso_especial.json"), input_template="escavador")
    g3 = next(i for i in result["instancias"] if i["grau"] == 3)
    assert g3["tribunal"]["sistema"] == "PJe"


# ---------------------------------------------------------------------------
# 3. nivel_sigilo — Escavador
# ---------------------------------------------------------------------------

def test_nivel_sigilo_publico():
    result = normalizar_processo(make_payload(segredo=False), input_template="escavador")
    assert result["nivel_sigilo"] == 0
    assert result["segredo_justica"] is False


def test_nivel_sigilo_segredo():
    result = normalizar_processo(make_payload(segredo=True), input_template="escavador")
    assert result["nivel_sigilo"] == 1
    assert result["segredo_justica"] is True


def test_nivel_sigilo_na_saida_lops_api():
    result = normalizar_processo(make_payload(segredo=False), input_template="escavador", output_template="lops_api")
    assert result["nivel_sigilo"] == 0


def test_nivel_sigilo_segredo_na_saida_lops_api():
    result = normalizar_processo(make_payload(segredo=True), input_template="escavador", output_template="lops_api")
    assert result["nivel_sigilo"] == 1


def test_nivel_sigilo_fixture_segredo_justica():
    result = normalizar_processo(load("payload_segredo_justica.json"), input_template="escavador")
    assert result["nivel_sigilo"] == 1


def test_nivel_sigilo_fixture_simples():
    result = normalizar_processo(load("payload_simples.json"), input_template="escavador")
    assert result["nivel_sigilo"] == 0
