"""Instrument tests for suites/merge (classification, laws, oracle parsing, vendoring).

Hermetic: no Oak binary and no network. Git-backed tests skip when git is absent.

"""

import hashlib

import json

from pathlib import Path

import shutil

import sys

import tempfile

import unittest

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

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

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

from mergesuite import classify as cl  # noqa: E402

from mergesuite.gitops import (Git, git_conflicts, normalize_git_conflict_type,  # noqa: E402

                               parse_merge_tree_z, prepare_git_home, worktree_manifest)

from mergesuite.oak_adapter import parse_conflict_show, summarize_prediction  # noqa: E402

VENDOR = ROOT / "suites" / "merge" / "vendor" / "gitoxide"

def v(tag):

    return ("file", hashlib.sha256(tag.encode()).hexdigest())

def oak(tree, conflicts=(), clean=None):

    return {"tree": tree, "conflicts": {p: [] for p in conflicts},

            "clean": (not conflicts) if clean is None else clean, "error": None, "error_kind": None}

def gitres(tree, conflicts=()):

    return {"tree": tree, "conflicts": {p: ["content"] for p in conflicts}, "clean": not conflicts}

class ClassifyTests(unittest.TestCase):

    base = {"a": v("a0"), "b": v("b0")}

    ours = {"a": v("a1"), "b": v("b0")}

    theirs = {"a": v("a0"), "b": v("b1")}

    merged = {"a": v("a1"), "b": v("b1")}

    def test_equal(self):

        r = cl.classify(gitres(self.merged), oak(self.merged), self.base, self.ours, self.theirs)

        self.assertEqual(r["class"], "equal-to-git")

    def test_lost_change_is_oak_wrong_even_if_git_agrees(self):

        # Oak drops theirs' change to b.

        r = cl.classify(gitres(self.merged), oak(self.ours), self.base, self.ours, self.theirs)

        self.assertEqual(r["class"], "oak-wrong")

        self.assertIn("lost_change: b", r["reasons"][0])

    def test_lost_deletion(self):

        theirs = {"a": v("a0")}  # theirs deletes b

        r = cl.classify(gitres({"a": v("a1")}), oak({"a": v("a1"), "b": v("b0")}),

                        self.base, self.ours, theirs)

        self.assertEqual(r["class"], "oak-wrong")

    def test_fabricated_content(self):

        r = cl.classify(gitres(self.merged), oak({"a": v("a1"), "b": v("zzz")}),

                        self.base, self.ours, self.theirs)

        self.assertEqual(r["class"], "oak-wrong")

        self.assertIn("fabricated", r["reasons"][0])

    def test_false_conflict_is_differs_but_valid(self):

        r = cl.classify(gitres(self.merged), oak(self.merged, conflicts=["a"]),

                        self.base, self.ours, self.theirs)

        self.assertEqual(r["class"], "differs-but-valid")

        self.assertTrue(any("oak_conflicts_where_git_clean" in x for x in r["reasons"]))

    def test_rename_not_detected_keeps_both_sides(self):

        # ours renames a->c; theirs edits b. git moves; Oak path-level result matches git here,

        # but when git conflicts and Oak keeps everything, it is differs-but-valid.

        base = {"a": v("a0")}

        ours = {"b": v("a0")}

        theirs = {"c": v("a0")}

        r = cl.classify(gitres({"b": v("a0"), "c": v("a0")}, conflicts=["a", "b", "c"]),

                        oak({"b": v("a0"), "c": v("a0")}), base, ours, theirs)

        self.assertEqual(r["class"], "differs-but-valid")

        self.assertTrue(any("oak_clean_where_git_conflicts" in x for x in r["reasons"]))

    def test_expectation_violation_wins(self):

        r = cl.classify(gitres(self.merged), oak(self.merged), self.base, self.ours, self.theirs,

                        expect={"paths": {"a": v("a0")[1]}})

        self.assertEqual(r["class"], "oak-wrong")

        self.assertIn("expectation_violated", r["reasons"][0])

    def test_expect_absent_and_clean(self):

        r = cl.classify(gitres(self.merged), oak(self.merged), self.base, self.ours, self.theirs,

                        expect={"clean": False})

        self.assertEqual(r["class"], "oak-wrong")

        r = cl.classify(gitres(self.merged), oak(self.merged), self.base, self.ours, self.theirs,

                        expect={"paths": {"gone": None}, "clean": True})

        self.assertEqual(r["class"], "equal-to-git")

    def test_unsupported_and_harness_and_oak_error(self):

        self.assertEqual(cl.classify(None, None, {}, {}, {}, unsupported="gitlink")["class"], "oak-unsupported")

        self.assertEqual(cl.classify(None, None, {}, {}, {}, harness_error="x")["class"], "harness-error")

        self.assertEqual(cl.classify(gitres({}), {"error_kind": "harness", "error": "shim"}, {}, {}, {})["class"],

                         "harness-error")

        r = cl.classify(gitres({}), {"error_kind": "oak", "error": "boom", "clean": None}, {}, {}, {})

        self.assertEqual(r["class"], "oak-wrong")

        self.assertEqual(cl.classify(gitres({}), None, {}, {}, {})["class"], "harness-error")

    def test_no_unique_base_leaves_law_unmeasured(self):

        r = cl.classify(gitres(self.merged), oak(self.merged), None, self.ours, self.theirs)

        self.assertEqual(r["class"], "equal-to-git")

        self.assertIsNone(r["evidence"]["law_no_lost_change"])

    def test_text_merge_law(self):

        base = b"1\n2\n3\n4\n5\n6\n"

        o = b"1 ours\n2\n3\n4\n5\n6\n"

        t = b"1\n2\n3\n4\n5\n6 theirs\n"

        good = b"1 ours\n2\n3\n4\n5\n6 theirs\n"

        self.assertTrue(cl.text_preserves_sides(base, o, t, good))

        self.assertFalse(cl.text_preserves_sides(base, o, t, o))

        self.assertFalse(cl.text_preserves_sides(base, o, t, b"<<<<<<< a\n" + good))

        trees = ({"f": v("b")}, {"f": v("o")}, {"f": v("t")})

        texts = {"f": {"base": base, "ours": o, "theirs": t, "merged": good}}

        law = cl.no_lost_change(*trees, {"f": v("m")}, set(), texts)

        self.assertEqual(law["text_merged"], ["f"])

        texts["f"]["merged"] = o

        self.assertEqual(cl.no_lost_change(*trees, {"f": v("m")}, set(), texts)["lost"], ["f"])

    def test_one_side_taken_wholesale_is_lost(self):

        # base exec+empty; ours: mode-only change; theirs: content change. Oak keeping theirs'

        # entry (content AND exec bit) drops ours' mode change.

        base = {"w": ("exec", "empty")}

        ours = {"w": ("file", "empty")}

        theirs = {"w": ("exec", "123")}

        law = cl.no_lost_change(base, ours, theirs, {"w": ("exec", "123")}, set())

        self.assertEqual(law["lost"], ["w"])

        law = cl.no_lost_change(base, ours, theirs, {"w": ("file", "123")}, set(),

                                {"w": {"base": b"", "ours": b"", "theirs": b"1\n2\n3\n", "merged": b"1\n2\n3\n"}})

        self.assertEqual(law["text_merged"], ["w"])

    def test_conflicted_paths_are_exempt_from_law(self):

        law = cl.no_lost_change(self.base, self.ours, self.theirs, {}, {"a", "b"})

        self.assertEqual(law, {"lost": [], "fabricated": [], "text_merged": []})

    def test_symmetry(self):

        f = oak(self.merged, conflicts=["a"])

        r = oak({"a": v("other-side-markers"), "b": v("b1")}, conflicts=["a"])

        self.assertTrue(cl.symmetry(f, r)["holds"])

        self.assertFalse(cl.symmetry(f, oak(self.merged))["holds"])

        self.assertIsNone(cl.symmetry(f, {"clean": None}))

    def test_idempotence(self):

        self.assertIsNone(cl.idempotence_holds({}))

        good = {"idempotence": {"returncode": 0, "head_unchanged": True, "tree_unchanged": True}}

        self.assertTrue(cl.idempotence_holds(good))

        good["idempotence"]["tree_unchanged"] = False

        self.assertFalse(cl.idempotence_holds(good))

    def test_oak_conflict_type(self):

        base = {"a": ("file", "1"), "m": ("file", "1")}

        self.assertEqual(cl.oak_conflict_type("a", base, {"a": ("file", "2")}, {}), "modify/delete")

        self.assertEqual(cl.oak_conflict_type("n", base, {"n": ("file", "2")}, {"n": ("file", "3")}), "add/add")

        self.assertEqual(cl.oak_conflict_type("m", base, {"m": ("exec", "1")}, {"m": ("symlink", "1")}), "mode")

