from __future__ import annotations

import contextlib

import io

import json

import sys

import tempfile

import unittest

from pathlib import Path

from unittest.mock import patch

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

import benchmark_stats

from oakbench.stats import (

    benjamini_hochberg,

    bootstrap_ci,

    named_statistic,

    percentile_nearest,

    ratio_ci,

    required_n_for_relative_delta,

)

class StatsTest(unittest.TestCase):

    def test_percentile_nearest(self) -> None:

        self.assertEqual(percentile_nearest([1, 2, 3, 4], 50), 2)

        self.assertEqual(percentile_nearest([1, 2, 3, 4], 95), 4)

        self.assertIsNone(percentile_nearest([], 50))

    def test_bootstrap_ci_singleton(self) -> None:

        self.assertEqual(bootstrap_ci([7.0]), (7.0, 7.0))

    def test_zero_percentile_is_observed_zero_not_nan(self) -> None:

        self.assertEqual(named_statistic("p90")([0.0, 0.0, 0.0]), 0.0)

        self.assertEqual(bootstrap_ci([0.0] * 10, statistic="p90", samples=20), (0.0, 0.0))

    def test_ratio_ci_orders_bounds(self) -> None:

        low, high = ratio_ci([1, 2, 3], [2, 4, 6], samples=100, seed=1)

        self.assertLessEqual(low, high)

        self.assertGreater(low, 0)

    def test_bh_fdr(self) -> None:

        self.assertEqual(benjamini_hochberg([0.001, 0.02, 0.2], alpha=0.05), [True, True, False])

    def test_required_n_scales_with_square_of_noise_ratio(self) -> None:

        self.assertEqual(required_n_for_relative_delta(10, 5, 4), 16)

        self.assertEqual(required_n_for_relative_delta(3, 5, 4), 4)

        self.assertIsNone(required_n_for_relative_delta(3, 0, 4))

class BenchmarkStatsCliTest(unittest.TestCase):

    def test_null_returncode_row_is_excluded_not_a_crash(self) -> None:

        rows = [

            {"subject": "git", "scenario": "tiny", "operation": "status.clean", "returncode": 0, "elapsed_ms": 10.0},

            {"subject": "git", "scenario": "tiny", "operation": "status.clean", "returncode": 0, "elapsed_ms": 12.0},

            # Emitters may record returncode: null (unmeasured); it must be

            # treated as a failure and excluded, never raise TypeError.

            {"subject": "git", "scenario": "tiny", "operation": "status.clean", "returncode": None, "elapsed_ms": 999.0},

        ]

        with tempfile.TemporaryDirectory() as tmp:

            path = Path(tmp) / "rows.jsonl"

            path.write_text("\n".join(json.dumps(row) for row in rows) + "\n")

            stdout = io.StringIO()

            argv = ["benchmark_stats.py", str(path), "--bootstrap-samples", "10"]

            with patch.object(sys, "argv", argv):

                with contextlib.redirect_stdout(stdout):

                    code = benchmark_stats.main()

        self.assertEqual(code, 0)

        output = stdout.getvalue()

        self.assertIn("| `git` | `tiny/status.clean` | 2 |", output)

        self.assertNotIn("999", output)

if __name__ == "__main__":

    unittest.main()