from __future__ import annotations

import json
import tempfile
import unittest
from pathlib import Path

from barbet_bgd.generation import GenerationPlan, generate_record
from barbet_bgd.io import iter_jsonl_gz, write_json_atomic, write_jsonl_gz_atomic
from barbet_bgd.quality_cli import run_quality_validation


ROOT = Path(__file__).resolve().parents[1]
CONFIG_PATH = ROOT / "configs" / "selected_sft_1m.json"


class QualityRunnerTests(unittest.TestCase):
    def _canonical_fixture(self, root: Path, records: int = 30) -> Path:
        config = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
        plan = GenerationPlan(config)
        dataset_root = root / "dataset"
        canonical_root = dataset_root / "canonical"
        shards = []
        for shard_index, start in enumerate(range(0, records, 15)):
            end = min(records, start + 15)
            result = write_jsonl_gz_atomic(
                canonical_root / f"part-{shard_index:05d}.jsonl.gz",
                (generate_record(config, plan, index) for index in range(start, end)),
            )
            shards.append(result.to_dict())
        write_json_atomic(dataset_root / "config.snapshot.json", config)
        manifest = {
            "manifest_version": "bgd.manifest.v1",
            "metadata": {
                "config_sha256": self._semantic_hash(config),
                "dataset_name": config["dataset_name"],
            },
            "shards": shards,
            "totals": {
                "records": records,
                "shards": len(shards),
            },
        }
        write_json_atomic(dataset_root / "manifest.json", manifest)
        return dataset_root

    @staticmethod
    def _semantic_hash(value: dict) -> str:
        import hashlib

        payload = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
        return hashlib.sha256(payload.encode("utf-8")).hexdigest()

    def test_materialises_and_independently_verifies_every_record(self) -> None:
        with tempfile.TemporaryDirectory() as tmp:
            root = Path(tmp)
            dataset_root = self._canonical_fixture(root)
            output_root = root / "quality"

            verified = run_quality_validation(
                dataset_root=dataset_root,
                generation_config_path=CONFIG_PATH,
                output_root=output_root,
                project_root=ROOT,
                workers=2,
            )

            self.assertTrue(verified["quality_artifacts_verified"])
            self.assertEqual(verified["records"], 30)
            self.assertEqual(verified["shards"], 2)
            self.assertTrue((output_root / "_QUALITY_COMPLETE.json").is_file())
            self.assertTrue((output_root / "_QUALITY_VERIFIED.json").is_file())
            self.assertTrue((output_root / "reports" / "postwrite-verification.json").is_file())

            quality_manifest = json.loads(
                (output_root / "manifest.json").read_text(encoding="utf-8")
            )
            self.assertEqual(quality_manifest["totals"]["records"], 30)
            self.assertEqual([shard["start_index"] for shard in quality_manifest["shards"]], [0, 15])
            verdicts = []
            for shard in quality_manifest["shards"]:
                verdicts.extend(iter_jsonl_gz(shard["verdict_path"]))
            self.assertEqual(len(verdicts), 30)
            self.assertEqual(verdicts[0]["record_index"], 0)
            self.assertEqual(verdicts[0]["expected_record_index"], 0)
            self.assertEqual(verdicts[15]["record_index"], 15)
            self.assertEqual(verdicts[15]["source_line"], 1)

            report = json.loads((output_root / "report.json").read_text(encoding="utf-8"))
            self.assertTrue(report["all_records_audited"])
            self.assertFalse(report["training_promotion_passed"])
            self.assertFalse(report["public_release_promotion_passed"])
            self.assertTrue(report["quality_gates"]["all_records_exactly_reproduced"])
            self.assertTrue(report["config_contract"]["explicit_generation_config_used"])
            self.assertFalse(report["config_contract"]["snapshot_used_for_exact_regeneration"])
            self.assertTrue(report["config_contract"]["snapshot_generation_plan_equal"])
            self.assertIn("target_decision_by_task_family", report["statistics"])
            self.assertIn("confidence_target_histogram", report["statistics"])
            self.assertEqual(
                sum(report["statistics"]["confidence_target_histogram"].values()),
                30,
            )
            self.assertEqual(
                sum(
                    count
                    for outcomes in report["statistics"][
                        "target_decision_by_task_family"
                    ].values()
                    for count in outcomes.values()
                ),
                30,
            )

    def test_max_records_writes_an_aligned_partial_sidecar(self) -> None:
        with tempfile.TemporaryDirectory() as tmp:
            root = Path(tmp)
            dataset_root = self._canonical_fixture(root)
            output_root = root / "quality-partial"
            verified = run_quality_validation(
                dataset_root=dataset_root,
                generation_config_path=CONFIG_PATH,
                output_root=output_root,
                project_root=ROOT,
                workers=1,
                max_records=7,
            )
            self.assertEqual(verified["records"], 7)
            report = json.loads((output_root / "report.json").read_text(encoding="utf-8"))
            self.assertTrue(report["all_records_audited"])
            self.assertTrue(report["partial_run"])
            self.assertFalse(report["quality_gates"]["full_corpus_audited"])

    def test_rejects_a_canonical_shard_checksum_mismatch(self) -> None:
        with tempfile.TemporaryDirectory() as tmp:
            root = Path(tmp)
            dataset_root = self._canonical_fixture(root, records=15)
            shard_path = next((dataset_root / "canonical").glob("*.jsonl.gz"))
            shard_path.write_bytes(shard_path.read_bytes() + b"tamper")
            with self.assertRaisesRegex(ValueError, "canonical checksum mismatch"):
                run_quality_validation(
                    dataset_root=dataset_root,
                    generation_config_path=CONFIG_PATH,
                    output_root=root / "quality-bad-source",
                    project_root=ROOT,
                    workers=1,
                )


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