#!/usr/bin/env python3

"""Run or read the focused oak-vs-git bench and emit a JSON scorecard."""

from __future__ import annotations

import argparse

import json

import subprocess

import sys

from datetime import datetime, timezone

from pathlib import Path

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

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

from oakbench.perf_loop import (  # noqa: E402

    build_scorecard,

    load_jsonl,

    scorecard_exit_code,

    write_json,

)

def parse_args() -> argparse.Namespace:

    parser = argparse.ArgumentParser(description=__doc__)

    parser.add_argument("--rows", nargs="*", type=Path, help="Existing JSONL rows to score; skips bench.py.")

    parser.add_argument("--profile", default="standard", help="bench.py profile when --rows is omitted.")

    parser.add_argument("--runs", type=int, default=None, help="bench.py --runs override.")

    parser.add_argument("--results", type=Path, default=ROOT / "results" / "perf-scorecard")

    parser.add_argument("--subjects", default="git,oak_installed", help="bench.py subjects.")

    parser.add_argument("--oak-subject", default="oak_installed", help="Oak subject to compare against git.")

    parser.add_argument("--git-subject", default="git")

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

    parser.add_argument("--oak-installed-bin", type=Path)

    parser.add_argument("--oak-local-bin", type=Path)

    parser.add_argument("--skip-remote", action="store_true", default=True)

    parser.add_argument("--include-remote", action="store_true", help="Do not pass --skip-remote to bench.py.")

    parser.add_argument("--baseline", type=Path, help="Previous scorecard JSON to diff against.")

    parser.add_argument("--write-baseline", type=Path, help="Write this scorecard as a stored baseline.")

    parser.add_argument("--output", type=Path, help="Write JSON here instead of stdout.")

    parser.add_argument("--change-threshold-pct", type=float, default=3.0)

    return parser.parse_args()

def run_bench(args: argparse.Namespace) -> list[Path]:

    bench_id = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")

    out = args.results / bench_id

    command = [

        sys.executable,

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

        "--profile",

        args.profile,

        "--subjects",

        args.subjects,

        "--randomize-subject-order",

        "--results",

        str(out),

    ]

    if args.runs is not None:

        command.extend(["--runs", str(args.runs)])

    if args.git_bin:

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

    if args.oak_installed_bin:

        command.extend(["--oak-installed-bin", str(args.oak_installed_bin)])

    if args.oak_local_bin:

        command.extend(["--oak-local-bin", str(args.oak_local_bin)])

    if args.skip_remote and not args.include_remote:

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

    proc = subprocess.run(command, cwd=ROOT, check=False)

    if proc.returncode not in (0, 1):

        raise SystemExit(f"bench.py failed to run (exit {proc.returncode})")

    latest = out / "latest.jsonl"

    if not latest.exists():

        raise SystemExit(f"bench.py did not write {latest}")

    return [latest]

def main() -> int:

    args = parse_args()

    row_paths = args.rows if args.rows else run_bench(args)

    baseline = json.loads(args.baseline.read_text()) if args.baseline else None

    scorecard = build_scorecard(

        load_jsonl(row_paths),

        oak_subject=args.oak_subject,

        git_subject=args.git_subject,

        baseline=baseline,

        change_threshold_pct=args.change_threshold_pct,

    )

    scorecard["source_rows"] = [str(path) for path in row_paths]

    if args.write_baseline:

        write_json(args.write_baseline, scorecard)

    if args.output:

        write_json(args.output, scorecard)

    else:

        print(json.dumps(scorecard, indent=2, sort_keys=True))

    return scorecard_exit_code(str(scorecard["summary"]["gate_verdict"]))

if __name__ == "__main__":

    raise SystemExit(main())