"""Per-cell latency verdicts (oakbench.cellstats) and their devloop wiring."""

from __future__ import annotations

import importlib.util

import random

import sys

import unittest

from pathlib import Path

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

from oakbench import cellstats  # noqa: E402

def rows_for(subject, cell_values, *, scenario="tiny_text", operation="status.dirty"):

    return [{"subject": subject, "scenario": scenario, "operation": operation, "run": run,

             "returncode": 0, "elapsed_ms": value, "vcs_tool_call_count": 1}

            for run, value in enumerate(cell_values)]

def load_devloop():

    path = Path(__file__).resolve().parents[1] / "scripts" / "devloop.py"

    spec = importlib.util.spec_from_file_location("devloop_cellstats", path)

    module = importlib.util.module_from_spec(spec)

    spec.loader.exec_module(module)

    return module

class CellStatsTest(unittest.TestCase):

    def test_gate_reproduction_identical_binary_is_not_an_improvement(self):

        # Samples from the 2026-09-19 gate: same binary both arms, the old

        # global 25.5% threshold published "-25.9% faster tiny_text/snapshot.dirty".

        baseline = [13.8, 16.2, 21.1, 22.0, 27.0]

        target = [14.9, 15.4, 15.6, 16.5, 17.0]

        control = [15.0, 21.5, 14.1, 25.0, 17.2]

        rows = (rows_for("oak_installed", baseline) + rows_for("oak_local", target)

                + rows_for("oak_installed_aa", control))

        floors = cellstats.cell_floors(rows, "oak_installed", "oak_installed_aa", lambda row: row["elapsed_ms"])

        verdicts = cellstats.classify_cells(rows, "oak_local", "oak_installed", floors)

        item = verdicts[("tiny_text", "status.dirty")]

        self.assertNotIn(item["verdict"], ("improvement", "regression"), item)

        self.assertLess(item["delta_pct"], -20)  # the point estimate alone would have been "published"

    def test_large_consistent_change_across_family_is_detected(self):

        rng = random.Random(3)

        rows = []

        for index in range(10):

            op = f"op{index}"

            rows += rows_for("oak_installed", [10 + rng.random() * 0.3 for _ in range(6)], operation=op)

            rows += rows_for("oak_installed_aa", [10 + rng.random() * 0.3 for _ in range(6)], operation=op)

            rows += rows_for("oak_local", [20 + rng.random() * 0.3 for _ in range(6)], operation=op)

        floors = cellstats.cell_floors(rows, "oak_installed", "oak_installed_aa", lambda row: row["elapsed_ms"])

        verdicts = cellstats.classify_cells(rows, "oak_local", "oak_installed", floors, min_delta_ms=5)

        self.assertEqual({item["verdict"] for item in verdicts.values()}, {"regression"})

        self.assertTrue(all(item["fdr_rejected"] for item in verdicts.values()))

    def test_single_cell_change_without_fdr_support_is_unconfirmed_not_claimed(self):

        rows = []

        for index in range(20):

            op = f"op{index}"

            slow = index == 0

            rows += rows_for("oak_installed", [10.0, 10.1, 10.2, 10.1, 10.0], operation=op)

            rows += rows_for("oak_installed_aa", [10.1, 10.0, 10.2, 10.0, 10.1], operation=op)

            rows += rows_for("oak_local", [20.0, 20.2, 20.1, 20.3, 20.1] if slow else [10.0, 10.2, 10.1, 10.0, 10.1],

                             operation=op)

        floors = cellstats.cell_floors(rows, "oak_installed", "oak_installed_aa", lambda row: row["elapsed_ms"])

        verdicts = cellstats.classify_cells(rows, "oak_local", "oak_installed", floors, min_delta_ms=5)

        slow = verdicts[("tiny_text", "op0")]

        self.assertEqual(slow["verdict"], "unconfirmed_regression")

        self.assertGreater(slow["required_n"], 0)

        self.assertEqual(sum(item["verdict"] == "no_change" for item in verdicts.values()), 19)

    def test_missing_aa_floor_or_samples_is_unmeasured(self):

        rows = rows_for("oak_installed", [10, 10, 10]) + rows_for("oak_local", [30, 30, 30])

        verdicts = cellstats.classify_cells(rows, "oak_local", "oak_installed", {})

        self.assertEqual(verdicts[("tiny_text", "status.dirty")]["verdict"], "unmeasured")

        rows = rows_for("oak_installed", [10, 11]) + rows_for("oak_local", [30, 31])

        verdicts = cellstats.classify_cells(rows, "oak_local", "oak_installed", {("tiny_text", "status.dirty"): 3.0})

        self.assertEqual(verdicts[("tiny_text", "status.dirty")]["verdict"], "unmeasured")

    def test_aa_floor_describes_the_cell_not_a_global_number(self):

        quiet = rows_for("oak_installed", [10.0, 10.1, 10.0, 10.1, 10.0], operation="quiet") + \

            rows_for("oak_installed_aa", [10.1, 10.0, 10.1, 10.0, 10.1], operation="quiet")

        noisy = rows_for("oak_installed", [10, 25, 12, 30, 11], operation="noisy") + \

            rows_for("oak_installed_aa", [28, 10, 26, 11, 13], operation="noisy")

        floors = cellstats.cell_floors(quiet + noisy, "oak_installed", "oak_installed_aa", lambda row: row["elapsed_ms"])

        self.assertEqual(floors[("tiny_text", "quiet")], cellstats.MIN_FLOOR_PCT)

        self.assertGreater(floors[("tiny_text", "noisy")], 30.0)

    def test_permutation_p_value_is_exact_for_small_samples(self):

        self.assertAlmostEqual(cellstats.permutation_p_value([1, 2, 3, 4, 5], [11, 12, 13, 14, 15]), 2 / 252)

        self.assertEqual(cellstats.permutation_p_value([1, 2, 3], [1, 2, 3]), 1.0)

    def test_failed_and_skipped_rows_are_not_samples(self):

        rows = rows_for("oak_local", [10, 11, 12])

        rows[0]["returncode"] = 1

        rows[1].update(returncode=77, skipped=True)

        self.assertEqual(cellstats.samples_by_cell(rows, "oak_local", lambda row: row["elapsed_ms"]),

                         {("tiny_text", "status.dirty"): {2: 12.0}})

