#!/usr/bin/env python3

"""Seed the identical Oak/Git fixture history for ``agent_loop_hosted_v1``.

Setup only; nothing here is timed. Produces a local Git repository whose

history is deterministic given (source tree, seed):

* commit 1 imports a source tree (oak/oak's tree, with CI config directories

  ``.github/`` and ``.oak/workflows/`` removed so neither host runs CI);

* commits 2..N edit synthetic files under ``bench-history/`` (1-3 files per

  commit, fixed PRNG), and every ``--merge-every`` steps a two-commit side

  branch is merged with ``--no-ff`` (the merge commit also appends to

  ``bench-history/MERGES.txt`` so every commit changes the tree).

``--publish-oak-clone`` then replays the same commits into an Oak clone of

the (already created) scratch repo as branch commits landed by hosted squash

merges -- see ``publish_oak_cycles`` for why direct pushes of ``main`` are

impossible today. The GitHub fixture is a plain ``git push`` of ``main``.

Measured seeding constraints (2026-09-27, oak 0.105.0 vs oak.space):

* a single push carrying >128 blobs is refused client-side (server does not

  advertise ``/api/capabilities`` staged push), so the source tree is imported

  in 100-file commits and the very first push can hold only one of them;

* a fresh ``oak clone file://<git>`` import cannot extend a remote ``main``

  ("push admission phase could not prove older remote commit edge(s)").

"""

from __future__ import annotations

import argparse

import os

import random

import shutil

import subprocess

import sys

from pathlib import Path

EXCLUDE_DIRS = {".oak", ".git", ".github"}

IMPORT_SLICE = 100

def run(cmd, cwd, env=None, quiet=True):

    r = subprocess.run(cmd, cwd=cwd, env=env, capture_output=True, text=True)

    if r.returncode != 0:

        raise SystemExit(f"command failed ({r.returncode}): {cmd}\n{r.stdout[-2000:]}\n{r.stderr[-2000:]}")

    return r.stdout

def copy_tree(src: Path, dst: Path) -> int:

    n = 0

    for root, dirs, files in os.walk(src):

        rel = Path(root).relative_to(src)

        if rel == Path("."):

            dirs[:] = [d for d in dirs if d not in EXCLUDE_DIRS]

        for f in files:

            s = Path(root) / f

            d = dst / rel / f

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

            shutil.copy2(s, d)

            n += 1

    return n

def git_env(i: int) -> dict:

    ts = f"{1_780_000_000 + i * 600} +0000"

    return dict(

        os.environ,

        GIT_AUTHOR_NAME="bench-seed", GIT_AUTHOR_EMAIL="[email protected]",

        GIT_COMMITTER_NAME="bench-seed", GIT_COMMITTER_EMAIL="[email protected]",

        GIT_AUTHOR_DATE=ts, GIT_COMMITTER_DATE=ts,

    )

def edit(repo: Path, rng: random.Random, step: int, files: int) -> None:

    for _ in range(rng.randint(1, 3)):

        p = repo / "bench-history" / f"f{rng.randrange(files):03d}.txt"

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

        with p.open("a") as fh:

            for j in range(rng.randint(1, 6)):

                fh.write(f"step {step} line {j} value {rng.getrandbits(48):012x}\n")

def seed_git(src: Path, repo: Path, commits: int, seed: int, merge_every: int, files: int) -> None:

    rng = random.Random(seed)

    repo.mkdir(parents=True)

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

    copy_tree(src, repo)

    # Import in slices of <= IMPORT_SLICE files: the hosted Oak server currently

    # refuses (client-side, before mutation) any single push carrying more than

    # MAPPING_PROOF_MAX_BLOBS=128 blobs, so the Oak mirror must be publishable

    # in increments. Git gets the identical commits.

    paths = sorted(run(["git", "ls-files", "--others", "--exclude-standard"], repo).split("\n"))

    paths = [x for x in paths if x]

    count = 0

    for i in range(0, len(paths), IMPORT_SLICE):

        run(["git", "add", "--"] + paths[i:i + IMPORT_SLICE], repo)

        count += 1

        run(["git", "commit", "-q", "-m", f"import source tree part {count}"], repo, git_env(count))

    run(["git", "add", "-A"], repo)

    if run(["git", "status", "--porcelain"], repo).strip():

        count += 1

        run(["git", "commit", "-q", "-m", "import source tree remainder"], repo, git_env(count))

    step = 0

    while count < commits:

        step += 1

        if merge_every and step % merge_every == 0 and commits - count >= 3:

            br = f"side-{step}"

            run(["git", "switch", "-q", "-c", br], repo)

            for k in range(2):

                edit(repo, rng, step * 10 + k, files)

                run(["git", "add", "-A"], repo)

                count += 1

                run(["git", "commit", "-q", "-m", f"side {step}.{k}"], repo, git_env(count))

            run(["git", "switch", "-q", "main"], repo)

            run(["git", "merge", "-q", "--no-ff", "--no-commit", br], repo, git_env(count))

            with (repo / "bench-history" / "MERGES.txt").open("a") as fh:

                fh.write(f"merged {br}\n")

            run(["git", "add", "-A"], repo)

            count += 1

            run(["git", "commit", "-q", "-m", f"Merge {br}"], repo, git_env(count))

            run(["git", "branch", "-q", "-D", br], repo)

        else:

            edit(repo, rng, step, files)

            run(["git", "add", "-A"], repo)

            count += 1

            run(["git", "commit", "-q", "-m", f"step {step}"], repo, git_env(count))

