"""Mount-vs-clone lane: variant command shapes, skip honesty, disk fields."""

from __future__ import annotations

import sys

import tempfile

import unittest

from pathlib import Path

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

import mount_vs_clone  # noqa: E402

from oakbench import rows as oakbench_rows  # noqa: E402

METADATA = {"bench_id": "test", "profile": "mount-vs-clone"}

class AcquireCommandsTest(unittest.TestCase):

    def commands(self, variant: str) -> list[list[str]]:

        return mount_vs_clone.acquire_commands(

            variant, "oak", "git", "oak/bench-large-mirror",

            "https://github.com/oakdotspace/bench-large-mirror.git",

            Path("/tmp/dest"), "docs",

        )

    def test_single_command_variants(self) -> None:

        for variant in ("oak_mount", "git_clone_full", "git_clone_shallow", "git_clone_blobless"):

            self.assertEqual(len(self.commands(variant)), 1, variant)

    def test_sparse_task_pays_three_tool_calls(self) -> None:

        commands = self.commands("git_sparse_task")

        self.assertEqual(len(commands), 3)

        self.assertIn("--no-checkout", commands[0])

        self.assertIn("sparse-checkout", commands[1])

    def test_blobless_checkout_still_full_tree(self) -> None:

        # Documented gotcha: --filter=blob:none without --no-checkout hydrates

        # the full working tree; only git_sparse_task adds --no-checkout.

        (command,) = self.commands("git_clone_blobless")

        self.assertIn("--filter=blob:none", command)

        self.assertNotIn("--no-checkout", command)

    def test_unknown_variant_rejected(self) -> None:

        with self.assertRaises(SystemExit):

            self.commands("git_lfs")

class SkipRowTest(unittest.TestCase):

    def test_skip_row_satisfies_mount_lane_contract(self) -> None:

        row = mount_vs_clone.skip_row(METADATA, "oak_mount", "oak", "acquire_cold", 0, "set OAK_BENCH_MIRROR_REPO")

        self.assertEqual(oakbench_rows.validate_rows([row], "mount"), [])

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

        self.assertTrue(row["skipped"])

class FailureExitTest(unittest.TestCase):

    def test_real_failures_are_nonzero_but_skips_are_not(self) -> None:

        skip = mount_vs_clone.skip_row(

            METADATA, "oak_mount", "oak", "acquire_cold", 0, "set OAK_BENCH_MIRROR_REPO"

        )

        self.assertFalse(mount_vs_clone.rows_contain_failures([skip]))

        failed = {

            **mount_vs_clone.base_row(

                METADATA, "git_clone_full", "git", "acquire_cold", "acquire.first_read", 0

            ),

            "elapsed_ms": 1.0,

            "returncode": 1,

        }

        self.assertTrue(mount_vs_clone.rows_contain_failures([skip, failed]))

class DiskRowFieldsTest(unittest.TestCase):

    def test_git_dest_splits_store_and_worktree(self) -> None:

        with tempfile.TemporaryDirectory() as tmp:

            dest = Path(tmp)

            (dest / ".git").mkdir()

            (dest / ".git" / "pack").write_bytes(b"x" * 4096)

            (dest / "README.md").write_bytes(b"y" * 1024)

            fields = mount_vs_clone.disk_row_fields(dest, "git_clone_full")

        self.assertIsNotNone(fields["vcs_store_allocated_bytes"])

        self.assertGreaterEqual(fields["worktree_allocated_bytes"], 0)

    def test_oak_dest_reports_unmeasured_store_as_null(self) -> None:

        with tempfile.TemporaryDirectory() as tmp:

            dest = Path(tmp)

            (dest / "README.md").write_bytes(b"y" * 1024)

            fields = mount_vs_clone.disk_row_fields(dest, "oak_mount")

        # Null means unmeasured (ADR-0002): oak's chunk store is not under

        # dest/.git and must never be reported as zero bytes.

        self.assertIsNone(fields["vcs_store_allocated_bytes"])

        self.assertIsNone(fields["oak_global_cache_bytes"])

        self.assertEqual(

            fields["oak_global_cache_state"],

            mount_vs_clone.OAK_CACHE_STATE_UNCHECKED,

        )

    def test_oak_acquire_rows_record_os_purge_and_unchecked_global_cache_state(self) -> None:

        self.assertEqual(

            mount_vs_clone.cache_state_fields(

                "oak_mount",

                {"attempted": True, "ok": True, "method": "darwin_purge", "error": None},

            ),

            {

                "requested_cache_state": "cold",

                "cache_state": "unknown",

                "cache_state_reason": f"fs_caches_purged: darwin_purge; {mount_vs_clone.OAK_CACHE_STATE_UNCHECKED}",

                "oak_global_cache_state": mount_vs_clone.OAK_CACHE_STATE_UNCHECKED,

            },

        )

        self.assertEqual(

            mount_vs_clone.cache_state_fields(

                "git_clone_full",

                {"attempted": True, "ok": True, "method": "darwin_purge", "error": None},

            ),

            {

                "requested_cache_state": "cold",

                "cache_state": "cold",

                "cache_state_reason": "fs_caches_purged: darwin_purge",

            },

        )

