"""Python/JS reporting parity: assert the shared golden fixture.

tests/fixtures/reporting_golden.json is the parity contract between the

Python formulas (oakbench.stats / oakbench.reporting) and their Cloudflare

worker ports (cloudflare/reporting.mjs). This module asserts every golden

case against the REAL Python functions, then — when node is available —

runs the JS side (node --test cloudflare/reporting_parity.test.mjs) so the

same numbers are asserted from both implementations.

"""

from __future__ import annotations

import json

import shutil

import subprocess

import sys

import unittest

from pathlib import Path

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

sys.path.insert(0, str(ROOT / "scripts"))

from oakbench.reporting import TAIL_PERCENTILE_MIN_SAMPLES, delta_pct, median, tail_latency_summary

from oakbench.stats import percentile_nearest

GOLDEN_PATH = ROOT / "tests" / "fixtures" / "reporting_golden.json"

GOLDEN = json.loads(GOLDEN_PATH.read_text())

class PercentileNearestGoldenTest(unittest.TestCase):

    def test_all_cases(self) -> None:

        for case in GOLDEN["percentile_nearest"]:

            with self.subTest(values=case["values"], p=case["p"]):

                self.assertEqual(percentile_nearest(case["values"], case["p"]), case["expected"])

    def test_covers_empty_single_and_ties(self) -> None:

        """The contract must keep exercising the edge cases it promises."""

        cases = GOLDEN["percentile_nearest"]

        self.assertTrue(any(case["values"] == [] and case["expected"] is None for case in cases))

        self.assertTrue(any(len(case["values"]) == 1 for case in cases))

        self.assertTrue(any(len(set(case["values"])) == 1 and len(case["values"]) > 1 for case in cases))

class DeltaPctGoldenTest(unittest.TestCase):

    def test_all_cases(self) -> None:

        for case in GOLDEN["delta_pct"]:

            with self.subTest(base=case["base"], value=case["value"]):

                self.assertEqual(delta_pct(case["base"], case["value"]), case["expected"])

    def test_base_zero_guard_documented(self) -> None:

        zero_cases = [case for case in GOLDEN["delta_pct"] if case["base"] == 0]

        self.assertTrue(zero_cases, "fixture must include the base == 0 guard")

        for case in zero_cases:

            self.assertEqual(case["expected"], 0.0)

class AggregateGroupGoldenTest(unittest.TestCase):

    def test_expected_matches_python_formulas(self) -> None:

        rows = GOLDEN["aggregate_group"]["rows"]

        expected = GOLDEN["aggregate_group"]["expected"]

        values = [

            row["elapsed_ms"]

            for row in rows

            if row["returncode"] == 0 and row["elapsed_ms"] is not None

        ]

        self.assertEqual(median(values), expected["median"])

        self.assertEqual(percentile_nearest(values, 90), expected["p90"])

        self.assertEqual(percentile_nearest(values, 95), expected["p95"])

        self.assertEqual(percentile_nearest(values, 99), expected["p99"])

        self.assertEqual(len(values), expected["n"])

    def test_fixture_exercises_null_preservation(self) -> None:

        rows = GOLDEN["aggregate_group"]["rows"]

        self.assertTrue(any(row["elapsed_ms"] is None for row in rows))

        self.assertTrue(any(row.get("estimated_tokens_total") is None for row in rows))

        self.assertTrue(any(row["returncode"] == 77 for row in rows))

        self.assertTrue(any(row["returncode"] not in (0, 77) for row in rows))

class AggregateTailGatingGoldenTest(unittest.TestCase):

    """Tail honesty parity: p95 null below n=20, p99 null below n=100.

    Python side asserts oakbench.reporting.tail_latency_summary; the JS side

    asserts the same cases against computeAggregates' gated p95_ms/p99_ms

    (cloudflare/reporting.mjs TAIL_MIN_SAMPLES mirrors

    TAIL_PERCENTILE_MIN_SAMPLES / scripts/benchmark_stats.py).

    """

    def test_expected_matches_tail_latency_summary(self) -> None:

        for case in GOLDEN["aggregate_tail_gating"]["cases"]:

            values = case["values"]

            expected = case["expected"]

            with self.subTest(n=len(values)):

                summary = tail_latency_summary(values)

                self.assertEqual(summary["n"], len(values))

                self.assertEqual(summary["p50_ms"], expected["p50"])

                self.assertEqual(summary["p95_ms"], expected["p95"])

                self.assertEqual(summary["p99_ms"], expected["p99"])

                self.assertEqual(summary["tail_supported"], expected["tail_supported"])

    def test_fixture_covers_both_gate_boundaries(self) -> None:

        sizes = {len(case["values"]) for case in GOLDEN["aggregate_tail_gating"]["cases"]}

        self.assertIn(TAIL_PERCENTILE_MIN_SAMPLES["p95"], sizes, "n=20 boundary case present")

        self.assertIn(TAIL_PERCENTILE_MIN_SAMPLES["p99"], sizes, "n=100 boundary case present")

        self.assertTrue(any(size < TAIL_PERCENTILE_MIN_SAMPLES["p95"] for size in sizes), "ungated-n case present")

class ComparisonGoldenTest(unittest.TestCase):

    def test_expected_matches_python_formulas(self) -> None:

        comparison = GOLDEN["comparison"]

        oak_median = median(comparison["oak_values"])

        git_median = median(comparison["git_values"])

        self.assertEqual(oak_median, comparison["expected_oak_median"])

        self.assertEqual(git_median, comparison["expected_git_median"])

        self.assertEqual(oak_median / git_median, comparison["expected_ratio"])

        self.assertEqual(delta_pct(git_median, oak_median), comparison["expected_delta_pct"])

class NodeParityTest(unittest.TestCase):

    """Run the JS side of the contract when node is installed."""

    def test_node_suite_passes(self) -> None:

        node = shutil.which("node")

        if node is None:

            self.skipTest("node absent")

        proc = subprocess.run(

            [node, "--test", "cloudflare/reporting_parity.test.mjs"],

            cwd=ROOT,

            capture_output=True,

            text=True,

            timeout=120,

        )

        self.assertEqual(

            proc.returncode,

            0,

            f"node --test failed:\nSTDOUT:\n{proc.stdout}\nSTDERR:\n{proc.stderr}",

        )

if __name__ == "__main__":

    unittest.main()