"""Tests for oakbench.calibration: versioned reporting-layer token factors."""

from __future__ import annotations

import json

import sys

import tempfile

import unittest

from pathlib import Path

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

from oakbench.calibration import (

    DEFAULT_CALIBRATION_PATH,

    available_token_counters,

    calibrated_tokens,

    load_calibration,

)

class LoadCalibrationTest(unittest.TestCase):

    def test_placeholder_config_loads(self) -> None:

        calibration = load_calibration(DEFAULT_CALIBRATION_PATH)

        self.assertEqual(calibration["schema_version"], 1)

        self.assertEqual(calibration["calibration_version"], "uncalibrated-v0")

        self.assertEqual(calibration["method"], "composition_heuristic")

        for style in ("status_output", "diff_output", "log_output", "prose"):

            entry = calibration["factors"][style]

            # Honest placeholder: usable heuristic factor, but n=0 and null CIs.

            self.assertEqual(entry["n"], 0)

            self.assertIsNone(entry["ci_low"])

            self.assertIsNone(entry["ci_high"])

    def test_bad_schema_version_raises_value_error(self) -> None:

        with tempfile.TemporaryDirectory() as tmp:

            path = Path(tmp) / "token_calibration.json"

            path.write_text(json.dumps({"schema_version": 99, "calibration_version": "x", "factors": {}}))

            with self.assertRaises(ValueError) as ctx:

                load_calibration(path)

            self.assertIn("schema_version", str(ctx.exception))

    def test_missing_schema_version_raises_value_error(self) -> None:

        with tempfile.TemporaryDirectory() as tmp:

            path = Path(tmp) / "token_calibration.json"

            path.write_text(json.dumps({"calibration_version": "x", "factors": {}}))

            with self.assertRaises(ValueError):

                load_calibration(path)

class CalibratedTokensTest(unittest.TestCase):

    CALIBRATION = {

        "schema_version": 1,

        "calibration_version": "cal-test-v1",

        "method": "composition_heuristic",

        "factors": {

            "prose": {"chars_per_token": 4.0, "ci_low": 3.8, "ci_high": 4.2, "n": 5},

            "diff_output": {"chars_per_token": 3.2, "ci_low": 3.0, "ci_high": 3.4, "n": 5},

            "log_output": {"chars_per_token": None, "ci_low": None, "ci_high": None, "n": 0},

        },

    }

    def test_math_and_version_citation(self) -> None:

        result = calibrated_tokens(400, "prose", self.CALIBRATION)

        self.assertIsNotNone(result)

        self.assertEqual(result["tokens_estimated"], 100.0)

        self.assertEqual(result["calibration_version"], "cal-test-v1")

        self.assertEqual(result["method"], "composition_heuristic")

        self.assertEqual(result["style"], "prose")

    def test_diff_style_uses_its_own_factor(self) -> None:

        result = calibrated_tokens(320, "diff_output", self.CALIBRATION)

        self.assertIsNotNone(result)

        self.assertAlmostEqual(result["tokens_estimated"], 100.0)

    def test_unknown_style_is_unmeasured(self) -> None:

        # Unknown style never gets a silent default factor (ADR-0002).

        self.assertIsNone(calibrated_tokens(400, "interpretive_dance", self.CALIBRATION))

    def test_null_factor_style_is_unmeasured(self) -> None:

        self.assertIsNone(calibrated_tokens(400, "log_output", self.CALIBRATION))

    def test_none_chars_is_unmeasured(self) -> None:

        self.assertIsNone(calibrated_tokens(None, "prose", self.CALIBRATION))

class AvailableTokenCountersTest(unittest.TestCase):

    def test_feature_detection_shape(self) -> None:

        counters = available_token_counters()

        self.assertEqual(set(counters), {"tiktoken", "anthropic_api"})

        self.assertIsInstance(counters["tiktoken"], bool)

        self.assertIsInstance(counters["anthropic_api"], bool)

if __name__ == "__main__":

    unittest.main()