from __future__ import annotations

import json
import unittest
from copy import deepcopy
from pathlib import Path

from barbet_bgd.generation import GenerationPlan, generate_record
from barbet_bgd.quality import validate_record_quality


ROOT = Path(__file__).resolve().parents[1]


class PerRecordQualityTests(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.config = json.loads((ROOT / "configs/selected_sft_1m.json").read_text())
        cls.plan = GenerationPlan(cls.config)

    def _find(self, primitive: str, family: str | None = None):
        for index in range(500):
            record = generate_record(self.config, self.plan, index)
            if record["primitive"] == primitive and (family is None or record["task_family"] == family):
                return record
        self.fail(f"missing generated example: {primitive}/{family}")

    def test_integrity_passes_all_primitive_examples(self):
        seen = set()
        for index in range(500):
            record = generate_record(self.config, self.plan, index)
            if record["primitive"] in seen:
                continue
            verdict = validate_record_quality(record, self.config, self.plan)
            self.assertTrue(verdict["integrity_passed"], verdict)
            seen.add(record["primitive"])
        self.assertEqual(len(seen), 10)

    def test_copy_mutation_is_rejected(self):
        record = deepcopy(self._find("COPY"))
        record["target"]["output_text"] += "不應新增"
        verdict = validate_record_quality(record, self.config, self.plan)
        self.assertEqual(verdict["disposition"], "REJECT")
        self.assertIn("COPY_OUTPUT_NOT_EXACT", verdict["hard_failures"])
        self.assertIn("EXACT_REGENERATION_MISMATCH", verdict["hard_failures"])

    def test_edit_operation_is_independently_executable(self):
        for index in range(1000):
            record = generate_record(self.config, self.plan, index)
            if record["primitive"] != "EDIT":
                continue
            verdict = validate_record_quality(record, self.config, self.plan)
            self.assertNotIn("EDIT_OPERATION_NOT_EXECUTABLE", verdict["hard_failures"])

    def test_provenance_mutation_is_rejected(self):
        record = deepcopy(self._find("VERIFY"))
        record["provenance"]["source_hash"] = "0" * 64
        verdict = validate_record_quality(record, self.config, self.plan)
        self.assertIn("PROVENANCE_INTEGRITY_FAILED", verdict["hard_failures"])

    def test_generic_modality_family_is_rejected_for_label_leakage(self):
        record = self._find("RANK", "ASR_NBEST_RANKING")
        verdict = validate_record_quality(record, self.config, self.plan)
        self.assertTrue(verdict["integrity_passed"])
        self.assertFalse(verdict["strict_fitness_passed"])
        self.assertEqual(verdict["disposition"], "REJECT")
        self.assertIn(
            "ASR_NBEST_RANKING_INPUT_SIGNATURE_MISMATCH",
            verdict["semantic_blockers"],
        )
        self.assertIn("RANK_GOLD_RELEVANCE_EXPOSED_IN_INPUT", verdict["semantic_blockers"])

    def test_locate_query_is_visible_and_abstain_is_supported(self):
        found = self._find("LOCATE")
        verdict = validate_record_quality(found, self.config, self.plan)
        self.assertIn("QUERY_HIDDEN_IN_TARGET", verdict["semantic_blockers"])

        contradictory = None
        for index in range(1000):
            record = generate_record(self.config, self.plan, index)
            if record["primitive"] == "LOCATE" and record["target"]["decision"] == "ABSTAIN":
                contradictory = record
                break
        self.assertIsNotNone(contradictory)
        verdict = validate_record_quality(contradictory, self.config, self.plan)
        self.assertIn(
            "LOCATE_ABSTAIN_CONTRADICTED_BY_INPUT", verdict["semantic_blockers"]
        )

    def test_candidate_ids_do_not_encode_gold(self):
        match = validate_record_quality(self._find("MATCH"), self.config, self.plan)
        rank = validate_record_quality(self._find("RANK"), self.config, self.plan)
        align = validate_record_quality(self._find("ALIGN"), self.config, self.plan)
        self.assertIn("MATCH_WINNER_ID_LEAKS_GOLD", match["semantic_blockers"])
        self.assertIn("RANK_WINNER_ID_LEAKS_GOLD", rank["semantic_blockers"])
        self.assertIn("ALIGNMENT_ID_SUFFIX_LEAKS_GOLD", align["semantic_blockers"])

    def test_task_abstention_contract_is_checked(self):
        verdict = validate_record_quality(self._find("COPY"), self.config, self.plan)
        self.assertIn(
            "ABSTENTION_LABEL_CONTRACT_INCONSISTENT", verdict["semantic_blockers"]
        )
        self.assertIn(
            "ABSTENTION_ACTION_CONTRACT_INCONSISTENT", verdict["semantic_blockers"]
        )


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