from __future__ import annotations

import contextlib

import io

import json

import os

import subprocess

import sys

import tempfile

import unittest

from pathlib import Path

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

import crosscheck_hyperfine as crosscheck

class HyperfineCrosscheckTest(unittest.TestCase):

    def test_skip_row_names_hyperfine_and_uses_skip_contract(self) -> None:

        row = crosscheck.skip_row(

            command=["oak", "status"],

            reason="hyperfine not found on PATH",

            bench_id="bench-1",

            scenario="s",

            operation="op",

            run=2,

            subject="oak",

            subject_kind="oak",

        )

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

        self.assertEqual(row["returncode"], 77)

        self.assertTrue(row["skipped"])

        self.assertIn("hyperfine", row["skip_reason"])

        self.assertEqual(row["command"], ["oak", "status"])

        self.assertEqual(row["measurement_source"], "external_hyperfine")

    def test_measurement_row_converts_hyperfine_seconds_to_ms(self) -> None:

        result = {

            "command": "python -c pass",

            "mean": 0.012,

            "median": 0.01,

            "stddev": 0.002,

            "min": 0.009,

            "max": 0.02,

            "times": [0.009, 0.01, 0.02],

        }

        row = crosscheck.measurement_row(command=["python", "-c", "pass"], hyperfine_result=result)

        self.assertEqual(row["elapsed_ms"], 10.0)

        self.assertEqual(row["returncode"], 0)

        self.assertEqual(row["hyperfine_mean_ms"], 12.0)

        self.assertEqual(row["hyperfine_median_ms"], 10.0)

        self.assertEqual(row["hyperfine_stddev_ms"], 2.0)

        self.assertEqual(row["hyperfine_min_ms"], 9.0)

        self.assertEqual(row["hyperfine_max_ms"], 20.0)

        self.assertEqual(row["hyperfine_times_ms"], [9.0, 10.0, 20.0])

    def test_run_hyperfine_reads_exported_json_from_fake_runner(self) -> None:

        with tempfile.TemporaryDirectory(prefix="oakbench-hyperfine-test-") as tmp:

            fake = Path(tmp) / "hyperfine"

            fake.write_text("#!/bin/sh\nexit 0\n")

            fake.chmod(0o755)

            def runner(args, **kwargs):  # type: ignore[no-untyped-def]

                export_path = Path(args[args.index("--export-json") + 1])

                export_path.write_text(json.dumps({"results": [{"command": "echo ok", "median": 0.003}]}))

                return subprocess.CompletedProcess(args, 0, stdout="", stderr="")

            result = crosscheck.run_hyperfine(

                ["echo", "ok"],

                cwd=Path(tmp),

                runs=2,

                warmup=0,

                executable=str(fake),

                env=os.environ.copy(),

                runner=runner,

            )

        self.assertEqual(result["command"], "echo ok")

        self.assertEqual(result["median"], 0.003)

    def test_main_missing_hyperfine_prints_clear_message(self) -> None:

        stderr = io.StringIO()

        with contextlib.redirect_stderr(stderr):

            code = crosscheck.main(["--hyperfine", "__oakbench_missing_hyperfine__", "--", "echo", "ok"])

        self.assertEqual(code, 77)

        self.assertIn("hyperfine not found on PATH", stderr.getvalue())

    def test_main_missing_hyperfine_can_emit_json_skip_row(self) -> None:

        stdout = io.StringIO()

        with contextlib.redirect_stdout(stdout):

            code = crosscheck.main(["--jsonl", "--hyperfine", "__oakbench_missing_hyperfine__", "--", "echo", "ok"])

        self.assertEqual(code, 77)

        row = json.loads(stdout.getvalue())

        self.assertEqual(row["returncode"], 77)

        self.assertTrue(row["skipped"])

        self.assertEqual(row["command"], ["echo", "ok"])

if __name__ == "__main__":

    unittest.main()