#!/usr/bin/env python3

"""Generate the branch-triage-shape local fixture with BRANCH_MANIFEST.json.

Creates a single git repository under ``<out>/repo`` with ``main`` plus N

labeled branches whose expected triage labels are recorded in

``<out>/BRANCH_MANIFEST.json``. Shapes cycle through empty, superseded_exact,

clean_contributes, conflict_additive, contributes_and_reverts_target, and

missing_data.

Determinism follows make_conflict_corpus.py: fixed identity, stepped commit

timestamps, seed-derived content, isolated git config. The same seed and

branch count always yield identical repos and manifests.

Self-test after generation asserts manifest validity, branch presence, and

deterministic regeneration.

Exit codes: 0 ok, 1 usage/generation/self-test error, 3 git unavailable.

"""

from __future__ import annotations

import argparse

import hashlib

import json

import os

import shutil

import subprocess

import sys

import tempfile

from pathlib import Path

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

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

from oakbench.branch_triage_shape import (

    GENERATOR_VERSION,

    MANIFEST_FILENAME,

    branch_name,

    shape_name,

    validate_manifest,

    write_manifest,

)

IDENTITY_NAME = "Oak Bench"

IDENTITY_EMAIL = "[email protected]"

EPOCH = 1_710_000_000

def git_env(tick: int = 0) -> dict[str, str]:

    stamp = f"{EPOCH + 60 * tick} +0000"

    env = dict(os.environ)

    env.update(

        GIT_CONFIG_GLOBAL=os.devnull,

        GIT_CONFIG_NOSYSTEM="1",

        GIT_AUTHOR_NAME=IDENTITY_NAME,

        GIT_AUTHOR_EMAIL=IDENTITY_EMAIL,

        GIT_COMMITTER_NAME=IDENTITY_NAME,

        GIT_COMMITTER_EMAIL=IDENTITY_EMAIL,

        GIT_AUTHOR_DATE=stamp,

        GIT_COMMITTER_DATE=stamp,

    )

    return env

def run_git(args: list[str], cwd: Path, tick: int = 0, check: bool = True) -> subprocess.CompletedProcess:

    return subprocess.run(

        ["git", *args],

        cwd=cwd,

        env=git_env(tick),

        check=check,

        capture_output=True,

        text=True,

    )

class Repo:

    def __init__(self, path: Path) -> None:

        self.path = path

        self.tick = 0

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

        run_git(["init", "-q"], path)

        run_git(["symbolic-ref", "HEAD", "refs/heads/main"], path)

    def write(self, rel: str, data: str | bytes) -> None:

        target = self.path / rel

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

        if isinstance(data, str):

            target.write_text(data)

        else:

            target.write_bytes(data)

    def commit(self, message: str) -> str:

        run_git(["add", "-A"], self.path, self.tick)

        run_git(["commit", "-q", "-m", message], self.path, self.tick)

        self.tick += 1

        return self.rev_parse()

    def rev_parse(self, rev: str = "HEAD") -> str:

        return run_git(["rev-parse", rev], self.path, self.tick).stdout.strip()

    def branch(self, name: str, start: str = "HEAD") -> None:

        run_git(["branch", name, start], self.path, self.tick)

    def checkout(self, branch: str, create: bool = False, start: str | None = None) -> None:

        args = ["checkout", "-q"]

        if create:

            args.extend(["-b", branch])

            if start is not None:

                args.append(start)

        else:

            args.append(branch)

        run_git(args, self.path, self.tick)

    def cherry_pick(self, commit: str) -> None:

        run_git(["cherry-pick", commit], self.path, self.tick)

        self.tick += 1

def superseded_path(index: int) -> str:

    return f"states/superseded-{index}.txt"

def conflict_path(index: int) -> str:

    return f"conflict/shared-{index}.txt"

def target_path(index: int) -> str:

    return f"target/risk-{index}.txt"

def superseded_placeholder(seed: str, index: int) -> str:

    return f"superseded placeholder {seed} {index}\n"

def superseded_final(seed: str, index: int) -> str:

    return f"superseded exact final {seed} {index}\n"

def conflict_base(seed: str, index: int) -> str:

    return f"shared base {seed} {index}\n"

