"""Tests for the VCS PATH shim instrument.

The shim must be behavior-transparent (same stdout, same exit code as the

real binary) while producing sidecar rows directly consumable by

oakbench.thrash. Tests run the real git binary and skip when absent.

"""

from __future__ import annotations

import json

import os

import shutil

import subprocess

import sys

import tempfile

import unittest

from pathlib import Path

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

from oakbench.thrash import agent_blocked_on_vcs_ms

from oakbench.vcs_shim import create_shim_dir, measure_shim_overhead, read_sidecar_rows

GIT = shutil.which("git")

def shim_env(shim_dir: Path) -> dict[str, str]:

    env = dict(os.environ)

    env["PATH"] = str(shim_dir) + os.pathsep + env.get("PATH", "")

    return env

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

class VcsShimTest(unittest.TestCase):

    def setUp(self) -> None:

        self.tmp = Path(tempfile.mkdtemp(prefix="vcs-shim-test-"))

        self.addCleanup(shutil.rmtree, self.tmp, True)

        self.sidecar = self.tmp / "sidecar.jsonl"

        self.shim_dir = create_shim_dir(

            self.tmp / "shim", real_binaries={"git": GIT}, sidecar_path=self.sidecar

        )

    def run_shimmed(self, *args: str, cwd: Path | None = None) -> subprocess.CompletedProcess[str]:

        return subprocess.run(

            ["git", *args],

            env=shim_env(self.shim_dir),

            cwd=cwd or self.tmp,

            text=True,

            capture_output=True,

            check=False,

        )

    def test_only_listed_binaries_get_wrappers(self) -> None:

        self.assertTrue((self.shim_dir / "git").exists())

        self.assertFalse((self.shim_dir / "oak").exists())

    def test_wrapper_uses_full_buffer_write_loop(self) -> None:

        script = (self.shim_dir / "git").read_text()

        self.assertIn("def write_all", script)

        self.assertIn("while written_total < len(data)", script)

        self.assertIn("write_all(fd, data)", script)

    def test_shim_is_transparent_and_records_one_row(self) -> None:

        direct = subprocess.run([GIT, "--version"], text=True, capture_output=True, check=False)

        shimmed = self.run_shimmed("--version")

        self.assertEqual(shimmed.returncode, 0)

        self.assertEqual(shimmed.stdout, direct.stdout)

        rows = read_sidecar_rows(self.sidecar)

        self.assertEqual(len(rows), 1)

        row = rows[0]

        for key in ("command", "argv", "start_ms", "end_ms", "elapsed_ms", "returncode", "shim"):

            self.assertIn(key, row)

        self.assertEqual(row["command"], "git --version")

        self.assertTrue(row["command"].startswith("git --version"))

        self.assertEqual(row["argv"], ["--version"])

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

        self.assertIs(row["shim"], True)

        self.assertGreater(row["elapsed_ms"], 0)

        self.assertGreaterEqual(row["end_ms"], row["start_ms"])

        self.assertAlmostEqual(row["elapsed_ms"], row["end_ms"] - row["start_ms"], places=3)

    def test_concurrent_shim_calls_produce_two_valid_json_lines(self) -> None:

        env = shim_env(self.shim_dir)

        procs = [

            subprocess.Popen(

                ["git", "--version"],

                env=env,

                cwd=self.tmp,

                stdout=subprocess.DEVNULL,

                stderr=subprocess.DEVNULL,

            )

            for _ in range(2)

        ]

        for proc in procs:

            self.assertEqual(proc.wait(timeout=30), 0)

        lines = [line for line in self.sidecar.read_text().splitlines() if line.strip()]

        self.assertEqual(len(lines), 2)

        for line in lines:

            row = json.loads(line)  # raises on interleaved/corrupt lines

            self.assertEqual(row["command"], "git --version")

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

    def test_measure_shim_overhead_is_non_negative_float(self) -> None:

        overhead = measure_shim_overhead(self.shim_dir, self.sidecar, GIT, n=3)

        self.assertIsInstance(overhead, float)

        self.assertGreaterEqual(overhead, 0.0)

    def test_nonzero_exit_passthrough(self) -> None:

        direct = subprocess.run(

            [GIT, "definitely-not-a-command"],

            cwd=self.tmp,

            text=True,

            capture_output=True,

            check=False,

        )

        self.assertNotEqual(direct.returncode, 0)

        shimmed = self.run_shimmed("definitely-not-a-command")

        self.assertEqual(shimmed.returncode, direct.returncode)

        rows = read_sidecar_rows(self.sidecar)

        self.assertEqual(rows[-1]["returncode"], direct.returncode)

    def test_sidecar_rows_feed_thrash_metrics(self) -> None:

        repo = self.tmp / "repo"

        repo.mkdir()

        init = self.run_shimmed("init", cwd=repo)

        self.assertEqual(init.returncode, 0)

        status = self.run_shimmed("status", cwd=repo)

        self.assertEqual(status.returncode, 0)

        rows = read_sidecar_rows(self.sidecar)

        self.assertGreaterEqual(len(rows), 2)

        blocked = agent_blocked_on_vcs_ms(rows)

        self.assertIsInstance(blocked, float)

        self.assertGreater(blocked, 0.0)

if __name__ == "__main__":

    unittest.main()