class OracleParsingTests(unittest.TestCase):

    def test_parse_merge_tree_z(self):

        out = (b"tree123\0"

               b"100644 aaa 1\ta\x00100644 bbb 2\ta\x00100644 ccc 3\ta\x00"

               b"\0"

               b"1\0a\0Auto-merging\0Auto-merging a\n\0"

               b"1\0a\0CONFLICT (contents)\0CONFLICT (content): Merge conflict in a\n\0")

        parsed = parse_merge_tree_z(out)

        self.assertEqual(parsed["tree_oid"], "tree123")

        self.assertEqual(parsed["conflict_stages"], {"a": [1, 2, 3]})

        self.assertEqual(git_conflicts(parsed), {"a": ["content"]})

    def test_parse_clean(self):

        parsed = parse_merge_tree_z(b"t\0\0")

        self.assertEqual(parsed["conflict_stages"], {})

        self.assertEqual(parsed["messages"], [])

    def test_type_vocabulary(self):

        self.assertIsNone(normalize_git_conflict_type("Auto-merging"))

        self.assertEqual(normalize_git_conflict_type("CONFLICT (modify/delete)"), "modify/delete")

        self.assertEqual(normalize_git_conflict_type("CONFLICT (rename/delete)"), "rename/delete")

        self.assertEqual(normalize_git_conflict_type("CONFLICT (directory rename split)"), "directory-rename")

    def test_conflict_show_and_prediction_parsing(self):

        doc = {"conflicts": [{"path": "f", "has_conflict_markers": False, "exists": True}]}

        self.assertEqual(parse_conflict_show(doc, {}), {"f": ["no-markers"]})

        self.assertEqual(parse_conflict_show(None, {"conflict_paths": ["x"]}), {"x": []})

        self.assertEqual(summarize_prediction(None, 6), {"available": False, "returncode": 6})

        pred = summarize_prediction({"prediction_available": True, "clean": False,

                                     "conflict_files": [{"path": "b"}, "a"]}, 0)

        self.assertEqual(pred["conflict_files"], ["a", "b"])

