"""
Testes de cobertura para cenários específicos do parser Escavador.

Fixtures cobertas:
  - payload_stj_recurso_especial.json  — processo multi-instância (G1 TJSP + G3 STJ)
  - payload_segredo_justica.json       — segredo de justiça ativo, capa sem classe
  - payload_trabalhista.json           — processo trabalhista (TRT15)
  - payload_campos_ausentes.json       — capa sem classe/orgão, partes vazias, datas nulas
  - payload_encerrado.json             — todas as instâncias arquivadas/inativas
"""

import json
import pytest
from pathlib import Path
from pyjuris import normalizar_processo

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


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


# ---------------------------------------------------------------------------
# Processo multi-instância: TJSP G1 (inativo) + STJ G3 (ativo)
# ---------------------------------------------------------------------------

@pytest.fixture
def stj():
    return normalizar_processo(load("payload_stj_recurso_especial.json"), input_template="escavador")


def test_stj_numero_cnj(stj):
    assert stj["numero_cnj"] == "1234567-89.2020.8.26.0100"


def test_stj_total_instancias(stj):
    assert stj["total_instancias"] == 2


def test_stj_fase_terceiro_grau(stj):
    assert stj["fase_atual"] == "TERCEIRO_GRAU"


def test_stj_tipo_recurso_superior(stj):
    assert stj["tipo_principal"] == "RECURSO_SUPERIOR"


def test_stj_status_ativo(stj):
    # STJ está ativo → processo ativo
    assert stj["status_geral"] == "ATIVO"


def test_stj_instancia_g1(stj):
    g1 = next(i for i in stj["instancias"] if i["grau"] == 1)
    assert g1["tribunal"]["sigla"] == "TJSP"
    assert g1["status"] == "INATIVO"
    assert g1["arquivado"] is True
    assert g1["classe"] == "PROCEDIMENTO COMUM CÍVEL"


def test_stj_instancia_g3(stj):
    g3 = next(i for i in stj["instancias"] if i["grau"] == 3)
    assert g3["tribunal"]["sigla"] == "STJ"
    assert g3["grau_formatado"] == "Terceiro Grau"
    assert g3["classe"] == "RECURSO ESPECIAL"
    assert g3["tipo"] == "RECURSO_SUPERIOR"
    assert g3["orgao_julgador"] == "3ª Turma"


def test_stj_polo_ativo(stj):
    assert stj["polo_ativo"] == "Maria Oliveira"


def test_stj_partes_preservadas(stj):
    g3 = next(i for i in stj["instancias"] if i["grau"] == 3)
    nomes = [p["nome"] for p in g3["partes"]]
    assert "Maria Oliveira" in nomes
    assert "Banco Bradesco S.A." in nomes


# ---------------------------------------------------------------------------
# Segredo de justiça
# ---------------------------------------------------------------------------

@pytest.fixture
def segredo():
    return normalizar_processo(load("payload_segredo_justica.json"), input_template="escavador")


def test_segredo_flag_verdadeiro(segredo):
    assert segredo["segredo_justica"] is True


def test_segredo_sem_classe_capa_disponivel(segredo):
    # capa existe (tem orgao_julgador), mas sem classe
    inst = segredo["instancias"][0]
    assert inst["capa_disponivel"] is True
    assert inst["classe"] is None


def test_segredo_orgao_julgador(segredo):
    inst = segredo["instancias"][0]
    assert inst["orgao_julgador"] == "2ª Vara de Família"


def test_segredo_status_ativo(segredo):
    assert segredo["status_geral"] == "ATIVO"
    assert segredo["fase_atual"] == "PRIMEIRO_GRAU"


def test_segredo_tipo_desconhecido_sem_classe(segredo):
    # Sem classe → tipo DESCONHECIDO
    inst = segredo["instancias"][0]
    assert inst["tipo"] == "DESCONHECIDO"


# ---------------------------------------------------------------------------
# Processo trabalhista
# ---------------------------------------------------------------------------

@pytest.fixture
def trabalhista():
    return normalizar_processo(load("payload_trabalhista.json"), input_template="escavador")


def test_trabalhista_numero_cnj(trabalhista):
    assert trabalhista["numero_cnj"] == "0001234-56.2022.5.15.0001"


