"""Git plumbing used as fixture builder and as the merge-ort reference oracle.

Git is the *oracle* here, never the subject. Every call runs with an isolated

config (no system/global config leaks into fixtures or oracle results).

"""

from __future__ import annotations

import hashlib

import os

from pathlib import Path

import stat

import subprocess

from typing import Dict, List, Optional, Tuple

# A tree value is (kind, sha256-of-bytes). kind: file | exec | symlink | gitlink.

# Symlink bytes are the link target; gitlink "bytes" are the commit id text.

TreeValue = Tuple[str, str]

Tree = Dict[str, TreeValue]

_MODE_KIND = {"100644": "file", "100755": "exec", "120000": "symlink", "160000": "gitlink"}

def sha256(data: bytes) -> str:

    return hashlib.sha256(data).hexdigest()

def git_env(home: Path, extra: Optional[dict] = None) -> dict:

    env = {k: v for k, v in os.environ.items() if not k.startswith("GIT_")}

    env.update({

        "HOME": str(home),

        "GIT_CONFIG_NOSYSTEM": "1",

        "GIT_CONFIG_GLOBAL": str(home / "gitconfig"),

        "GIT_AUTHOR_NAME": "author", "GIT_AUTHOR_EMAIL": "[email protected]",

        "GIT_COMMITTER_NAME": "committer", "GIT_COMMITTER_EMAIL": "[email protected]",

        "GIT_AUTHOR_DATE": "2000-01-01 00:00:00 +0000",

        "GIT_COMMITTER_DATE": "2000-01-01 00:00:00 +0000",

        "LC_ALL": "C",

    })

    if extra:

        env.update(extra)

    return env

def prepare_git_home(home: Path, git_bin: str) -> None:

    home.mkdir(parents=True, exist_ok=True)

    cfg = home / "gitconfig"

    if not cfg.exists():

        cfg.write_text("[init]\n\tdefaultBranch = main\n[protocol \"file\"]\n\tallow = always\n"

                       "[advice]\n\tdetachedHead = false\n")

class Git:

    def __init__(self, repo: Path, git_bin: str, home: Path):

        self.repo, self.bin, self.home = Path(repo), git_bin, Path(home)

    def run(self, *args: str, input: Optional[bytes] = None, check: bool = True,

            env_extra: Optional[dict] = None) -> subprocess.CompletedProcess:

        p = subprocess.run([self.bin, *args], cwd=self.repo, env=git_env(self.home, env_extra),

                           input=input, capture_output=True, timeout=120)

        if check and p.returncode:

            raise RuntimeError(f"git {' '.join(args)} failed ({p.returncode}): "

                               f"{p.stderr.decode('utf-8', 'replace')[:500]}")

        return p

    def out(self, *args: str, **kw) -> str:

        return self.run(*args, **kw).stdout.decode("utf-8", "surrogateescape").strip()

    def rev(self, ref: str) -> str:

        return self.out("rev-parse", "--verify", ref + "^{commit}")

    def merge_bases(self, a: str, b: str) -> List[str]:

        p = self.run("merge-base", "--all", a, b, check=False)

        return p.stdout.decode().split() if p.returncode == 0 else []

    def is_ancestor(self, a: str, b: str) -> bool:

        return self.run("merge-base", "--is-ancestor", a, b, check=False).returncode == 0

    def cat(self, obj: str) -> bytes:

        return self.run("cat-file", "-p", obj).stdout

    def tree(self, treeish: str) -> Tree:

        """Full recursive tree as {path: (kind, sha256)}; blobs are read in one batch."""

        raw = self.run("ls-tree", "-r", "-z", "--full-tree", treeish).stdout

        entries = []

        for rec in raw.split(b"\0"):

            if not rec:

                continue

            meta, path = rec.split(b"\t", 1)

            mode, _typ, oid = meta.decode().split()

            entries.append((path.decode("utf-8", "surrogateescape"), mode, oid))

        blobs = self.blob_bytes([oid for _, mode, oid in entries if mode != "160000"])

        result: Tree = {}

        for path, mode, oid in entries:

            kind = _MODE_KIND.get(mode, "unknown:" + mode)

            data = oid.encode() if mode == "160000" else blobs[oid]

            result[path] = (kind, sha256(data))

        return result

    def blob_bytes(self, oids: List[str]) -> Dict[str, bytes]:

        uniq = sorted(set(oids))

        if not uniq:

            return {}

        out = self.run("cat-file", "--batch", input=("\n".join(uniq) + "\n").encode()).stdout

        result, pos = {}, 0

        for _ in uniq:

            nl = out.index(b"\n", pos)

            oid, _typ, size = out[pos:nl].decode().split()

            start = nl + 1

            result[oid] = out[start:start + int(size)]

            pos = start + int(size) + 1

        return result

    def materialize(self, treeish: str, dest: Path) -> None:

        """Write a git tree into dest (files, exec bits, symlinks). Gitlinks are refused."""

        raw = self.run("ls-tree", "-r", "-z", "--full-tree", treeish).stdout

        entries = []

        for rec in raw.split(b"\0"):

            if rec:

                meta, path = rec.split(b"\t", 1)

                mode, _typ, oid = meta.decode().split()

                entries.append((os.fsdecode(path), mode, oid))

        if any(mode == "160000" for _, mode, _ in entries):

            raise ValueError("gitlink entries cannot be materialized")

        blobs = self.blob_bytes([oid for _, _, oid in entries])

        for path, mode, oid in entries:

            target = dest / path

            target.parent.mkdir(parents=True, exist_ok=True)

            if mode == "120000":

                os.symlink(os.fsdecode(blobs[oid]), target)

            else:

                target.write_bytes(blobs[oid])

                if mode == "100755":

                    target.chmod(target.stat().st_mode | 0o111)

    def merge_tree(self, ours: str, theirs: str) -> dict:

        """git merge-ort via `merge-tree --write-tree -z --messages` on two commits."""

        p = self.run("-c", "merge.conflictStyle=merge", "merge-tree", "-z", "--write-tree",

                     "--allow-unrelated-histories", "--messages", ours, theirs, check=False)

        if p.returncode not in (0, 1):

            raise RuntimeError("git merge-tree failed: " + p.stderr.decode("utf-8", "replace")[:500])

        parsed = parse_merge_tree_z(p.stdout)

        parsed["clean"] = p.returncode == 0

        parsed["tree"] = self.tree(parsed["tree_oid"])

        return parsed

