"""Subject-kind plugin layer: schema, capability gaps, and the parity proof.

The load-bearing assertion is parity_report == [] for git and oak: the

plugin JSONs are a parallel read of config/command_semantics.json, and an

empty report proves the extraction is measurement-identical, so existing

lanes' behavior cannot have changed.

"""

from __future__ import annotations

import sys

import unittest

from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]

sys.path.insert(0, str(ROOT / "scripts"))

from oakbench.subject_kinds import (

    SCHEMA_VERSION,

    available_kinds,

    command_for,

    load_subject_kind,

    parity_report,

)

class ParityProofTest(unittest.TestCase):

    """The row_parity proof for the config layer (empty = identical)."""

    def test_git_plugin_is_measurement_identical_to_command_semantics(self) -> None:

        self.assertEqual(parity_report("git", ROOT / "config" / "command_semantics.json"), [])

    def test_oak_plugin_is_measurement_identical_to_command_semantics(self) -> None:

        self.assertEqual(parity_report("oak", ROOT / "config" / "command_semantics.json"), [])

    def test_jj_is_honestly_absent_from_command_semantics(self) -> None:

        report = parity_report("jj", ROOT / "config" / "command_semantics.json")

        self.assertEqual(len(report), 1)

        self.assertIn("kind_not_in_command_semantics:jj", report[0])

class SchemaTest(unittest.TestCase):

    def test_all_shipped_plugins_load_and_validate(self) -> None:

        kinds = available_kinds()

        self.assertEqual(kinds, ["git", "jj", "oak"])

        for kind in kinds:

            plugin = load_subject_kind(kind)

            self.assertEqual(plugin.kind, kind)

            self.assertEqual(plugin.schema_version, SCHEMA_VERSION)

            self.assertIsInstance(plugin.workspace_model, str)

            self.assertIn("stage_required", plugin.snapshot_call_semantics)

            self.assertIn("calls_per_snapshot", plugin.snapshot_call_semantics)

    def test_workspace_models_match_declarations(self) -> None:

        self.assertEqual(load_subject_kind("git").workspace_model, "working_copy")

        self.assertEqual(load_subject_kind("oak").workspace_model, "virtual_branch")

        self.assertEqual(load_subject_kind("jj").workspace_model, "working_copy_autosnapshot")

    def test_remote_env_vars_match_harness(self) -> None:

        self.assertEqual(load_subject_kind("git").remote_env_var, "GIT_BENCH_REMOTE")

        self.assertEqual(load_subject_kind("oak").remote_env_var, "OAK_BENCH_REMOTE")

        self.assertIsNone(load_subject_kind("jj").remote_env_var)

class CapabilityGapTest(unittest.TestCase):

    def test_jj_status_has_argv(self) -> None:

        self.assertEqual(command_for("jj", "status"), ["st"])

    def test_jj_absent_operation_is_capability_gap(self) -> None:

        self.assertIsNone(command_for("jj", "rebase.interactive"))

    def test_jj_explicit_null_is_capability_gap(self) -> None:

        plugin = load_subject_kind("jj")

        self.assertIsNone(plugin.command_for("stage"))

        self.assertIsNone(plugin.command_for("branch_create"))

        self.assertEqual(plugin.skip_reason("stage"), "capability_gap:jj:stage")

    def test_track_selection(self) -> None:

        self.assertEqual(command_for("git", "status", track="core-equivalent"), ["status", "--porcelain=v1"])

        self.assertIsNone(command_for("jj", "status", track="core-equivalent"))

    def test_oak_stage_gap_matches_command_semantics(self) -> None:

        self.assertIsNone(command_for("oak", "stage"))

class UnknownKindTest(unittest.TestCase):

    def test_unknown_kind_raises_clear_error(self) -> None:

        with self.assertRaises(ValueError) as ctx:

            load_subject_kind("sapling")

        message = str(ctx.exception)

        self.assertIn("sapling", message)

        self.assertIn("available", message)

        self.assertIn("git", message)

if __name__ == "__main__":

    unittest.main()