class ScopedTaskFilesTest(unittest.TestCase):

    def test_deterministic_sorted_and_limited(self) -> None:

        with tempfile.TemporaryDirectory() as tmp:

            dest = Path(tmp)

            (dest / "docs" / "b").mkdir(parents=True)

            (dest / "docs" / "a").mkdir(parents=True)

            (dest / "docs" / "b" / "two.md").write_text("2")

            (dest / "docs" / "a" / "one.md").write_text("1")

            (dest / "docs" / "a" / "three.md").write_text("3")

            files = mount_vs_clone.scoped_task_files(dest, "docs", 2)

        self.assertEqual(files, ["docs/a/one.md", "docs/a/three.md"])

    def test_missing_prefix_returns_empty(self) -> None:

        with tempfile.TemporaryDirectory() as tmp:

            self.assertEqual(mount_vs_clone.scoped_task_files(Path(tmp), "docs", 5), [])

class ManifestContentVerificationTest(unittest.TestCase):

    def test_manifest_hash_verifies_file_bytes(self) -> None:

        with tempfile.TemporaryDirectory() as tmp:

            dest = Path(tmp)

            (dest / "README.md").write_bytes(b"expected bytes\n")

            digest = mount_vs_clone.hashlib.sha256(b"expected bytes\n").hexdigest()

            manifest = mount_vs_clone.parse_manifest(f"{digest}  README.md\n")

            fields = mount_vs_clone.content_verification_fields(dest, ["README.md"], manifest)

        self.assertTrue(fields["content_verified"])

        self.assertEqual(fields["content_check_status"], "passed")

        self.assertEqual(fields["content_verified_files"], 1)

    def test_manifest_mismatch_marks_row_failed(self) -> None:

        with tempfile.TemporaryDirectory() as tmp:

            dest = Path(tmp)

            (dest / "README.md").write_bytes(b"actual bytes\n")

            manifest = mount_vs_clone.parse_manifest(f"{'0' * 64}  README.md\n")

            row = {

                **mount_vs_clone.base_row(METADATA, "oak_mount", "oak", "acquire_cold", "acquire.first_read", 0),

                "elapsed_ms": 1.0,

                "returncode": 0,

            }

            mount_vs_clone.apply_content_verification(

                row,

                mount_vs_clone.content_verification_fields(dest, ["README.md"], manifest),

            )

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

        self.assertFalse(row["content_verified"])

        self.assertEqual(row["content_check_status"], "failed")

    def test_scoped_read_requires_every_file_in_manifest(self) -> None:

        with tempfile.TemporaryDirectory() as tmp:

            dest = Path(tmp)

            (dest / "docs").mkdir()

            (dest / "docs" / "one.md").write_text("one")

            manifest = mount_vs_clone.parse_manifest(

                f"{mount_vs_clone.hashlib.sha256(b'one').hexdigest()}  docs/one.md\n"

            )

            fields = mount_vs_clone.content_verification_fields(

                dest,

                ["docs/one.md", "docs/two.md"],

                manifest,

            )

        self.assertFalse(fields["content_verified"])

        self.assertEqual(fields["content_check_status"], "missing_manifest_entries")

        self.assertEqual(fields["content_missing_manifest_entries"], ["docs/two.md"])

if __name__ == "__main__":

    unittest.main()