"""Outcome classification and merge laws. Pure functions; no I/O.

Classes (every case gets exactly one; nothing passes silently):

- equal-to-git: same clean/conflicted status, same conflicted path set, and

  identical content+mode for every non-conflicted path.

- differs-but-valid: differs from git, but no change from either side is lost

  or fabricated at any non-conflicted path (e.g. Oak conflicts where git's

  rename detection resolved cleanly; git conflicts where Oak's path-level merge

  kept both sides). Reasons say which.

- oak-wrong: a non-conflicted path loses a side's change, carries content no

  input or valid text merge explains, a scenario's stated expectation (e.g.

  "revert stays reverted") is violated, or Oak errors on a valid input.

- oak-unsupported: the input cannot be represented through Oak's public

  surface (gitlinks, multiple git merge bases or unrelated histories for the

  fork+squash construction), decided before Oak runs.

- harness-error: the instrument failed (fixture build, oracle, shim).

"""

from __future__ import annotations

import difflib

from typing import Dict, Iterable, List, Optional, Set, Tuple

CLASSES = ("equal-to-git", "differs-but-valid", "oak-wrong", "oak-unsupported", "harness-error")

MARKERS = (b"<<<<<<< ", b"=======", b">>>>>>> ")

Value = Tuple[str, str]

Tree = Dict[str, Value]

def split_tree(tree: Tree, conflicted: Iterable[str]) -> Tree:

    conflicted = set(conflicted)

    return {p: v for p, v in tree.items() if p not in conflicted}

def oak_conflict_type(path: str, base: Tree, ours: Tree, theirs: Tree) -> str:

    """Oak's per-path conflict kind, derived from the three inputs (Oak merges path-by-path)."""

    b, o, t = base.get(path), ours.get(path), theirs.get(path)

    if o is None or t is None:

        return "modify/delete" if b is not None else "file/directory"

    if b is None:

        return "add/add"

    if o[1] == t[1] and o[0] != t[0]:

        return "mode"

    return "content"

def text_preserves_sides(base: bytes, ours: bytes, theirs: bytes, merged: bytes) -> bool:

    """Heuristic line-level check: every block a side inserted/replaced appears in the merge,

    and the merge carries no conflict markers. Deletions are not checked (lines repeat)."""

    if any(m in merged for m in MARKERS) and not any(m in x for x in (base, ours, theirs) for m in MARKERS):

        return False

    b, m = base.splitlines(), merged.splitlines()

    for side in (ours.splitlines(), theirs.splitlines()):

        for tag, _i1, _i2, j1, j2 in difflib.SequenceMatcher(None, b, side, autojunk=False).get_opcodes():

            if tag in ("insert", "replace") and not _contains(m, side[j1:j2]):

                return False

    return True

def _contains(haystack: List[bytes], needle: List[bytes]) -> bool:

    if not needle:

        return True

    n = len(needle)

    return any(haystack[i:i + n] == needle for i in range(len(haystack) - n + 1))

def _three_way_kind(b: Optional[Value], o: Optional[Value], t: Optional[Value]) -> Optional[str]:

    """Expected entry kind (file/exec/symlink) of a both-sides-changed path, or None when

    the two sides changed the kind incompatibly (a mode conflict)."""

    bk, ok, tk = (b and b[0]), (o and o[0]), (t and t[0])

    if ok == tk:

        return ok

    if ok == bk:

        return tk

    if tk == bk:

        return ok

    return None

def lacks_final_newline(ev: dict) -> bool:

    """True when a non-empty merge input does not end in a newline (the fb-537 trigger)."""

    return any(x and not x.endswith(b"\n") for x in (ev.get("base"), ev.get("ours"), ev.get("theirs")))

def has_new_markers(ev: dict) -> bool:

    inputs = (ev.get("base") or b"", ev.get("ours") or b"", ev.get("theirs") or b"")

    return any(m in ev.get("merged", b"") and not any(m in x for x in inputs) for m in MARKERS)

