"""Positive CLI checks and fault-injected negative oracle controls."""

import os

from pathlib import Path

import shutil

import subprocess

import sys

import tempfile

import unittest

from unittest.mock import patch

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

from oakbench.conformance import (Repository, SCENARIOS, assert_state,

                                 run_scenario, tree_manifest)

class ManifestTests(unittest.TestCase):

    def test_exact_oracle_rejects_each_loss_class(self):

        with tempfile.TemporaryDirectory() as tmp:

            root = Path(tmp)

            target = root / "payload"

            target.write_bytes(b"sentinel\x00\xff")

            expected = tree_manifest(root)

            target.write_bytes(b"sentinel\x00\xfe")

            with self.assertRaises(AssertionError):

                assert_state(expected, tree_manifest(root))

            target.write_bytes(b"sentinel\x00\xff")

            target.rename(root / "renamed")

            with self.assertRaises(AssertionError):

                assert_state(expected, tree_manifest(root))

            (root / "renamed").rename(target)

            (root / "extra").write_bytes(b"")

            with self.assertRaises(AssertionError):

                assert_state(expected, tree_manifest(root))

            (root / "extra").unlink()

            if os.name == "posix":

                target.chmod(0o755)

                with self.assertRaises(AssertionError):

                    assert_state(expected, tree_manifest(root))

    @unittest.skipUnless(os.name == "posix", "POSIX symlinks required")

    def test_symlink_target_type_and_no_traversal(self):

        with tempfile.TemporaryDirectory() as tmp:

            root = Path(tmp)

            (root / "link").symlink_to("missing")

            expected = tree_manifest(root)

            (root / "link").unlink()

            (root / "link").symlink_to("different")

            with self.assertRaises(AssertionError):

                assert_state(expected, tree_manifest(root))

            (root / "link").unlink()

            (root / "link").write_text("missing")

            with self.assertRaises(AssertionError):

                assert_state(expected, tree_manifest(root))

            (root / "cycle").symlink_to(".")

            self.assertEqual(tree_manifest(root)["cycle"], {"kind": "symlink", "target": "."})

    def test_missing_binary_is_explicit_unmeasured_skip(self):

        with tempfile.TemporaryDirectory() as tmp:

            row = run_scenario(Path(tmp), "oak", "/nonexistent/conformance-oak", SCENARIOS[0])

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

            self.assertIsNone(row["integrity_ok"])

            self.assertIsNone(row["wall_ms"])

            self.assertTrue(row["skip_reason"])

@unittest.skipUnless(shutil.which("git"), "Git binary required")

class RealGitControls(unittest.TestCase):

    @unittest.skipUnless(os.name == "posix", "POSIX symlinks required")

    def test_relative_binary_resolved_before_fixture_cwd_change(self):

        with tempfile.TemporaryDirectory() as tmp:

            root = Path(tmp)

            (root / "git-subject").symlink_to(shutil.which("git"))

            relative_binary = os.path.relpath(root / "git-subject")

            row = run_scenario(root / "work", "git", relative_binary, "byte_roundtrip_v1")

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

            self.assertTrue(Path(row["binary"]).is_absolute())

    def test_five_positive_scenarios(self):

        with tempfile.TemporaryDirectory() as tmp:

            for scenario in SCENARIOS:

                with self.subTest(scenario=scenario):

                    row = run_scenario(Path(tmp), "git", "git", scenario)

                    if scenario == "mode_symlink_roundtrip_v1" and row["returncode"] == 77:

                        self.assertTrue(row["skip_reason"])

                    else:

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

                        self.assertTrue(row["integrity_ok"])

    def test_noop_restore_cannot_pass(self):

        with tempfile.TemporaryDirectory() as tmp, patch.object(Repository, "restore"):

            row = run_scenario(Path(tmp), "git", "git", "byte_roundtrip_v1")

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

            self.assertFalse(row["integrity_ok"])

    def test_restore_cannot_erase_unrelated_work(self):

        real_restore = Repository.restore

        def lossy_restore(repo, paths, invalid_source=False):

            result = real_restore(repo, paths, invalid_source)

            (repo.root / "untracked.txt").unlink()

            return result

        with tempfile.TemporaryDirectory() as tmp, patch.object(Repository, "restore", lossy_restore):

            row = run_scenario(Path(tmp), "git", "git", "scoped_restore_preservation_v1")

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

            self.assertIn("untracked.txt", row["failure"])

    def test_expected_failure_cannot_hide_partial_write_or_success(self):

        def partial_failure(repo, paths, invalid_source=False):

            (repo.root / "other.txt").write_bytes(b"corrupted")

            return subprocess.CompletedProcess([], 1)

        for implementation in (partial_failure,

                               lambda *a, **kw: subprocess.CompletedProcess([], 0),

                               lambda *a, **kw: subprocess.CompletedProcess([], -9)):

            with self.subTest(implementation=implementation):

                with tempfile.TemporaryDirectory() as tmp, patch.object(Repository, "restore", implementation):

                    row = run_scenario(Path(tmp), "git", "git", "failed_restore_preservation_v1")

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

                    self.assertFalse(row["integrity_ok"])

    def test_expected_failure_cannot_move_head_without_changing_tree(self):

        def move_head(repo, paths, invalid_source=False):

            repo.run("commit", "--allow-empty", "-m", "unexpected state mutation")

            return subprocess.CompletedProcess([], 1)

        with tempfile.TemporaryDirectory() as tmp, patch.object(Repository, "restore", move_head):

            row = run_scenario(Path(tmp), "git", "git", "failed_restore_preservation_v1")

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

            self.assertIn("head", row["failure"])

if __name__ == "__main__":

    unittest.main()