#!/usr/bin/env python3

"""Generate the deterministic large-mirror fixture (bench-large-mirror).

Produces the working tree used by the mount-vs-clone lane: the same seed

always yields the same bytes (fixture identity, ADR-0005), and the content

has realistic entropy — text files are seeded identifier soup that compresses

like real source (~3-4x), binaries are seeded incompressible bytes — so

transfer-byte measurements mean something. Pattern fixtures from

oakbench.fixtures compress ~1000:1 and must not be used here.

Modes:

  --tree-only        write the final working tree + MANIFEST.sha256, no VCS

  --git-history      also synthesize git history (growth commits + churn

                     commits + one binary rewrite), manifest committed last

  --verify DIR       recompute the manifest in DIR and compare

Both modes end at the identical final tree; --verify proves it.

The git and oak mirrors share the final tree (verified via MANIFEST.sha256),

not history: git carries the synthetic history because full-history transfer

is part of stock clone cost; the oak mirror is seeded with a single commit.

Record that asymmetry wherever results are published.

Usage:

  python3 scripts/make_large_fixture.py --dest /tmp/bench-large-mirror --git-history

  python3 scripts/make_large_fixture.py --verify /tmp/bench-large-mirror

"""

from __future__ import annotations

import argparse

import hashlib

import random

import subprocess

import sys

from pathlib import Path

FIXTURE_NAME = "bench-large-mirror"

FIXTURE_VERSION = "v1"

DEFAULT_SEED = f"oak-{FIXTURE_NAME}-{FIXTURE_VERSION}"

TEXT_FILE_COUNT = 28_000

BINARY_SPECS = [  # path, MiB (kept well under GitHub's 100 MB file limit)

    ("assets/media/intro.bin", 16),

    ("assets/media/dataset.bin", 32),

    ("assets/models/weights.bin", 48),

]

GROWTH_COMMITS = 20

CHURN_COMMITS = 400

CHURN_FILES_PER_COMMIT = 8

CHURN_LINES_PER_TOUCH = 4

MANIFEST = "MANIFEST.sha256"

TOP_DIRS = ["core", "api", "ui", "infra", "tools", "vendor", "docs", "tests"]

EXTENSIONS = {"core": ".py", "api": ".py", "ui": ".ts", "infra": ".yaml",

              "tools": ".py", "vendor": ".js", "docs": ".md", "tests": ".py"}

WORDS = (

    "handler request response buffer stream parse encode decode commit tree "

    "branch merge index cache token batch worker queue retry timeout config "

    "schema field record column filter reduce visit walk node edge graph "

    "mount hydrate snapshot manifest oracle subject lane scenario operation"

).split()

def make_rng(seed: str, *scope: object) -> random.Random:

    digest = hashlib.sha256(":".join([seed, *map(str, scope)]).encode()).digest()

    return random.Random(int.from_bytes(digest[:8], "big"))

def text_paths(seed: str) -> list[str]:

    rng = make_rng(seed, "paths")

    paths: list[str] = []

    seen = set()

    while len(paths) < TEXT_FILE_COUNT:

        top = rng.choice(TOP_DIRS)

        depth = rng.randint(1, 5)

        parts = [top] + [

            f"{rng.choice(WORDS)}_{rng.randint(0, 99):02d}" for _ in range(depth)

        ]

        name = f"{rng.choice(WORDS)}_{rng.randint(0, 9999):04d}{EXTENSIONS[top]}"

        rel = "/".join(parts + [name])

        if rel not in seen:

            seen.add(rel)

            paths.append(rel)

    paths.sort()

    return paths

def text_body(seed: str, rel: str) -> bytes:

    rng = make_rng(seed, "body", rel)

    # Log-normal-ish sizes centered near ~7 KB so 28k files land near 200 MB.

    lines = max(12, int(rng.lognormvariate(4.6, 0.7)))

    out = [f"# {FIXTURE_NAME} {FIXTURE_VERSION} {rel}"]

    for i in range(lines):

        w = [rng.choice(WORDS) for _ in range(rng.randint(4, 11))]

        out.append(f"{w[0]}_{rng.randint(0,999)} = {w[1]}({', '.join(w[2:])})  # {i}")

    return ("\n".join(out) + "\n").encode()

def churn_block(seed: str, rel: str, commit_index: int) -> str:

    """The exact lines appended to rel by churn commit commit_index.

    Shared by --git-history (incremental appends) and --tree-only (bulk

    appends) so both modes converge on identical bytes.

    """

    rng = make_rng(seed, "churnline", rel, commit_index)

    lines = []

    for _ in range(CHURN_LINES_PER_TOUCH):

        w = [rng.choice(WORDS) for _ in range(5)]

        lines.append(f"{w[0]}_{rng.randint(0,999)} = {w[1]}({', '.join(w[2:])})  # churn")

    return "".join(line + "\n" for line in lines)

def churn_schedule(seed: str, paths: list[str]) -> list[list[str]]:

    rng = make_rng(seed, "churn")

    return [sorted(rng.sample(paths, CHURN_FILES_PER_COMMIT)) for _ in range(CHURN_COMMITS)]

def write_binary(path: Path, mib: int, seed: str) -> None:

    rng = make_rng(seed, "binary", path.name, mib)

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

    with path.open("wb") as fh:

        for _ in range(mib):

            fh.write(rng.randbytes(1024 * 1024))

def write_readme(dest: Path, seed: str) -> None:

    (dest / "README.md").write_text(

        f"# {FIXTURE_NAME}\n\nDeterministic benchmark fixture "

        f"({FIXTURE_VERSION}, seed `{seed}`), generated by "

        f"`scripts/make_large_fixture.py` in oak/benchmarks.\n"

        f"Do not edit by hand; regenerate and bump {FIXTURE_VERSION} instead.\n"

    )