def conflict_main(seed: str, index: int) -> str:

    return f"main additive {seed} {index}\n"

def conflict_branch(seed: str, index: int) -> str:

    return f"branch additive {seed} {index}\n"

def target_before_fix(seed: str, index: int) -> str:

    return f"target before fix {seed} {index}\n"

def target_after_fix(seed: str, index: int) -> str:

    return f"target fixed {seed} {index}\n"

def missing_payload(seed: str, index: int) -> bytes:

    return hashlib.sha256(f"{seed}:missing:{index}".encode()).digest()

def support_key(shape: str, index: int) -> str:

    return f"{shape}:{index}"

def seed_main(repo: Repo, seed: str, branch_count: int) -> tuple[str, list[tuple[str, str]]]:

    repo.write("README.md", f"# branch triage fixture\n\nseed={seed}\n")

    repo.write(".gitignore", ".fixture-ready\n")

    for index in range(branch_count):

        shape = shape_name(index)

        if shape == "superseded_exact":

            repo.write(superseded_path(index), superseded_placeholder(seed, index))

        elif shape == "conflict_additive":

            repo.write(conflict_path(index), conflict_base(seed, index))

        elif shape == "contributes_and_reverts_target":

            repo.write(target_path(index), target_before_fix(seed, index))

    base_head = repo.commit("init main")

    support_commits: list[tuple[str, str]] = []

    for index in range(branch_count):

        shape = shape_name(index)

        key = support_key(shape, index)

        if shape == "superseded_exact":

            repo.write(superseded_path(index), superseded_final(seed, index))

            support_commits.append((key, repo.commit(f"main superseded content {index}")))

        elif shape == "conflict_additive":

            repo.write(conflict_path(index), conflict_main(seed, index))

            support_commits.append((key, repo.commit(f"main conflict side {index}")))

        elif shape == "contributes_and_reverts_target":

            repo.write(target_path(index), target_after_fix(seed, index))

            support_commits.append((key, repo.commit(f"main target fix {index}")))

    return base_head, support_commits

def cherry_pick_support(repo: Repo, *, own_key: str, support_commits: list[tuple[str, str]]) -> None:

    for key, commit in support_commits:

        if key == own_key:

            continue

        repo.cherry_pick(commit)

def build_empty(repo: Repo, index: int) -> None:

    repo.branch(branch_name(index), "main")

def build_superseded_exact(

    repo: Repo,

    seed: str,

    index: int,

    *,

    base_head: str,

    support_commits: list[tuple[str, str]],

) -> None:

    repo.checkout(branch_name(index), create=True, start=base_head)

    repo.write(superseded_path(index), superseded_final(seed, index))

    repo.commit(f"branch superseded content {index}")

    cherry_pick_support(repo, own_key=support_key("superseded_exact", index), support_commits=support_commits)

    repo.checkout("main")

def build_clean_contributes(repo: Repo, seed: str, index: int) -> None:

    repo.checkout(branch_name(index), create=True, start="main")

    repo.write(f"contrib/clean-{index}.txt", f"clean contribution {seed} {index}\n")

    repo.commit(f"clean contribution {index}")

    repo.checkout("main")

def build_conflict_additive(

    repo: Repo,

    seed: str,

    index: int,

    *,

    base_head: str,

    support_commits: list[tuple[str, str]],

) -> None:

    repo.checkout(branch_name(index), create=True, start=base_head)

    repo.write(conflict_path(index), conflict_branch(seed, index))

    repo.commit(f"branch conflict side {index}")

    cherry_pick_support(repo, own_key=support_key("conflict_additive", index), support_commits=support_commits)

    repo.checkout("main")

def build_contributes_and_reverts_target(repo: Repo, seed: str, index: int) -> None:

    repo.checkout(branch_name(index), create=True, start="main")

    repo.write(f"contrib/reverts-target-{index}.txt", f"contributes while reverting target {seed} {index}\n")

    repo.write(target_path(index), target_before_fix(seed, index))

    repo.commit(f"regressive contribution {index}")

    repo.checkout("main")