class DevloopCellWiringTest(unittest.TestCase):

    def test_compare_subjects_uses_cell_verdicts_not_global_threshold(self):

        devloop = load_devloop()

        rows = rows_for("oak_installed", [10, 10, 10]) + rows_for("oak_local", [30, 30, 30])

        verdicts = {("tiny_text", "status.dirty"): {"verdict": "no_change"}}

        notes: list[str] = []

        regressions, improvements = devloop.compare_subjects(

            rows, "oak_local", "oak_installed", "Oak baseline", 10.0, 5.0,

            efficiency_gates=False, output_bytes_threshold_pct=25.0, diagnostics=notes, cell_verdicts=verdicts)

        self.assertEqual((regressions, improvements), ([], []))

        regressions, _ = devloop.compare_subjects(

            rows, "oak_local", "oak_installed", "Oak baseline", 10.0, 5.0,

            efficiency_gates=False, output_bytes_threshold_pct=25.0)

        self.assertTrue(regressions)  # legacy path unchanged when no cell verdicts are supplied

    def test_unconfirmed_regression_is_a_note_not_a_regression(self):

        devloop = load_devloop()

        rows = rows_for("oak_installed", [10, 10, 10]) + rows_for("oak_local", [30, 30, 30])

        item = {"verdict": "unconfirmed_regression", "scenario": "tiny_text", "operation": "status.dirty",

                "delta_pct": 200.0, "ci_low_pct": 190.0, "ci_high_pct": 210.0, "floor_pct": 3.0,

                "p_value": 0.1, "baseline_median": 10.0, "target_median": 30.0, "baseline_n": 3,

                "target_n": 3, "required_n": 6}

        notes: list[str] = []

        regressions, _ = devloop.compare_subjects(

            rows, "oak_local", "oak_installed", "Oak baseline", 10.0, 5.0, efficiency_gates=False,

            output_bytes_threshold_pct=25.0, diagnostics=notes, cell_verdicts={("tiny_text", "status.dirty"): item})

        self.assertEqual(regressions, [])

        self.assertTrue(notes[0].startswith("UNCONFIRMED slower"), notes)

    def test_devloop_defaults_are_at_least_five_runs(self):

        devloop = load_devloop()

        import sys as _sys

        argv = _sys.argv

        try:

            _sys.argv = ["devloop.py"]

            args = devloop.parse_args()

        finally:

            _sys.argv = argv

        self.assertGreaterEqual(args.runs, 5)

if __name__ == "__main__":

    unittest.main()