from __future__ import annotations

import json
import unittest
from collections import Counter
from pathlib import Path

from barbet_bgd.generation import GenerationPlan, PRIMITIVES, _long_bucket, generate_record
from barbet_bgd.serializers import build_messages, serialize_target


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


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

    def test_one_cycle_has_exact_configured_mixture(self):
        counts = Counter(self.plan.position(i).primitive for i in range(100))
        self.assertEqual(counts, Counter(self.config["primitive_percent"]))
        mixtures = Counter(self.plan.position(i).mixture_category for i in range(100))
        self.assertEqual(mixtures, Counter(self.config["mixture_percent"]))
        serializers = Counter(self.plan.position(i).serializer for i in range(100))
        self.assertEqual(serializers, Counter(self.config["serializer_percent"]))
        self.assertEqual(sum(self.plan.position(i).is_long_context for i in range(100)), 5)

    def test_generation_is_deterministic(self):
        for index in (0, 1, 19, 20, 99, 100, 979_999, 980_000, 989_999, 990_000):
            self.assertEqual(
                generate_record(self.config, self.plan, index),
                generate_record(self.config, self.plan, index),
            )

    def test_generation_does_not_depend_on_json_key_order(self):
        sorted_config = json.loads(
            json.dumps(self.config, ensure_ascii=False, sort_keys=True)
        )
        sorted_plan = GenerationPlan(sorted_config)
        for index in (0, 1, 99, 100, 500_000, 990_000):
            self.assertEqual(self.plan.position(index), sorted_plan.position(index))
            self.assertEqual(
                generate_record(self.config, self.plan, index),
                generate_record(sorted_config, sorted_plan, index),
            )

    def test_split_boundaries_do_not_break_source_group(self):
        self.assertEqual(self.plan.position(979_999).split, "train")
        self.assertEqual(self.plan.position(980_000).split, "validation")
        self.assertEqual(self.plan.position(989_999).split, "validation")
        self.assertEqual(self.plan.position(990_000).split, "test")
        before = generate_record(self.config, self.plan, 979_999)["source_group"]
        after = generate_record(self.config, self.plan, 980_000)["source_group"]
        self.assertNotEqual(before, after)

    def test_all_primitives_build_structured_targets(self):
        seen = set()
        for index in range(300):
            record = generate_record(self.config, self.plan, index)
            seen.add(record["primitive"])
            self.assertIn("decision", record["target"])
            self.assertIn("evidence", record["target"])
            self.assertIn("confidence_target", record["target"])
            self.assertIn("action", record["target"])
            self.assertEqual(record["language"][0], "zh-TW")
            self.assertEqual(record["locale"], "zh-TW")
        self.assertEqual(seen, set(PRIMITIVES))

    def test_each_hundred_long_records_has_exact_length_mix(self):
        counts = Counter(_long_bucket(i, 50_000)[0] for i in range(100))
        self.assertEqual(
            counts,
            Counter({"0.5K-4K": 75, "4K-16K": 18, "16K-64K": 6, "64K-128K": 1}),
        )

    def test_serializers_are_controlled_views(self):
        target = generate_record(self.config, self.plan, 0)["target"]
        for serializer in ("JSON", "FUNCTION_CALL", "COMPACT_TAGS", "KEY_VALUE"):
            rendered = serialize_target(target, serializer)
            self.assertIn("decision", rendered)
            self.assertIn(str(target["decision"]), rendered)
        messages = build_messages(generate_record(self.config, self.plan, 0))
        self.assertEqual([item["role"] for item in messages], ["system", "user", "assistant"])


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