def write_base_tree(dest: Path, seed: str) -> list[str]:

    """The pre-churn tree: base text bodies + original binaries + README."""

    paths = text_paths(seed)

    for rel in paths:

        p = dest / rel

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

        p.write_bytes(text_body(seed, rel))

    for rel, mib in BINARY_SPECS:

        write_binary(dest / rel, mib, seed + ":orig")

    write_readme(dest, seed)

    return paths

def apply_churn_to_tree(dest: Path, seed: str, paths: list[str]) -> None:

    """Bulk-apply every churn append and the final binary rewrite."""

    appends: dict[str, list[str]] = {}

    for i, batch in enumerate(churn_schedule(seed, paths)):

        for rel in batch:

            appends.setdefault(rel, []).append(churn_block(seed, rel, i))

    for rel, blocks in appends.items():

        with (dest / rel).open("a", encoding="utf-8") as fh:

            fh.write("".join(blocks))

    for rel, mib in BINARY_SPECS:

        write_binary(dest / rel, mib, seed)

def compute_manifest(root: Path) -> str:

    entries = []

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

        rel = p.relative_to(root).as_posix()

        if not p.is_file() or rel == MANIFEST or rel.split("/", 1)[0] in (".git", ".oak"):

            continue

        entries.append(f"{hashlib.sha256(p.read_bytes()).hexdigest()}  {rel}")

    return "\n".join(entries) + "\n"

def git(args: list[str], cwd: Path, commit_index: int | None = None) -> None:

    env = None

    if commit_index is not None:

        # Deterministic identity/dates make the history reproducible run-to-run.

        ts = 1767225600 + commit_index * 60  # 2026-01-01T00:00:00Z + 60s per commit

        env = {"GIT_AUTHOR_DATE": f"{ts} +0000", "GIT_COMMITTER_DATE": f"{ts} +0000",

               "GIT_AUTHOR_NAME": "oak-bench", "GIT_AUTHOR_EMAIL": "[email protected]",

               "GIT_COMMITTER_NAME": "oak-bench", "GIT_COMMITTER_EMAIL": "[email protected]",

               "PATH": "/usr/bin:/bin:/usr/local/bin:/opt/homebrew/bin",

               "HOME": str(Path.home())}

    subprocess.run(["git", *args], cwd=cwd, env=env, check=True,

                   stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)

def build_git_history(dest: Path, seed: str) -> None:

    paths = write_base_tree(dest, seed)

    git(["init", "-q", "-b", "main"], dest)

    git(["config", "core.autocrlf", "false"], dest)

    n = 0

    growth_groups: list[list[str]] = [[] for _ in range(GROWTH_COMMITS)]

    for i, rel in enumerate(paths):

        growth_groups[i % GROWTH_COMMITS].append(rel)

    for i, group in enumerate(growth_groups):

        git(["add", "--"] + group + (["README.md"] if i == 0 else []), dest)

        n += 1

        git(["commit", "-q", "-m", f"growth {i+1}/{GROWTH_COMMITS}"], dest, n)

    git(["add", "-A"], dest)

    n += 1

    git(["commit", "-q", "-m", "add binary assets"], dest, n)

    for i, batch in enumerate(churn_schedule(seed, paths)):

        for rel in batch:

            with (dest / rel).open("a", encoding="utf-8") as fh:

                fh.write(churn_block(seed, rel, i))

        git(["add", "--"] + batch, dest)

        n += 1

        git(["commit", "-q", "-m", f"churn {i+1}/{CHURN_COMMITS}"], dest, n)

    # One binary rewrite so history carries a large non-text delta.

    for rel, mib in BINARY_SPECS:

        write_binary(dest / rel, mib, seed)

    git(["add", "-A"], dest)

    n += 1

    git(["commit", "-q", "-m", "refresh binary assets"], dest, n)

    (dest / MANIFEST).write_text(compute_manifest(dest))

    git(["add", MANIFEST], dest)

    n += 1

    git(["commit", "-q", "-m", f"manifest {FIXTURE_VERSION}"], dest, n)

def main() -> int:

    ap = argparse.ArgumentParser(description=__doc__)

    ap.add_argument("--dest", type=Path)

    ap.add_argument("--seed", default=DEFAULT_SEED)

    ap.add_argument("--tree-only", action="store_true")

    ap.add_argument("--git-history", action="store_true")

    ap.add_argument("--verify", type=Path)

    args = ap.parse_args()

    if args.verify:

        expected = (args.verify / MANIFEST).read_text()

        actual = compute_manifest(args.verify)

        if expected == actual:

            print(f"OK: {args.verify} matches {MANIFEST} ({expected.count(chr(10))} files)")

            return 0

        print("MISMATCH: tree does not match MANIFEST.sha256", file=sys.stderr)

        return 1

    if not args.dest:

        ap.error("--dest required unless --verify")

    dest = args.dest

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

    if any(dest.iterdir()):

        print(f"refusing to write into non-empty {dest}", file=sys.stderr)

        return 1

    if args.git_history:

        build_git_history(dest, args.seed)

    else:

        paths = write_base_tree(dest, args.seed)

        apply_churn_to_tree(dest, args.seed, paths)

        (dest / MANIFEST).write_text(compute_manifest(dest))

    total = sum(p.stat().st_size for p in dest.rglob("*")

                if p.is_file() and ".git" not in p.parts)

    print(f"{FIXTURE_NAME} {FIXTURE_VERSION} seed={args.seed} -> {dest}")

    print(f"working tree bytes (excl .git): {total:,}")

    return 0

if __name__ == "__main__":

    raise SystemExit(main())