@unittest.skipUnless(shutil.which("git"), "git not installed")

class GitBackedTests(unittest.TestCase):

    def setUp(self):

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

        self.home = self.tmp / "home"

        from oakbench.subjects import which_measured_git

        self.git_bin = which_measured_git() or shutil.which("git")

        prepare_git_home(self.home, self.git_bin)

    def tearDown(self):

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

    def test_builder_oracle_and_materialize_roundtrip(self):

        from mergesuite.builder import RepoBuilder, lines

        b = RepoBuilder(self.tmp / "r", self.git_bin, self.home)

        base = b.commit({"f": lines("1", "2", "3"), "x": ("exec", b"#!/bin/sh\n"), "l": ("link", "f")})

        a = b.commit({"f": lines("1 a", "2", "3"), "x": ("exec", b"#!/bin/sh\n"), "l": ("link", "f")}, [base])

        c = b.commit({"f": lines("1", "2", "3 c"), "l": ("link", "f")}, [base], message="unique")

        self.assertEqual(b.merge_bases(a, c), [base])

        merge = b.merge_tree(a, c)

        self.assertTrue(merge["clean"])

        self.assertEqual(sorted(merge["tree"]), ["f", "l"])

        self.assertEqual(merge["tree"]["l"][0], "symlink")

        out = self.tmp / "mat"

        out.mkdir()

        b.materialize(base, out)

        self.assertEqual(worktree_manifest(out), b.tree(base))

        # first parent order is preserved

        m = b.commit({"f": lines("z")}, [a, c])

        self.assertEqual(b.out("rev-parse", m + "^1"), a)

    def test_oracle_reports_conflict_types(self):

        from mergesuite.builder import RepoBuilder, lines

        b = RepoBuilder(self.tmp / "r2", self.git_bin, self.home)

        base = b.commit({"f": lines("1", "2"), "g": lines("g")})

        a = b.commit({"f": lines("1", "A")}, [base])

        c = b.commit({"f": lines("1", "C"), "g": lines("g2")}, [base])

        merge = b.merge_tree(a, c)

        self.assertFalse(merge["clean"])

        self.assertEqual(git_conflicts(merge), {"f": ["content"], "g": ["modify/delete"]})

    def test_sources_build_without_oak(self):

        from mergesuite import sources

        scen = sources.git_t64xx(self.tmp / "t64", self.git_bin, self.home)

        ids = [s["id"] for s in scen]

        self.assertIn("git-t6423-1a", ids)

        self.assertTrue(all(len(s["directions"]) == 2 and s["unsupported"] is None for s in scen))

        native = sources.native_incidents(self.tmp / "nat", self.git_bin, self.home)

        by_id = {s["id"]: s for s in native}

        cc = by_id["incident/criss-cross-tie-break-side-newer"]["directions"][0]

        self.assertEqual(len(cc["merge_bases"]), 2)  # two best common ancestors by construction

        self.assertIsNone(cc["trees"]["base"])

        skew = by_id["incident/clock-skew-merge-base-skewed"]["directions"][0]

        self.assertEqual(len(skew["merge_bases"]), 1)

        gen = sources.generated(self.tmp / "gen", self.git_bin, self.home, 3, 7)

        gen2 = sources.generated(self.tmp / "gen2", self.git_bin, self.home, 3, 7)

        self.assertEqual([s["notes"] for s in gen], [s["notes"] for s in gen2])  # seeded

class VendoringTests(unittest.TestCase):

    def test_vendored_scripts_are_byte_identical_to_pinned_upstream(self):

        meta = json.loads((VENDOR / "UPSTREAM.json").read_text())

        self.assertEqual(meta["license"], "MIT OR Apache-2.0")

        for name, info in meta["files"].items():

            path = VENDOR / name

            self.assertTrue(path.is_file(), name)

            if "sha256" in info:

                self.assertEqual(hashlib.sha256(path.read_bytes()).hexdigest(), info["sha256"], name)

        notice = (VENDOR / "NOTICE").read_text()

        self.assertIn(meta["commit"], notice)

        self.assertIn("Permission is hereby granted", (VENDOR / "LICENSE-MIT").read_text())

        self.assertIn("Apache License", (VENDOR / "LICENSE-APACHE").read_text())

    def test_no_git_test_suite_text_is_vendored(self):

        merge_root = ROOT / "suites" / "merge"

        for path in merge_root.rglob("*"):

            if path.is_file() and path.suffix in (".py", ".sh", ".md", ".json"):

                text = path.read_text(errors="replace")

                self.assertNotIn("test_expect_success", text, path)

                self.assertNotIn(". ./test-lib.sh", text, path)

if __name__ == "__main__":

    unittest.main()