#!/usr/bin/env python3

"""Build a committed Git Baseline Book from benchmark JSONL rows."""

from __future__ import annotations

import argparse

import json

import sys

from pathlib import Path

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

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

from oakbench.baseline_book import (  # noqa: E402

    DEFAULT_BASELINE_METRICS,

    DEFAULT_BASELINE_STATISTICS,

    book_json,

    book_markdown,

    cells_from_rows,

    iter_jsonl,

    manifest_json,

)

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__)

    parser.add_argument("jsonl", nargs="+", type=Path, help="Git-only or mixed benchmark row JSONL inputs")

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

    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")

    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("--runner-class")

    parser.add_argument("--git-version")

    parser.add_argument("--git-binary-sha256")

    parser.add_argument("--force", action="store_true", help="Overwrite an existing output directory")

    return parser.parse_args()

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

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

def main() -> int:

    args = parse_args()

    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

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

    rows = iter_jsonl(args.jsonl)

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

    cells = cells_from_rows(

        rows,

        lane=args.lane,

        metrics=split_csv(args.metrics),

        statistics_names=split_csv(args.statistics),

        subjects=subjects,

        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

    # Books must carry runner identity (ADR-0007); capture this host's profile

    # and let flags override only what the operator explicitly pins.

    profile = machine_profile(ROOT)

    manifest = manifest_json(

        book_id=args.book_id,

        row_paths=args.jsonl,

        runner_id=runner_id(profile),

        runner_class=args.runner_class or runner_class(profile),

        runner_profile=profile,

        git_version=args.git_version,

        git_binary_sha256=args.git_binary_sha256,

    )

    (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))

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

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

    return 0

if __name__ == "__main__":

    raise SystemExit(main())