"""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 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": [...], "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

    (checked with `texts[path] = {base, ours, theirs, merged}` bytes)."""

    lost, 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)

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

                lost.append(path)  # one side taken wholesale: the other side's change is dropped

            elif r is None or ev is None:

                (lost if r is None else fabricated).append(path)

            elif r[0] not in (o and o[0], t and t[0]):

                fabricated.append(path)

            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, "fabricated": fabricated, "text_merged": merged_ok}

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") in ("oak", "oak-setup") or oak_result.get("clean") is None:

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

    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:

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

                    "evidence": evidence}

    law = law or {"lost": [], "fabricated": [], "text_merged": []}

    if law["lost"]:

        reasons.append("lost_change: " + ",".join(law["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)