"""Testes do banco, da cegueira e da estatística."""
from __future__ import annotations

import os
import sys
import unittest

sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "harness"))

import bank  # noqa: E402
import blind  # noqa: E402
import stats  # noqa: E402

RAIZ = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))


class TesteBanco(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.itens = bank.load_bank(os.path.join(RAIZ, "banco"))

    def test_total_700(self):
        self.assertEqual(len(self.itens), 700)

    def test_schema_valido(self):
        self.assertEqual(bank.validate(self.itens), [])

    def test_balanceamento_por_dominio(self):
        for dom in bank.DOMINIOS:
            self.assertEqual(sum(1 for i in self.itens if i["domain"] == dom), 100, dom)

    def test_balanceamento_por_idioma(self):
        self.assertEqual(sum(1 for i in self.itens if i["lang"] == "pt"), 238)
        self.assertEqual(sum(1 for i in self.itens if i["lang"] == "en"), 231)
        self.assertEqual(sum(1 for i in self.itens if i["lang"] == "zh"), 231)

    def test_sem_enunciados_duplicados(self):
        erros = [e for e in bank.validate(self.itens) if "duplicado" in e]
        self.assertEqual(erros, [])

    def test_pesos_consistentes(self):
        for it in self.itens:
            self.assertEqual(it["pts"], bank.PONTOS[it["type"]], it["id"])

    def test_split_calibracao(self):
        calib, prova = bank.split_calibracao(self.itens, 0.10, 20261111)
        self.assertEqual(len(calib) + len(prova), 700)
        self.assertGreater(len(calib), 60)
        self.assertLess(len(calib), 90)
        ids_c = {i["id"] for i in calib}
        ids_p = {i["id"] for i in prova}
        self.assertEqual(ids_c & ids_p, set())

    def test_canario_unico(self):
        itens = bank.injetar_canarios([dict(self.itens[0])], "2026-Q4")
        self.assertTrue(itens[0]["canary"].startswith("CN-"))
        self.assertNotEqual(itens[0]["canary"], bank.injetar_canarios([dict(self.itens[0])], "outra")[0]["canary"])


class TesteCegueira(unittest.TestCase):
    def test_anonimiza_autoidentificacao(self):
        t = blind.anonimizar("Como um modelo da OpenAI, analiso o contrato. Claude e o GPT-5 são concorrentes.")
        self.assertNotIn("OpenAI", t)
        self.assertNotIn("Claude", t)
        self.assertNotIn("GPT-5", t)

    def test_anonimiza_chines(self):
        t = blind.anonimizar("我是由智谱 AI 训练的模型，请查看 DeepSeek 的说明。")
        self.assertNotIn("DeepSeek", t)

    def test_rotulos_deterministicos(self):
        r1 = blind.atribuir_rotulos(["A", "B", "C"], 42)
        r2 = blind.atribuir_rotulos(["A", "B", "C"], 42)
        self.assertEqual(r1, r2)
        self.assertEqual(len({v for v in r1.values()}), 3)

    def test_rotulos_nao_ordenados(self):
        r = blind.atribuir_rotulos(["Zzz", "Aaa"], 20261111)
        self.assertNotEqual(r["Aaa"], "SISTEMA-01")

    def test_ordem_reproduzivel(self):
        itens = [{"id": str(i)} for i in range(20)]
        a = [i["id"] for i in blind.ordem_apresentacao(itens, 7)]
        b = [i["id"] for i in blind.ordem_apresentacao(itens, 7)]
        self.assertEqual(a, b)
        self.assertEqual(sorted(a), sorted(i["id"] for i in itens))


class TesteEstatistica(unittest.TestCase):
    def test_media_desvio(self):
        self.assertEqual(stats.media([1, 2, 3]), 2)
        self.assertAlmostEqual(stats.desvio([1, 2, 3]), 1.0)

    def test_ic_bootstrap_contem_media(self):
        vals = [50 + (i % 7) for i in range(100)]
        baixo, alto = stats.ic_bootstrap(vals, seed=1, n=300)
        self.assertLessEqual(baixo, stats.media(vals))
        self.assertGreaterEqual(alto, stats.media(vals))

    def test_bradley_terry_ordenacao(self):
        vitorias = {("A", "B"): 90, ("B", "A"): 10, ("A", "C"): 80, ("C", "A"): 20,
                    ("B", "C"): 60, ("C", "B"): 40}
        forca = stats.bradley_terry(vitorias)
        self.assertGreater(forca["A"], forca["B"])
        self.assertGreater(forca["B"], forca["C"])
        self.assertAlmostEqual(sum(forca.values()), 1.0, places=6)

    def test_elo_escala(self):
        elos = stats.elo_de_forca({"A": 0.6, "B": 0.4})
        self.assertEqual(elos["A"], 1900.0)
        self.assertEqual(elos["B"], 1100.0)

    def test_sobreposicao(self):
        self.assertGreater(stats.sobreposicao_ngramas("a b c d e f g h i j", "a b c d e f g h i j"), 0.99)
        self.assertEqual(stats.sobreposicao_ngramas("a b c d e f g h i j", "z y x w v u t s r q"), 0.0)

    def test_empate_tecnico(self):
        self.assertTrue(stats.empate_tecnico((50.0, 52.0), (50.5, 52.5)))
        self.assertFalse(stats.empate_tecnico((10.0, 12.0), (90.0, 92.0)))


if __name__ == "__main__":
    unittest.main()