def publish_oak_cycles(git_repo: Path, oak_dir: Path, oak_bin: str, start_after: int, per_cycle: int = 10) -> int:

    """Replay Git commits onto an Oak clone as branch commits + hosted squash merges.

    Hosted Oak only lets ``main`` advance by server squash-merge (a first push

    can create ``main``, but the server refuses any push over 128 blobs without

    a staged protocol it does not yet advertise). So each cycle commits up to

    ``per_cycle`` Git commits (in ``--topo-order``) on the current branch and

    ends at a first-parent commit with ``oak desc`` + ``oak merge``. The

    squash commit's ``merge_parent`` is the branch head, so every replayed

    commit stays reachable from main; main's first-parent chain is shorter

    than Git's (one squash per cycle). ``start_after`` skips commits that are

    already on the Oak remote. Stops (never retries) on any merge failure.

    """

    env = dict(os.environ, OAK_NO_UPDATE_CHECK="1")

    shas = run(["git", "rev-list", "--reverse", "--topo-order", "main"], git_repo).split()

    first_parent = set(run(["git", "rev-list", "--first-parent", "main"], git_repo).split())

    idx = str(oak_dir.parent / (oak_dir.name + ".replay-index"))

    genv = dict(os.environ, GIT_INDEX_FILE=idx, GIT_WORK_TREE=str(oak_dir), GIT_DIR=str(git_repo / ".git"))

    pending = 0

    cycles = 0

    for n, sha in enumerate(shas, 1):

        if n <= start_after:

            continue

        run(["git", "read-tree", sha], git_repo, genv)

        run(["git", "checkout-index", "-a", "-f"], git_repo, genv)

        run([oak_bin, "commit", "--no-verify", "--quiet"], oak_dir, env)

        pending += 1

        if (pending >= per_cycle and sha in first_parent) or n == len(shas):

            cycles += 1

            run([oak_bin, "desc", f"seed cycle {cycles}: replay through git commit {n} ({sha[:12]})"], oak_dir, env)

            out = run([oak_bin, "merge", "--json"], oak_dir, env)

            print(f"cycle {cycles} through commit {n}: {out.strip()[:140]}", file=sys.stderr)

            pending = 0

    if os.path.exists(idx):

        os.unlink(idx)

    return cycles

def main(argv=None) -> int:

    ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])

    ap.add_argument("--source", required=True, type=Path)

    ap.add_argument("--git-dir", required=True, type=Path)

    ap.add_argument("--oak-bin", default="oak")

    ap.add_argument("--commits", type=int, default=1000)

    ap.add_argument("--seed", type=int, default=20260927)

    ap.add_argument("--merge-every", type=int, default=25)

    ap.add_argument("--files", type=int, default=50)

    ap.add_argument("--publish-oak-clone", type=Path, help="Oak clone of the target repo to replay into via squash-merge cycles")

    ap.add_argument("--start-after", type=int, default=0, help="Git commits (topo order) already on the Oak remote")

    ap.add_argument("--per-cycle", type=int, default=10)

    a = ap.parse_args(argv)

    if a.publish_oak_clone:

        print("cycles:", publish_oak_cycles(a.git_dir, a.publish_oak_clone, a.oak_bin, a.start_after, a.per_cycle))

        return 0

    seed_git(a.source, a.git_dir, a.commits, a.seed, a.merge_every, a.files)

    print("git commits:", run(["git", "rev-list", "--count", "main"], a.git_dir).strip(),

          "merges:", run(["git", "rev-list", "--count", "--merges", "main"], a.git_dir).strip(),

          "tree:", run(["git", "rev-parse", "main^{tree}"], a.git_dir).strip())

    return 0

if __name__ == "__main__":

    raise SystemExit(main())