def no_lost_change(base: Tree, ours: Tree, theirs: Tree, result: Tree, conflicted: Set[str],

                   texts: Optional[Dict[str, dict]] = None) -> Dict[str, List[str]]:

    """Path-level law. Returns {"lost", "mode_lost", "markers", "markers_no_final_newline",

    "markers_symlink", "fabricated",

    "text_merged"}.

    For every non-conflicted path: a change made by exactly one side must be

    present; an identical change on both sides must be present; a divergent

    change on both sides must have been text-merged preserving both sides'

    content AND the 3-way-merged entry kind/mode (checked with

    `texts[path] = {base, ours, theirs, merged}` bytes). Merged bytes carrying

    conflict markers that no input had are reported as `markers`."""

    lost, mode_lost, markers, markers_nofinal, markers_symlink, fabricated, merged_ok = [], [], [], [], [], [], []

    texts = texts or {}

    for path in sorted(set(base) | set(ours) | set(theirs) | set(result)):

        if path in conflicted:

            continue

        b, o, t, r = base.get(path), ours.get(path), theirs.get(path), result.get(path)

        if o == t:

            want = o

        elif o == b:

            want = t

        elif t == b:

            want = o

        else:

            ev = texts.get(path)

            kind = _three_way_kind(b, o, t)

            if r is not None and r in (o, t):

                # One side taken wholesale: the other side's change is dropped. When the dropped

                # side changed only the kind/mode (same content as base), call it a mode loss.

                other = t if r == o else o

                same_content = o is not None and t is not None and o[1] == t[1]

                mode_only = other is not None and (same_content or (

                    b is not None and other[1] == b[1] and other[0] != b[0]))

                (mode_lost if mode_only else lost).append(path)

            elif r is None:

                lost.append(path)

            elif o is not None and t is not None and o[1] == t[1] and r[1] == o[1]:

                # Same content both sides, kinds differ: only the mode merge is at stake.

                (merged_ok if kind is not None and r[0] == kind else mode_lost).append(path)

            elif ev is None:

                fabricated.append(path)

            elif has_new_markers(ev):

                symlinky = "symlink" in (o and o[0], t and t[0], r[0])

                if symlinky:

                    markers_symlink.append(path)

                else:

                    (markers_nofinal if lacks_final_newline(ev) else markers).append(path)

            elif kind is None or r[0] != kind:

                mode_lost.append(path)  # content merged, but a side's mode/kind change dropped

            elif text_preserves_sides(ev.get("base") or b"", ev["ours"], ev["theirs"], ev["merged"]):

                merged_ok.append(path)

            else:

                lost.append(path)

            continue

        if r != want:

            # Absent, or another input's value (a side's change was dropped) -> lost;

            # a value no input has -> fabricated.

            (lost if r is None or r in (b, o, t) else fabricated).append(path)

    return {"lost": lost, "mode_lost": mode_lost, "markers": markers, "markers_no_final_newline": markers_nofinal,

            "markers_symlink": markers_symlink,

            "fabricated": fabricated,

            "text_merged": merged_ok}

def validate_class(value: str) -> str:

    if value not in CLASSES:

        raise ValueError(f"unknown merge-suite class {value!r}; expected one of {CLASSES}")

    return value

