from __future__ import annotations

import json
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch

from barbet_bgd.io import iter_jsonl_gz
from barbet_bgd.quality_v2 import validate_record_quality_v2
from barbet_bgd.v2_cli import run_build_v2


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


class V2BuildPipelineTests(unittest.TestCase):
    def _small_shard_config(self, root: Path, shard_size: int = 10) -> Path:
        config = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
        config["shard_size"] = shard_size
        path = root / "selected_sft_1m_v2.test.json"
        path.write_text(
            json.dumps(config, ensure_ascii=False, indent=2) + "\n",
            encoding="utf-8",
        )
        return path

    def test_limit_build_writes_aligned_canonical_and_keep_sidecars(self) -> None:
        with tempfile.TemporaryDirectory() as tmp:
            root = Path(tmp)
            config_path = self._small_shard_config(root)
            output = root / "v2-smoke"
            result = run_build_v2(
                config_path=config_path,
                output_root=output,
                workers=1,
                limit=25,
                project_root=ROOT,
            )

            self.assertTrue(result["quality_artifacts_verified"])
            self.assertTrue(result["partial_run"])
            self.assertFalse(result["training_promotion_passed"])
            self.assertTrue((output / "_VERIFIED.json").is_file())
            self.assertFalse((output / "_PROMOTED.json").exists())
            self.assertFalse((output / "_SUCCESS.json").exists())

            manifest = json.loads((output / "manifest.json").read_text(encoding="utf-8"))
            self.assertEqual(manifest["totals"]["records"], 25)
            self.assertEqual(manifest["totals"]["shards"], 3)
            self.assertEqual(
                [row["records"] for row in manifest["shards"]],
                [10, 10, 5],
            )
            self.assertIn("config", manifest["metadata"])
            self.assertEqual(len(manifest["metadata"]["generation_plan"]["sha256"]), 64)
            self.assertEqual(len(manifest["metadata"]["source_bundle"]["sha256"]), 64)
            logical_paths = {
                row["logical_path"]
                for row in manifest["metadata"]["source_bundle"]["files"]
            }
            self.assertIn("src/barbet_bgd/generation_v2.py", logical_paths)
            self.assertIn("src/barbet_bgd/quality_v2.py", logical_paths)
            self.assertIn("src/barbet_bgd/serializers_v2.py", logical_paths)
            self.assertTrue((output / "source_bundle_manifest.json").is_file())
            self.assertTrue((output / "source_bundle_snapshot.tar.gz").is_file())
            self.assertEqual(
                len(manifest["metadata"]["source_snapshot"]["sha256"]),
                64,
            )

            records = []
            verdicts = []
            for shard in manifest["shards"]:
                records.extend(iter_jsonl_gz(shard["canonical_path"]))
                verdicts.extend(iter_jsonl_gz(shard["verdict_path"]))
            self.assertEqual(len(records), 25)
            self.assertEqual(len(verdicts), 25)
            for index, (record, verdict) in enumerate(zip(records, verdicts, strict=True)):
                self.assertEqual(record["record_id"], f"bgd_tw_v2_{index:07d}")
                self.assertEqual(verdict["record_id"], record["record_id"])
                self.assertEqual(verdict["record_index"], index)
                self.assertEqual(verdict["disposition"], "KEEP")
                self.assertTrue(verdict["training_ready"])
                self.assertTrue(all(verdict["pipeline_checks"].values()))
                self.assertEqual(validate_record_quality_v2(record)["disposition"], "KEEP")

            postwrite = json.loads(
                (output / "reports" / "postwrite-verification.json").read_text(
                    encoding="utf-8"
                )
            )
            self.assertEqual(postwrite["statistics"]["keep_records"], 25)
            self.assertEqual(postwrite["statistics"]["reject_records"], 0)
            self.assertEqual(postwrite["verification_issue_counts"], {})
            self.assertTrue(postwrite["gates"]["all_records_exactly_regenerated"])
            self.assertTrue(postwrite["gates"]["all_verdicts_independently_recomputed"])
            self.assertTrue(postwrite["gates"]["first_and_second_corpus_statistics_equal"])

    def test_non_keep_record_fails_closed_before_canonical_publication(self) -> None:
        with tempfile.TemporaryDirectory() as tmp:
            root = Path(tmp)
            config_path = self._small_shard_config(root)
            output = root / "v2-rejected"

            def reject(record):
                verdict = validate_record_quality_v2(record)
                verdict["hard_failures"] = ["TEST_FORCED_REJECTION"]
                verdict["training_ready"] = False
                verdict["disposition"] = "REJECT"
                return verdict

            with patch("barbet_bgd.v2_cli.validate_record_quality_v2", side_effect=reject):
                with self.assertRaisesRegex(RuntimeError, "failed closed quality gates"):
                    run_build_v2(
                        config_path=config_path,
                        output_root=output,
                        workers=1,
                        limit=1,
                        project_root=ROOT,
                    )

            self.assertTrue((output / "_BUILD_FAILED.json").is_file())
            self.assertFalse(any((output / "canonical").glob("*.jsonl.gz")))
            self.assertFalse(any((output / "quality" / "verdicts").glob("*.jsonl.gz")))
            self.assertFalse((output / "_PROMOTED.json").exists())
            self.assertFalse((output / "_SUCCESS.json").exists())

    def test_refuses_to_overwrite_any_existing_output(self) -> None:
        with tempfile.TemporaryDirectory() as tmp:
            root = Path(tmp)
            config_path = self._small_shard_config(root)
            output = root / "occupied"
            output.mkdir()
            (output / "user-owned.txt").write_text("preserve", encoding="utf-8")
            with self.assertRaises(FileExistsError):
                run_build_v2(
                    config_path=config_path,
                    output_root=output,
                    workers=1,
                    limit=1,
                    project_root=ROOT,
                )
            self.assertEqual((output / "user-owned.txt").read_text(encoding="utf-8"), "preserve")


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