def build_missing_data(repo: Repo, seed: str, index: int) -> None:

    repo.checkout(branch_name(index), create=True, start="main")

    repo.write(f"missing/manual-{index}.txt", f"manual review required {seed} {index}\n")

    repo.write(f"missing/payload-{index}.bin", missing_payload(seed, index))

    repo.commit(f"missing data branch {index}")

    repo.checkout("main")

def build_shape(

    repo: Repo,

    seed: str,

    index: int,

    *,

    base_head: str,

    support_commits: list[tuple[str, str]],

) -> None:

    shape = shape_name(index)

    if shape == "empty":

        build_empty(repo, index)

    elif shape == "superseded_exact":

        build_superseded_exact(repo, seed, index, base_head=base_head, support_commits=support_commits)

    elif shape == "clean_contributes":

        build_clean_contributes(repo, seed, index)

    elif shape == "conflict_additive":

        build_conflict_additive(repo, seed, index, base_head=base_head, support_commits=support_commits)

    elif shape == "contributes_and_reverts_target":

        build_contributes_and_reverts_target(repo, seed, index)

    elif shape == "missing_data":

        build_missing_data(repo, seed, index)

    else:

        raise ValueError(f"unknown shape {shape!r}")

def generate_fixture(out: Path, seed: str, branch_count: int) -> dict[str, object]:

    if shutil.which("git") is None:

        raise RuntimeError("git unavailable")

    repo_root = out / "repo"

    if repo_root.exists():

        shutil.rmtree(repo_root)

    repo = Repo(repo_root)

    base_head, support_commits = seed_main(repo, seed, branch_count)

    for index in range(branch_count):

        build_shape(repo, seed, index, base_head=base_head, support_commits=support_commits)

    manifest = write_manifest(out / MANIFEST_FILENAME, seed=seed, branch_count=branch_count)

    errors = validate_manifest(manifest)

    if errors:

        raise RuntimeError("manifest validation failed: " + "; ".join(errors))

    branches = run_git(["branch", "--format=%(refname:short)"], repo_root, repo.tick, check=False)

    present = {line.strip() for line in branches.stdout.splitlines() if line.strip()}

    for entry in manifest["branches"]:

        name = entry["name"]

        if name not in present:

            raise RuntimeError(f"missing generated branch {name!r}")

    return manifest

def self_test(out: Path, seed: str, branch_count: int) -> None:

    manifest = json.loads((out / MANIFEST_FILENAME).read_text())

    if validate_manifest(manifest):

        raise RuntimeError("self-test manifest invalid")

    if branch_count > 6:

        return

    regen = Path(tempfile.mkdtemp(prefix="branch-triage-selftest-"))

    try:

        generate_fixture(regen, seed, branch_count)

        first = (out / MANIFEST_FILENAME).read_text()

        second = (regen / MANIFEST_FILENAME).read_text()

        if first != second:

            raise RuntimeError("manifest not deterministic across regeneration")

    finally:

        shutil.rmtree(regen, ignore_errors=True)

def parse_args(argv: list[str] | None = None) -> argparse.Namespace:

    parser = argparse.ArgumentParser(description="Generate branch triage shape fixture")

    parser.add_argument("--out", type=Path, required=True)

    parser.add_argument("--seed", default="oakbench-branch-triage-v2")

    parser.add_argument("--branch-count", type=int, default=6)

    parser.add_argument("--quick", action="store_true", help="Alias for --branch-count 6")

    parser.add_argument("--medium", action="store_true", help="Alias for --branch-count 60")

    return parser.parse_args(argv)

def main(argv: list[str] | None = None) -> int:

    args = parse_args(argv)

    if args.quick:

        args.branch_count = 6

    if args.medium:

        args.branch_count = 60

    if args.branch_count < 1:

        print("branch-count must be at least 1", file=sys.stderr)

        return 1

    if shutil.which("git") is None:

        print("git unavailable", file=sys.stderr)

        return 3

    try:

        generate_fixture(args.out, args.seed, args.branch_count)

        self_test(args.out, args.seed, args.branch_count)

    except RuntimeError as exc:

        print(str(exc), file=sys.stderr)

        return 1

    print(json.dumps({"ok": True, "generator": GENERATOR_VERSION, "out": str(args.out)}, sort_keys=True))

    return 0

if __name__ == "__main__":

    raise SystemExit(main())