def _classify(git_result: Optional[dict], oak_result: Optional[dict], base: Optional[Tree], ours: Tree,

             theirs: Tree, *, unsupported: Optional[str] = None, harness_error: Optional[str] = None,

             expect: Optional[dict] = None, texts: Optional[Dict[str, dict]] = None) -> dict:

    """Classify one directional case. git_result: {clean, tree, conflicts{path: [types]}}.

    oak_result: adapter result ({clean, tree, conflicts, error, error_kind})."""

    if harness_error:

        return {"class": "harness-error", "reasons": [harness_error]}

    if unsupported:

        return {"class": "oak-unsupported", "reasons": [unsupported]}

    if oak_result is None or git_result is None:

        return {"class": "harness-error", "reasons": ["missing result"]}

    if oak_result.get("error_kind") == "harness":

        return {"class": "harness-error", "reasons": [oak_result.get("error") or "harness"]}

    if oak_result.get("error_kind") == "oak-setup":

        # A scripted setup step (import, push, staged pull) failed before the measured merge.

        # That is not a merge verdict and must never be absorbed by a known merge bug.

        return {"class": "harness-error", "reasons": ["setup_failed: " + str(oak_result.get("error"))[:300]]}

    if oak_result.get("error_kind") == "oak" or oak_result.get("clean") is None:

        reasons = ["oak_error: " + str(oak_result.get("error"))[:300]]

        pf = oak_result.get("post_failure") or {}

        if pf.get("hazard_head_moved_worktree_stale"):

            reasons.append("failed_pull_moved_head_worktree_stale: head %s -> %s, %d worktree path(s) "

                           "differ from HEAD, re-pull says %s" % (

                               str(pf.get("head_before"))[:12], str(pf.get("head_after"))[:12],

                               pf.get("worktree_changes_vs_head", 0), pf.get("repull_parent_sync")))

        if pf.get("hazard_worktree_dirty_head_unmoved"):

            reasons.append("failed_pull_left_worktree_dirty: HEAD unchanged, %d worktree path(s) differ "

                           "from HEAD (e.g. %s)" % (pf.get("worktree_changes_vs_head", 0),

                                                    ",".join((pf.get("worktree_changes_sample") or [])[:3])))

        return {"class": "oak-wrong", "reasons": reasons}

    oak_tree: Tree = oak_result["tree"]

    oak_conf: Set[str] = set(oak_result.get("conflicts") or {})

    git_conf: Set[str] = set(git_result.get("conflicts") or {})

    reasons: List[str] = []

    # base None = no unique merge base (criss-cross): the path-level law is undefined

    # there and stays unmeasured (null); expectations and the git oracle still apply.

    law = no_lost_change(base, ours, theirs, oak_tree, oak_conf, texts) if base is not None else None

    evidence = {"law_no_lost_change": law}

    base = base or {}

    if expect:

        violations = check_expectations(expect, oak_result, oak_tree, oak_conf)

        if violations:

            label = f"[{expect['label']}]" if expect.get("label") else ""

            return {"class": "oak-wrong", "reasons": [f"expectation_violated{label}: " + "; ".join(violations)],

                    "evidence": evidence}

    law = law or {"lost": [], "mode_lost": [], "markers": [], "markers_no_final_newline": [],

                  "markers_symlink": [], "fabricated": [], "text_merged": []}

    if law["markers_no_final_newline"]:

        reasons.append("committed_conflict_markers_no_final_newline: "

                       + ",".join(law["markers_no_final_newline"][:10]))

    if law["markers_symlink"]:

        reasons.append("committed_conflict_markers_symlink: " + ",".join(law["markers_symlink"][:10]))

    if law["markers"]:

        reasons.append("committed_conflict_markers: " + ",".join(law["markers"][:10]))

    if law["lost"]:

        reasons.append("lost_change: " + ",".join(law["lost"][:10]))

    if law["mode_lost"]:

        reasons.append("lost_mode_change: " + ",".join(law["mode_lost"][:10]))

    if law["fabricated"]:

        reasons.append("fabricated_content: " + ",".join(law["fabricated"][:10]))

    if reasons:

        return {"class": "oak-wrong", "reasons": reasons, "evidence": evidence}

    git_clean_part = split_tree(git_result["tree"], git_conf)

    oak_clean_part = split_tree(oak_tree, oak_conf)

    if (bool(oak_result["clean"]) == bool(git_result["clean"]) and oak_conf == git_conf

            and oak_clean_part == git_clean_part):

        type_diff = conflict_type_differences(git_result.get("conflicts") or {}, oak_conf, base, ours, theirs)

        out = {"class": "equal-to-git", "reasons": [], "evidence": evidence}

        if type_diff:

            out["notes"] = ["conflict_type_differs: " + ", ".join(type_diff[:10])]

        return out

    false_conf = sorted(oak_conf - git_conf)

    missed = sorted(git_conf - oak_conf)

    if false_conf:

        reasons.append("oak_conflicts_where_git_clean: " + ",".join(false_conf[:10]))

    if missed:

        reasons.append("oak_clean_where_git_conflicts: " + ",".join(missed[:10]))

    shared = set(git_clean_part) & set(oak_clean_part)

    only_git = sorted(p for p in set(git_clean_part) - set(oak_clean_part) if p not in oak_conf)

    only_oak = sorted(p for p in set(oak_clean_part) - set(git_clean_part) if p not in git_conf)

    changed = sorted(p for p in shared if git_clean_part[p] != oak_clean_part[p])

    if only_git or only_oak or changed:

        reasons.append("tree_differs(all side changes preserved): git_only=%s oak_only=%s content=%s"

                       % (only_git[:6], only_oak[:6], changed[:6]))

    if law["text_merged"] and changed:

        reasons.append("text_merge_algorithm_differs: " + ",".join(sorted(set(changed) & set(law["text_merged"]))[:6]))

    if not reasons:

        reasons.append("status_differs")

    evidence.update({"false_conflict_paths": false_conf, "missed_conflict_paths": missed})

    return {"class": "differs-but-valid", "reasons": reasons, "evidence": evidence}