def parse_merge_tree_z(out: bytes) -> dict:

    """Parse `git merge-tree -z --write-tree --messages` output.

    Layout: <tree>NUL, then conflicted stage records `<mode> <oid> <stage>\\t<path>NUL`,

    then an empty record, then messages `<n>NUL<path>NUL...<type>NUL<message>NUL`.

    """

    fields = out.split(b"\0")

    tree_oid = fields[0].decode()

    i = 1

    stages: Dict[str, List[int]] = {}

    while i < len(fields) and fields[i]:

        meta, path = fields[i].split(b"\t", 1)

        _mode, _oid, stage = meta.decode().split()

        stages.setdefault(os.fsdecode(path), []).append(int(stage))

        i += 1

    i += 1  # skip section separator

    messages = []

    while i < len(fields) and fields[i]:

        count = int(fields[i])

        paths = [os.fsdecode(fields[i + 1 + k]) for k in range(count)]

        ctype = fields[i + 1 + count].decode("utf-8", "replace")

        msg = fields[i + 2 + count].decode("utf-8", "replace")

        messages.append({"paths": paths, "type": ctype, "message": msg.strip()})

        i += 3 + count

    return {"tree_oid": tree_oid, "conflict_stages": stages, "messages": messages}

def normalize_git_conflict_type(ctype: str) -> Optional[str]:

    """Map a merge-ort message type to the suite's conflict vocabulary (None = informational)."""

    t = ctype.lower()

    if not t.startswith("conflict"):

        return None

    inner = t[t.find("(") + 1:t.rfind(")")] if "(" in t else t

    table = {

        "contents": "content", "content": "content", "binary": "binary",

        "add/add": "add/add", "modify/delete": "modify/delete",

        "rename/delete": "rename/delete", "rename/rename": "rename/rename",

        "rename involved in collision": "rename/add", "file/directory": "file/directory",

        "directory/file": "file/directory", "distinct types": "distinct-types",

        "submodule": "submodule",

    }

    if inner in table:

        return table[inner]

    if "dir" in inner and "rename" in inner:

        return "directory-rename"

    if "rename" in inner:

        return "rename/other"

    return "other:" + inner

def git_conflicts(merge: dict) -> Dict[str, List[str]]:

    """{conflicted path: sorted normalized types}. Paths come from the stage section

    (what the index would mark unmerged) plus paths named by CONFLICT messages."""

    result: Dict[str, set] = {p: set() for p in merge["conflict_stages"]}

    for m in merge["messages"]:

        kind = normalize_git_conflict_type(m["type"])

        if kind is None:

            continue

        for p in m["paths"]:

            if p in result:

                result[p].add(kind)

        if not any(p in result for p in m["paths"]) and m["paths"]:

            # Message-only conflicts (e.g. directory rename split) still count.

            result.setdefault(m["paths"][0], set()).add(kind)

    return {p: sorted(v) for p, v in sorted(result.items())}

def worktree_manifest(root: Path) -> Tree:

    """Oak working-tree projection in the same (kind, sha256) shape as Git.tree()."""

    result: Tree = {}

    def visit(directory: Path) -> None:

        for path in sorted(directory.iterdir()):

            if directory == root and path.name in {".git", ".oak"}:

                continue

            mode = path.lstat().st_mode

            name = path.relative_to(root).as_posix()

            if stat.S_ISLNK(mode):

                result[name] = ("symlink", sha256(os.fsencode(os.readlink(path))))

            elif stat.S_ISDIR(mode):

                visit(path)

            elif stat.S_ISREG(mode):

                result[name] = ("exec" if mode & 0o111 else "file", sha256(path.read_bytes()))

            else:

                result[name] = ("unknown", "")

    visit(root)

    return result