#!/usr/bin/env python3

"""Run or materialize a Git Baseline Book campaign."""

from __future__ import annotations

import argparse

import json

import shutil

import subprocess

import sys

from pathlib import Path

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

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

import publish_gate  # noqa: E402

from oakbench.baseline_book import (  # noqa: E402

    DEFAULT_BASELINE_METRICS,

    DEFAULT_BASELINE_STATISTICS,

    book_json,

    book_markdown,

    cells_from_rows,

    iter_jsonl,

    manifest_json,

    sha256_file,

)

from oakbench.runner import machine_profile, runner_class, runner_id  # noqa: E402

def non_negative_float(raw: str) -> float:

    value = float(raw)

    if value < 0:

        raise argparse.ArgumentTypeError("must be >= 0")

    return value

def parse_args() -> argparse.Namespace:

    parser = argparse.ArgumentParser(description=__doc__)

    sub = parser.add_subparsers(dest="command", required=True)

    run = sub.add_parser("run", help="run bench.py with canonical Git baseline arguments, then write a book")

    add_common_book_args(run)

    run.add_argument("--profile", default="standard")

    run.add_argument("--track", default="core-equivalent")

    run.add_argument("--runs", type=int, default=30)

    run.add_argument("--results", type=Path, required=True)

    run.add_argument("--workdir", type=Path, required=True)

    run.add_argument("--git-bin", type=Path)

    run.add_argument("--git-modes", default="untracked_cache,fsmonitor")

    run.add_argument("--skip-remote", action="store_true")

    book = sub.add_parser("book", help="write a book from existing benchmark JSONL")

    add_common_book_args(book)

    book.add_argument("--input-jsonl", nargs="+", type=Path, required=True)

    return parser.parse_args()

def add_common_book_args(parser: argparse.ArgumentParser) -> None:

    parser.add_argument("--book-id", required=True)

    parser.add_argument("--out", type=Path, help="Output directory; defaults to baselines/git/<book-id>")

    parser.add_argument("--lane", default="core")

    parser.add_argument("--metrics", default=",".join(DEFAULT_BASELINE_METRICS))

    parser.add_argument("--statistics", default=",".join(DEFAULT_BASELINE_STATISTICS))

    parser.add_argument("--subjects", help="Comma-separated Git subject names to include in the book")

    parser.add_argument("--include-subops", action="store_true")

    parser.add_argument("--bootstrap-samples", type=int, default=2000)

    parser.add_argument("--confidence", type=float, default=0.95)

    parser.add_argument("--noise-floor-pct", type=non_negative_float)

    parser.add_argument("--raw-storage-key", action="append", default=[])

    parser.add_argument("--skip-publish-gate", action="store_true")

    parser.add_argument("--force", action="store_true")

    parser.add_argument("--update-current", action="store_true")

def split_csv(raw: str | None) -> tuple[str, ...]:

    if not raw:

        return ()

    return tuple(item.strip() for item in raw.split(",") if item.strip())

def resolve_git_binary(args: argparse.Namespace) -> Path | None:

    """Resolve the single git binary used for benching, pinning, and versioning.

    --git-bin wins when given; otherwise fall back to PATH lookup. Returning

    None means no git binary was found (manifest fields stay null).

    """

    git_bin = getattr(args, "git_bin", None)

    if git_bin:

        return Path(git_bin)

    from oakbench.subjects import which_measured_git

    found = which_measured_git()

    return Path(found) if found else None

def main() -> int:

    args = parse_args()

    if args.command == "run":

        rc = run_bench(args)

        if rc != 0:

            return rc

        paths = [args.results / "latest.jsonl"]

    else:

        paths = args.input_jsonl

    return write_campaign_book(args, paths)

def run_bench(args: argparse.Namespace) -> int:

    cmd = [

        sys.executable,

        str(ROOT / "scripts" / "bench.py"),

        "--profile",

        args.profile,

        "--track",

        args.track,

        "--runs",

        str(args.runs),

        "--subjects",

        # git_aa is the same Git under a second name: each book cell's noise

        # floor comes from its own interleaved A/A (ADR-0011).

        "git,git_aa",

        "--git-modes",

        args.git_modes,

        "--randomize-subject-order",

        "--results",

        str(args.results),

        "--workdir",

        str(args.workdir),

    ]

    git_bin = resolve_git_binary(args)

    if git_bin:

        cmd.extend(["--git-bin", str(git_bin)])

    if args.skip_remote:

        cmd.append("--skip-remote")

    print("[run] " + " ".join(cmd), flush=True)

    return subprocess.run(cmd, cwd=ROOT, check=False).returncode

def write_campaign_book(args: argparse.Namespace, paths: list[Path]) -> int:

    out_dir = args.out or (ROOT / "baselines" / "git" / args.book_id)

    if out_dir.exists() and any(out_dir.iterdir()) and not args.force:

        print(f"refusing to overwrite existing baseline book directory: {out_dir}", file=sys.stderr)

        return 2

    if not args.skip_publish_gate:

        gate_rc = publish_gate.main([str(path) for path in paths])

        if gate_rc != 0:

            return gate_rc

    profile = machine_profile(ROOT)

    git_bin = resolve_git_binary(args)

    rows = iter_jsonl(paths)

    cells = cells_from_rows(

        rows,

        lane=args.lane,

        metrics=split_csv(args.metrics),

        statistics_names=split_csv(args.statistics),

        subjects=set(split_csv(args.subjects)) if args.subjects else None,

        include_subops=args.include_subops,

        bootstrap_samples=args.bootstrap_samples,

        confidence=args.confidence,

        noise_floor_pct=args.noise_floor_pct,

    )

    if not cells:

        print("no successful Git metric cells found in inputs", file=sys.stderr)

        return 1

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

    manifest = manifest_json(

        book_id=args.book_id,

        row_paths=paths,

        runner_id=runner_id(profile),

        runner_class=runner_class(profile),

        runner_profile=profile,

        git_version=git_version(git_bin),

        git_binary_sha256=sha256_file(git_bin) if git_bin is not None and git_bin.is_file() else None,

        raw_storage_keys=list(args.raw_storage_key),

        suite_hash=suite_hash(),

    )

    (out_dir / "manifest.json").write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n")

    (out_dir / "book.json").write_text(json.dumps(book_json(cells), indent=2, sort_keys=True) + "\n")

    (out_dir / "book.md").write_text(book_markdown(args.book_id, cells))

    if args.update_current:

        current = ROOT / "baselines" / "git" / "CURRENT"

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

        current.write_text(args.book_id + "\n")

    print(f"[baseline-book] {out_dir}")

    print(f"[cells] {len(cells)}")

    return 0

def git_version(git_bin: Path | None) -> str | None:

    if git_bin is None:

        return None

    return command_stdout([str(git_bin), "--version"])

def suite_hash() -> str | None:

    return command_stdout(["oak", "hash"])

def command_stdout(command: list[str]) -> str | None:

    try:

        return subprocess.check_output(command, cwd=ROOT, text=True, stderr=subprocess.DEVNULL, timeout=10).strip() or None

    except Exception:

        return None

if __name__ == "__main__":

    raise SystemExit(main())