"""Deterministic Git history with two-parent merges, for ancestry-walk lanes.

``make_monorepo_fixture.py`` produces linear history. Lanes that measure how a

client walks ancestry (e.g. first parent refresh in a shallow worker) need the

merge shape real repositories have: a mainline with short side branches

merged back with ``--no-ff`` two-parent commits.

Identity (ADR-0005): the same ``(commits, seed, FIXTURE_SCHEMA)`` always yields

byte-identical history — fixed author/committer, timestamps stepping from a

fixed epoch, a seeded RNG for topology/content, one ``git fast-import`` stream.

Commit SHAs are therefore reproducible across runs and machines, and the

resulting head is recorded in the manifest so lanes can check it. Changing

the generator's output is a ``FIXTURE_SCHEMA`` bump.

The model tracks the full file map for every commit, so the expected tree at

``main`` (``expected_files``) is known independently of Git and of the VCS

under test. ``tree_content_hash`` hashes that map canonically.

"""

from __future__ import annotations

import hashlib

import random

import subprocess

from dataclasses import dataclass, field

from pathlib import Path

FIXTURE_SCHEMA = "merge-history-v1"

EPOCH = 1_767_225_600  # 2026-01-01T00:00:00Z

IDENTITY = b"Oak Bench Fixture <[email protected]>"

MAINLINE_FILES = 48

SIDE_BRANCH_PROBABILITY = 0.035

SIDE_BRANCH_MIN_COMMITS = 1

SIDE_BRANCH_MAX_COMMITS = 3

@dataclass

class MergeHistoryManifest:

    schema: str

    commits: int

    seed: int

    merge_commits: int

    root_commits: int

    expected_files: dict[str, str] = field(repr=False)  # path -> sha256 hex of bytes

    head: str | None = None  # git SHA of main, filled after import

    @property

    def fixture_id(self) -> str:

        return f"{self.schema}-c{self.commits}-s{self.seed}"

    @property

    def merge_fraction(self) -> float:

        return self.merge_commits / self.commits if self.commits else 0.0

    @property

    def tree_content_hash(self) -> str:

        return tree_content_hash(self.expected_files)

    def as_dict(self) -> dict[str, object]:

        return {

            "fixture_generator": "oakbench.merge_history_fixture",

            "fixture_version": self.schema,

            "fixture_id": self.fixture_id,

            "fixture_commits": self.commits,

            "fixture_seed": str(self.seed),

            "fixture_merge_commits": self.merge_commits,

            "fixture_merge_fraction": round(self.merge_fraction, 4),

            "fixture_root_commits": self.root_commits,

            "fixture_file_count": len(self.expected_files),

            "fixture_tree_content_hash": self.tree_content_hash,

            "fixture_git_head": self.head,

        }

def tree_content_hash(files: dict[str, str]) -> str:

    """Canonical hash of a {posix path: sha256(bytes)} map (paths sorted)."""

    digest = hashlib.sha256()

    for path in sorted(files):

        digest.update(path.encode("utf-8") + b"\0" + files[path].encode("ascii") + b"\n")

    return digest.hexdigest()

def worktree_files(root: Path, ignored_top_level: tuple[str, ...] = (".oak", ".git")) -> dict[str, str]:

    """Regular files under ``root`` as {posix path: sha256}; symlinks/dirs excluded."""

    files: dict[str, str] = {}

    for path in sorted(root.rglob("*")):

        relative = path.relative_to(root)

        if relative.parts and relative.parts[0] in ignored_top_level:

            continue

        if path.is_file() and not path.is_symlink():

            files[relative.as_posix()] = hashlib.sha256(path.read_bytes()).hexdigest()

    return files

def _content(path: str, revision: int, rng: random.Random) -> bytes:

    token = rng.getrandbits(64)

    lines = [f"{path} revision {revision} token {token:016x}"]

    lines.extend(f"line {index} {token ^ index:016x}" for index in range(8))

    return ("\n".join(lines) + "\n").encode("utf-8")

def _blob(data: bytes) -> bytes:

    return b"data " + str(len(data)).encode() + b"\n" + data + b"\n"