def test_trabalhista_tribunal_trt15(trabalhista):
    inst = trabalhista["instancias"][0]
    assert inst["tribunal"]["sigla"] == "TRT15"


def test_trabalhista_tipo(trabalhista):
    assert trabalhista["tipo_principal"] == "ACAO_TRABALHISTA"
    inst = trabalhista["instancias"][0]
    assert inst["tipo"] == "ACAO_TRABALHISTA"


def test_trabalhista_classe_normalizada(trabalhista):
    inst = trabalhista["instancias"][0]
    assert inst["classe"] == "ACAO_TRABALHISTA"


def test_trabalhista_assunto(trabalhista):
    inst = trabalhista["instancias"][0]
    assert inst["assunto_principal"] == "Rescisão do Contrato de Trabalho"


def test_trabalhista_valor_causa(trabalhista):
    inst = trabalhista["instancias"][0]
    assert inst["valor_causa"] == 25000.00


# ---------------------------------------------------------------------------
# Campos ausentes (capa sem classe, sem orgão explícito, partes vazias)
# ---------------------------------------------------------------------------

@pytest.fixture
def ausentes():
    return normalizar_processo(load("payload_campos_ausentes.json"), input_template="escavador")


def test_ausentes_sem_classe(ausentes):
    inst = ausentes["instancias"][0]
    assert inst["classe"] is None
    assert inst["classe_raw"] is None


def test_ausentes_orgao_via_informacoes_complementares(ausentes):
    # Deve extrair orgão de informacoes_complementares → último segmento
    inst = ausentes["instancias"][0]
    assert inst["orgao_julgador"] == "3ª Vara Cível"


def test_ausentes_datas_nulas(ausentes):
    assert ausentes["data_inicio"] is None
    assert ausentes["data_ultima_movimentacao"] is None


def test_ausentes_polo_nulo(ausentes):
    assert ausentes["polo_ativo"] is None
    assert ausentes["polo_passivo"] is None


def test_ausentes_partes_vazias(ausentes):
    inst = ausentes["instancias"][0]
    assert inst["partes"] == []


def test_ausentes_tipo_desconhecido(ausentes):
    assert ausentes["tipo_principal"] == "DESCONHECIDO"


def test_ausentes_capa_disponivel(ausentes):
    # Tem informacoes_complementares → capa existe
    inst = ausentes["instancias"][0]
    assert inst["capa_disponivel"] is True


# ---------------------------------------------------------------------------
# Processo encerrado (todas as instâncias arquivadas)
# ---------------------------------------------------------------------------

@pytest.fixture
def encerrado():
    return normalizar_processo(load("payload_encerrado.json"), input_template="escavador")


def test_encerrado_status_geral(encerrado):
    assert encerrado["status_geral"] == "INATIVO"


def test_encerrado_fase(encerrado):
    assert encerrado["fase_atual"] == "ENCERRADO"


def test_encerrado_total_instancias(encerrado):
    assert encerrado["total_instancias"] == 2


def test_encerrado_instancias_arquivadas(encerrado):
    for inst in encerrado["instancias"]:
        assert inst["status"] == "INATIVO"
        assert inst["arquivado"] is True


def test_encerrado_tipo_principal(encerrado):
    # Maior grau com tipo conhecido: G2 Apelação Cível → RECURSO
    assert encerrado["tipo_principal"] == "RECURSO"


def test_encerrado_g1_classe(encerrado):
    g1 = next(i for i in encerrado["instancias"] if i["grau"] == 1)
    assert g1["classe"] == "PROCEDIMENTO COMUM CÍVEL"


def test_encerrado_g2_classe(encerrado):
    g2 = next(i for i in encerrado["instancias"] if i["grau"] == 2)
    assert g2["classe"] == "APELAÇÃO CÍVEL"
    assert g2["tipo"] == "RECURSO"


def test_encerrado_polo_ativo(encerrado):
    assert encerrado["polo_ativo"] == "Ana Paula Ferreira"


def test_encerrado_movimentos_reservado(encerrado):
    for inst in encerrado["instancias"]:
        assert inst["movimentos"] == []
