"""Fast end-to-end checks for the core, contention, and mock-agent lanes.

Together with test_integration_workflow.py, every lane has a tiny-scale wire

test from fixture to contract-valid rows, so agents can refactor any harness

and know within seconds whether the lane still measures.

"""

from __future__ import annotations

import sys

from pathlib import Path

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

import shutil

import tempfile

import unittest

import hashlib

import re

import agent_workflow

import bench

import parallel_contention

import workflow_ab

from agent_metrics_schema import validate_row

from oakbench.rows import validate_rows

from oakbench.runner import runner_fields

from oakbench.subjects import subject_details

from oakbench.subjects import Subject

GIT = shutil.which("git")

SHA256_RE = re.compile(r"^[0-9a-f]{64}$")

def git_subject() -> Subject:

    return Subject(name="git", kind="git", label="Git", bin=Path(GIT))

@unittest.skipIf(GIT is None, "git not installed")

class CoreLaneIntegrationTest(unittest.TestCase):

    def setUp(self) -> None:

        self.tmp = Path(tempfile.mkdtemp(prefix="oakbench-core-test-"))

    def tearDown(self) -> None:

        shutil.rmtree(self.tmp, ignore_errors=True)

    def test_micro_scenario_end_to_end(self) -> None:

        scenario = bench.Scenario("tiny_text", 8, 256, 2, False, 1)

        fixture = bench.ensure_fixture(self.tmp, scenario)

        metadata = {

            "bench_id": "test",

            "profile": "micro",

            "benchmark_track": "agent-default",

            "command_semantics_version": bench.COMMAND_SEMANTICS_VERSION,

            "timestamp_utc": "test",

            "subject_details": subject_details([git_subject()]),

            **runner_fields(

                {

                    "system": "Linux",

                    "release": "6.8",

                    "machine": "x86_64",

                    "processor": "x86_64",

                    "cpu_model": "Test CPU",

                    "cpu_count_logical": 8,

                    "filesystem_type": "ext4",

                },

                {"classes": [{"id": "unknown", "default": True}]},

            ),

        }

        rows = bench.run_subject_scenario(

            git_subject(),

            scenario,

            fixture,

            run_index=0,

            run_root=self.tmp / "runs",

            metadata=metadata,

            skip_diff=False,

            admitted_output_chars=20_000,

            track="agent-default",

        )

        self.assertEqual(validate_rows(rows, "core"), [])

        self.assertTrue(rows)

        for row in rows:

            self.assertIsInstance(row.get("runner_id"), str)

            self.assertIsInstance(row.get("runner_class"), str)

            self.assertIsInstance(row.get("runner_profile"), dict)

            self.assertIn("binary_sha256", row)

            digest = row.get("binary_sha256")

            self.assertTrue(digest is None or SHA256_RE.fullmatch(digest), digest)

        operations = [row["operation"] for row in rows]

        for expected in (

            "proc.spawn",

            "repo.init",

            "snapshot.initial.add",

            "snapshot.initial.commit",

            "snapshot.initial",

            "status.clean",

            "status.dirty",

            "status.dirty.determinism",

            "diff.dirty",

            "diff.dirty.determinism",

            "snapshot.dirty",

            "branch.create",

            "task.snapshot",

        ):

            self.assertIn(expected, operations)

        failures = [row for row in rows if row["returncode"] != 0]

        self.assertEqual(failures, [])

        probe = next(row for row in rows if row["operation"] == "status.dirty.determinism")

        self.assertIn("output_stable", probe)

        self.assertIn("ansi_escape_count_non_tty", probe)

    def test_subject_provenance_uses_subject_specific_binary_hashes(self) -> None:

        git_bin = self.tmp / "fake-git"

        oak_bin = self.tmp / "fake-oak"

        git_bin.write_bytes(b"git-binary")

        oak_bin.write_bytes(b"oak-binary")

        git_subject = Subject(name="git", kind="git", label="Git", bin=git_bin)

        oak_subject = Subject(name="oak_local", kind="oak", label="Oak", bin=oak_bin)

        metadata = {"subject_details": subject_details([git_subject, oak_subject])}

        git_hash = bench.subject_provenance(git_subject, metadata)["binary_sha256"]

        oak_hash = bench.subject_provenance(oak_subject, metadata)["binary_sha256"]

        self.assertEqual(git_hash, hashlib.sha256(b"git-binary").hexdigest())

        self.assertEqual(oak_hash, hashlib.sha256(b"oak-binary").hexdigest())

        self.assertNotEqual(git_hash, oak_hash)