def build_stream(commits: int, seed: int) -> tuple[bytes, MergeHistoryManifest]:

    """Return the fast-import stream and the independent model manifest."""

    if commits < 1:

        raise ValueError("commits must be >= 1")

    rng = random.Random(f"{FIXTURE_SCHEMA}:{seed}")

    out: list[bytes] = []

    main_files: dict[str, bytes] = {}

    revision = 0

    mark = 0

    produced = 0

    merges = 0

    main_mark: int | None = None

    side_serial = 0

    def emit_commit(ref: bytes, parents: list[int], changes: dict[str, bytes], message: str) -> int:

        nonlocal mark, produced

        mark += 1

        produced += 1

        when = str(EPOCH + produced * 60).encode()

        body = message.encode("utf-8")

        out.append(b"commit " + ref + b"\n")

        out.append(b"mark :" + str(mark).encode() + b"\n")

        out.append(b"author " + IDENTITY + b" " + when + b" +0000\n")

        out.append(b"committer " + IDENTITY + b" " + when + b" +0000\n")

        out.append(b"data " + str(len(body)).encode() + b"\n" + body + b"\n")

        if parents:

            out.append(b"from :" + str(parents[0]).encode() + b"\n")

        for parent in parents[1:]:

            out.append(b"merge :" + str(parent).encode() + b"\n")

        for path in sorted(changes):

            out.append(b"M 100644 inline " + path.encode("utf-8") + b"\n")

            out.append(_blob(changes[path]))

        out.append(b"\n")

        return mark

    def mainline_change() -> dict[str, str]:

        nonlocal revision

        revision += 1

        path = f"src/d{rng.randrange(6):02d}/f{rng.randrange(MAINLINE_FILES):03d}.txt"

        return {path: _content(path, revision, rng)}

    # Root commit: the full mainline tree.

    initial = {}

    for index in range(MAINLINE_FILES):

        path = f"src/d{index % 6:02d}/f{index:03d}.txt"

        initial[path] = _content(path, 0, rng)

    main_files.update(initial)

    main_mark = emit_commit(b"refs/heads/main", [], initial, "fixture root")

    while produced < commits:

        remaining = commits - produced

        # A side branch needs >= 1 side commit, one mainline commit (so the

        # merge is a true two-parent merge, not a fast-forward), and the merge.

        if remaining >= 3 and rng.random() < SIDE_BRANCH_PROBABILITY * 2:

            side_len = rng.randint(SIDE_BRANCH_MIN_COMMITS, min(SIDE_BRANCH_MAX_COMMITS, remaining - 2))

            side_serial += 1

            side_ref = f"refs/heads/side-{side_serial:04d}".encode()

            side_changes_total: dict[str, bytes] = {}

            side_mark = main_mark

            for step in range(side_len):

                revision += 1

                path = f"side/s{side_serial:04d}/n{step % 2}.txt"

                change = {path: _content(path, revision, rng)}

                side_changes_total.update(change)

                side_mark = emit_commit(side_ref, [side_mark], change, f"side {side_serial} step {step}")

            main_change = mainline_change()

            main_files.update(main_change)

            main_mark = emit_commit(b"refs/heads/main", [main_mark], main_change, f"main {produced}")

            # Side paths never collide with mainline paths: the merge tree is

            # main's tree plus the side branch's files.

            main_files.update(side_changes_total)

            main_mark = emit_commit(

                b"refs/heads/main", [main_mark, side_mark], side_changes_total,

                f"Merge side-{side_serial:04d}",

            )

            merges += 1

            out.append(b"reset " + side_ref + b"\n" + b"from 0000000000000000000000000000000000000000\n\n")

            continue

        change = mainline_change()

        main_files.update(change)

        main_mark = emit_commit(b"refs/heads/main", [main_mark], change, f"main {produced}")

    manifest = MergeHistoryManifest(

        schema=FIXTURE_SCHEMA,

        commits=produced,

        seed=seed,

        merge_commits=merges,

        root_commits=1,

        expected_files={path: hashlib.sha256(data).hexdigest() for path, data in main_files.items()},

    )

    return b"".join(out) + b"done\n", manifest

def generate(dest: Path, commits: int, seed: int, *, git_bin: str = "git", env: dict[str, str] | None = None) -> MergeHistoryManifest:

    """Create a non-bare Git repo at ``dest`` with ``main`` checked out."""

    stream, manifest = build_stream(commits, seed)

    dest.mkdir(parents=True, exist_ok=False)

    def git(*args: str, data: bytes | None = None) -> bytes:

        result = subprocess.run(

            [git_bin, *args], cwd=dest, input=data, env=env,

            stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False,

        )

        if result.returncode != 0:

            raise RuntimeError(f"git {args[0]} failed: {result.stderr.decode(errors='replace')[-2000:]}")

        return result.stdout

    git("init", "-q", "-b", "main")

    git("fast-import", "--quiet", "--done", data=stream)

    git("checkout", "-q", "-f", "main")

    manifest.head = git("rev-parse", "refs/heads/main").decode().strip()

    return manifest

__all__ = [

    "FIXTURE_SCHEMA",

    "MergeHistoryManifest",

    "build_stream",

    "generate",

    "tree_content_hash",

    "worktree_files",

]