"""Tests for the token-estimate calibration classifier."""

from __future__ import annotations

import sys

from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))

import unittest

import token_calibration

class CompositionTest(unittest.TestCase):

    def test_classes_partition_the_text(self) -> None:

        text = "commit 4f2a9c8be1d34f7a line 42, words here!\n"

        counts = token_calibration.classify_chars(text)

        self.assertEqual(sum(counts.values()), len(text))

    def test_hex_runs_detected(self) -> None:

        counts = token_calibration.classify_chars("deadbeefcafe1234")

        self.assertEqual(counts["hex_run"], 16)

class BiasDirectionTest(unittest.TestCase):

    """Pins the HEURISTIC path: optional enhancers (tiktoken, ADR-0001) must

    not flip test behavior depending on what happens to be installed, so

    exact_tokens is forced off. Direction claims under a real tokenizer are

    asserted separately in TokenizerBiasDirectionTest."""

    def factor(self, sample_name: str) -> float:

        text = token_calibration.SELF_TEST_SAMPLES[sample_name]

        original = token_calibration.exact_tokens

        token_calibration.exact_tokens = lambda _text: (None, None)

        try:

            result = token_calibration.analyze_text(sample_name, text)

        finally:

            token_calibration.exact_tokens = original

        return result["calibration_factor_vs_char_div_4"]

    def test_hash_heavy_underestimated_by_char_div_4(self) -> None:

        # factor > 1 means char/4 UNDERESTIMATES; hash-heavy log output is the

        # worst case and the reason cross-subject token deltas need calibration.

        self.assertGreater(self.factor("hash_heavy_log"), 1.3)

    def test_prose_close_to_char_div_4(self) -> None:

        self.assertLess(self.factor("prose_readme"), 1.0)

        self.assertGreater(self.factor("prose_readme"), 0.8)

    def test_diff_between_the_two(self) -> None:

        self.assertGreater(self.factor("git_diff_like"), 1.0)

        self.assertLess(self.factor("git_diff_like"), self.factor("hash_heavy_log"))

class TokenizerBiasDirectionTest(unittest.TestCase):

    """Direction-only claims when a real tokenizer is present; skipped

    otherwise. Bounds are loose on purpose — exact values are calibration

    output, not test fixtures."""

    def setUp(self) -> None:

        exact, _ = token_calibration.exact_tokens("probe")

        if exact is None:

            self.skipTest("tiktoken not installed")

    def factor(self, sample_name: str) -> float:

        text = token_calibration.SELF_TEST_SAMPLES[sample_name]

        return token_calibration.analyze_text(sample_name, text)["calibration_factor_vs_char_div_4"]

    def test_hash_heavy_still_underestimated(self) -> None:

        self.assertGreater(self.factor("hash_heavy_log"), 1.0)

    def test_prose_not_underestimated(self) -> None:

        self.assertLess(self.factor("prose_readme"), 1.0)

    def test_ordering_preserved(self) -> None:

        self.assertLess(self.factor("prose_readme"), self.factor("git_diff_like"))

        self.assertLess(self.factor("git_diff_like"), self.factor("hash_heavy_log"))

class AggregateTest(unittest.TestCase):

    def test_aggregate_reports_method_honestly(self) -> None:

        results = [

            token_calibration.analyze_text(name, text)

            for name, text in token_calibration.SELF_TEST_SAMPLES.items()

        ]

        aggregate = token_calibration.aggregate(results, label="self-test")

        self.assertEqual(aggregate["samples"], 3)

        self.assertIn(aggregate["method"], {"exact_tokenizer", "mixed", "composition_heuristic"})

        self.assertIsNotNone(aggregate["calibration_factor_vs_char_div_4"])

if __name__ == "__main__":

    unittest.main()