@unittest.skipIf(GIT is None, "git not installed")

class ContentionLaneIntegrationTest(unittest.TestCase):

    def setUp(self) -> None:

        self.tmp = Path(tempfile.mkdtemp(prefix="oakbench-contention-test-"))

    def tearDown(self) -> None:

        shutil.rmtree(self.tmp, ignore_errors=True)

    def test_shared_checkout_two_workers(self) -> None:

        fixture = self.tmp / "fixture"

        parallel_contention.make_fixture(fixture)

        metadata = {"bench_id": "test", "profile": "parallel-contention", "timestamp_utc": "test"}

        rows = parallel_contention.run_shared_checkout(

            git_subject(),

            fixture,

            workers=2,

            commits=1,

            run_root=self.tmp / "runs",

            run_index=0,

            metadata=metadata,

        )

        self.assertEqual(validate_rows(rows, "contention"), [])

        total = next(row for row in rows if row["operation"] == "parallel.total")

        metrics = total["parallel_metrics"]

        self.assertEqual(metrics["tasks_total"], 2)

        self.assertEqual(metrics["tasks_completed"], 2)

        self.assertEqual(metrics["lost_updates_detected"], 0)

        self.assertTrue(metrics["integrity_check_passed"])

        self.assertIsNotNone(metrics["commit_throughput_per_s"])

@unittest.skipIf(GIT is None, "git not installed")

class MockAgentLaneIntegrationTest(unittest.TestCase):

    def setUp(self) -> None:

        self.tmp = Path(tempfile.mkdtemp(prefix="oakbench-agent-test-"))

    def tearDown(self) -> None:

        shutil.rmtree(self.tmp, ignore_errors=True)

    def test_mock_bugfix_end_to_end(self) -> None:

        agent = agent_workflow.AgentConfig(

            name="mock",

            adapter="deterministic_mock",

            provider="local",

            bin=None,

            model=None,

            version="test",

        )

        workflow = workflow_ab.WORKFLOWS["bugfix_test_loop"]

        fixture = workflow_ab.prepare_fixture(self.tmp, workflow)

        row = agent_workflow.run_one(

            agent=agent,

            subject=git_subject(),

            workflow=workflow,

            fixture=fixture,

            run_index=0,

            run_root=self.tmp / "runs",

            artifacts_root=self.tmp / "artifacts",

            timeout_seconds=300.0,

            track="agent-default",

            agent_environment="minimal",

            instruction_level="full-docs",

            bench_id="test",

            timestamp_utc="2026-06-10T00:00:00Z",

            source={"oak_hash": None, "oak_status": None},

            host_meta={"host": "test", "platform": "test", "machine": "test"},

        )

        self.assertEqual(validate_row(row), [])

        self.assertTrue(row["success"], row.get("failure_reason"))

        # Null-honesty: the mock adapter exposes no stream, so turn metrics

        # must be unmeasured, never zero (ADR-0002).

        self.assertEqual(row["turn_metrics"]["turn_source"], "unmeasured")

        self.assertIsNone(row["turn_metrics"]["assistant_turns_total"])

        self.assertIsNone(row["bytes_metrics"]["bytes_hydrated"])

if __name__ == "__main__":

    unittest.main()