def conflict_type_differences(git_conflicts: Dict[str, List[str]], oak_conf: Set[str],

                              base: Tree, ours: Tree, theirs: Tree) -> List[str]:

    out = []

    for path in sorted(oak_conf & set(git_conflicts)):

        oak_kind = oak_conflict_type(path, base, ours, theirs)

        git_kinds = git_conflicts[path]

        if git_kinds and oak_kind not in git_kinds and not (oak_kind == "content" and "binary" in git_kinds):

            out.append(f"{path}: git={'/'.join(git_kinds)} oak={oak_kind}")

    return out

def check_expectations(expect: dict, oak_result: dict, tree: Tree, conflicts: Set[str]) -> List[str]:

    """expect = {"clean": bool?, "paths": {path: sha256 | None (absent)}, "conflicts": [paths]?}."""

    out = []

    if "clean" in expect and bool(oak_result.get("clean")) != expect["clean"]:

        out.append(f"clean={oak_result.get('clean')} expected {expect['clean']}")

    for path, digest in (expect.get("paths") or {}).items():

        got = tree.get(path)

        if digest is None and got is not None and path not in conflicts:

            out.append(f"{path} present, expected absent")

        elif digest is not None and (got is None or got[1] != digest):

            out.append(f"{path} content {'absent' if got is None else got[1][:12]} expected {digest[:12]}")

    if "conflicts" in expect and sorted(conflicts) != sorted(expect["conflicts"]):

        out.append(f"conflicts={sorted(conflicts)} expected {sorted(expect['conflicts'])}")

    return out

def symmetry(forward: dict, reverse: dict) -> Optional[dict]:

    """Merge-symmetry law over two directional Oak results (None if either is unusable).

    merge(A,B) ≅ merge(B,A): same clean flag, same conflicted path set and the

    same non-conflicted content. Conflicted files are excluded (side labels and

    marker order legitimately differ)."""

    if not forward or not reverse or forward.get("clean") is None or reverse.get("clean") is None:

        return None

    fc, rc = set(forward.get("conflicts") or {}), set(reverse.get("conflicts") or {})

    ft, rt = split_tree(forward["tree"], fc), split_tree(reverse["tree"], rc)

    diffs = sorted(p for p in set(ft) | set(rt) if ft.get(p) != rt.get(p) and p not in fc | rc)

    ok = forward["clean"] == reverse["clean"] and fc == rc and not diffs

    return {"holds": ok, "conflict_sets_equal": fc == rc, "clean_equal": forward["clean"] == reverse["clean"],

            "content_diff_paths": diffs[:20]}

def idempotence_holds(oak_result: dict) -> Optional[bool]:

    idem = oak_result.get("idempotence") if oak_result else None

    if not idem:

        return None

    return (idem.get("returncode") == 0 and idem.get("head_unchanged") is True

            and idem.get("tree_unchanged") is True)

def classify(*args, **kwargs) -> dict:

    """Classify one directional case (see _classify); the class is always validated."""

    verdict = _classify(*args, **kwargs)

    validate_class(verdict["class"])

    return verdict