from __future__ import annotations

import contextlib

import io

import json

from pathlib import Path

import sys

import tempfile

import unittest

from unittest.mock import patch

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

import benchmark_stats

from oakbench.baseline_book import BaselineCell, Target

from oakbench.populations import population_conflicts

from oakbench.scorecard import evaluate_targets

def row(**extra):

    return dict(subject="oak_local", lane="core", profile="smoke", scenario="tiny",

                operation="status.clean", returncode=0, elapsed_ms=1.0, **extra)

class PopulationReportingTest(unittest.TestCase):

    def test_incompatible_identity_is_rejected_by_cli_and_scorecard(self):

        variants = [

            ({"runner_class": "arm"}, {"runner_class": "x86"}, "runner_class"),

            ({"benchmark_track": "core-equivalent"}, {"benchmark_track": "agent-default"}, "benchmark_track"),

            ({"cache_state": "cold"}, {"cache_state": "warm"}, "cache_state"),

            ({"load_tier": "none"}, {"load_tier": "cpu50"}, "load_tier"),

            ({"fixture_version": 1}, {"fixture_version": 2}, "fixture_version"),

            ({"fixture": {"fixture_version": 1}}, {"fixture": {"fixture_version": 2}}, "fixture.fixture_version"),

            ({"scenario_version": 1}, {"scenario_version": 2}, "scenario_version"),

            ({"oracle_version": 1}, {"oracle_version": 2}, "oracle_version"),

            ({"remote_server": "a"}, {"remote_server": "b"}, "remote_server"),

            ({"netshape_profile": "lan-1ms"}, {"netshape_profile": "wan-100ms"}, "netshape_profile"),

            ({"env_isolation_version": 1}, {"env_isolation_version": 2}, "env_isolation_version"),

            ({"calibration_version": "a"}, {"calibration_version": "b"}, "calibration_version"),

            ({"remote_transport": "network"}, {"remote_transport": "local_file"}, "remote_transport"),

            ({"agent": {"instruction_level": "zero-shot"}}, {"agent": {"instruction_level": "full-docs"}}, "agent.instruction_level"),

            ({"agent": {"model": "a"}}, {"agent": {"model": "b"}}, "agent.model"),

            ({"runner_id": "known"}, {}, "runner_id"),

            ({"subject_details": {"oak_local": {"binary_sha256": "a"}}},

             {"subject_details": {"oak_local": {"binary_sha256": "b"}}}, "subject_details.binary_sha256"),

        ]

        for left, right, field in variants:

            with self.subTest(field=field):

                rows = [row(**left), row(**right)]

                with tempfile.TemporaryDirectory() as tmp:

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

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

                    output = io.StringIO()

                    with patch.object(sys, "argv", ["benchmark_stats.py", str(path)]), contextlib.redirect_stdout(output):

                        self.assertEqual(benchmark_stats.main(), 1)

                    self.assertIn(field, output.getvalue())

                    self.assertNotIn("median CI", output.getvalue())

                target = Target("t", "core", "smoke", "tiny", "status.clean", "oak_local", "git",

                                "elapsed_ms", "median", "ratio_at_most", .8, {})

                baseline = BaselineCell("core", "smoke", "tiny", "status.clean", "git", "elapsed_ms", "median", 10)

                result = evaluate_targets(rows, [target], {baseline.key: baseline})[0]

                self.assertEqual(result["verdict"], "INVALID")

                self.assertIn(field, " ".join(result["messages"]))

    def test_legacy_rows_and_repetitions_do_not_invent_identity(self):

        self.assertEqual(population_conflicts([row(run=1), row(run=2)]), [])

        self.assertEqual(population_conflicts([row(runner_id="same", run=1), row(runner_id="same", run=2)]), [])

    def test_subject_metadata_for_other_subjects_does_not_change_identity(self):

        left = row(subject_details={"oak_local": {"binary_sha256": "same"}, "git": {"version": "a"}})

        right = row(subject_details={"oak_local": {"binary_sha256": "same"}, "git": {"version": "b"}})

        self.assertEqual(population_conflicts([left, right]), [])

if __name__ == "__main__":

    unittest.main()