#!/usr/bin/env python3

"""Run the mechanical checks for a public benchmark drop.

This script does not run benchmarks. It takes the JSONL files already intended

for publication and writes a small readiness bundle:

- publish_gate.txt: hard mechanical gate output

- benchmark_stats.md: bootstrap confidence intervals for the same JSONL files

- opportunities.md / opportunities.json: ranked backlog from the same results

- manifest.json: exact inputs, commands, exit codes, and generated paths

"""

from __future__ import annotations

import argparse

import contextlib

import io

import json

import subprocess

import sys

from datetime import datetime, timezone

from pathlib import Path

from typing import Any

import opportunities

import publish_gate

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

DEFAULT_RESULTS = ROOT / "results"

def parse_args(argv: list[str] | None = None) -> argparse.Namespace:

    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])

    parser.add_argument(

        "jsonl",

        nargs="*",

        type=Path,

        help="Result JSONL files to publish. Defaults to latest JSONL files in --results.",

    )

    parser.add_argument("--results", type=Path, default=DEFAULT_RESULTS)

    parser.add_argument(

        "--out-dir",

        type=Path,

        help="Directory for readiness reports. Default: <results>/public-readiness.",

    )

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

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

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

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

    return parser.parse_args(argv)

def discover_inputs(results: Path) -> list[Path]:

    candidates = [

        results / "latest.jsonl",

        results / "latest.mount.jsonl",

        results / "parallel-contention" / "latest.jsonl",

    ]

    return [path for path in candidates if path.exists()]

def write_text(path: Path, text: str) -> str:

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

    path.write_text(text)

    return str(path)

def run_publish_gate(inputs: list[Path], out_dir: Path) -> dict[str, Any]:

    buf = io.StringIO()

    with contextlib.redirect_stdout(buf):

        exit_code = publish_gate.main([str(path) for path in inputs])

    return {

        "name": "publish_gate",

        "exit_code": exit_code,

        "path": write_text(out_dir / "publish_gate.txt", buf.getvalue()),

    }

def run_benchmark_stats(

    inputs: list[Path],

    out_dir: Path,

    bootstrap_samples: int,

    confidence: float,

) -> dict[str, Any]:

    command = [

        sys.executable,

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

        *[str(path) for path in inputs],

        "--bootstrap-samples",

        str(bootstrap_samples),

        "--confidence",

        str(confidence),

    ]

    proc = subprocess.run(command, cwd=ROOT, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)

    stats_path = write_text(out_dir / "benchmark_stats.md", proc.stdout)

    stderr_path = None

    if proc.stderr:

        stderr_path = write_text(out_dir / "benchmark_stats.stderr.txt", proc.stderr)

    return {

        "name": "benchmark_stats",

        "exit_code": proc.returncode,

        "command": command,

        "path": stats_path,

        "stderr_path": stderr_path,

    }

def run_opportunities(results: Path, inputs: list[Path], out_dir: Path) -> dict[str, Any]:

    report, entries = opportunities.generate_report(results, input_paths=inputs)

    report_path = write_text(out_dir / "opportunities.md", report)

    json_path = out_dir / "opportunities.json"

    json_path.write_text(json.dumps(entries, indent=2, sort_keys=True) + "\n")

    return {

        "name": "opportunities",

        "exit_code": 0,

        "path": str(report_path),

        "json_path": str(json_path),

        "entry_count": len(entries),

    }

def main(argv: list[str] | None = None) -> int:

    args = parse_args(argv)

    results = args.results.resolve()

    out_dir = (args.out_dir or (results / "public-readiness")).resolve()

    inputs = [path.resolve() for path in (args.jsonl or discover_inputs(results))]

    if not inputs:

        print(f"No result JSONL files found. Pass files explicitly or populate {results}.")

        return 2

    checks: list[dict[str, Any]] = []

    checks.append(run_publish_gate(inputs, out_dir))

    if not args.skip_stats:

        checks.append(run_benchmark_stats(inputs, out_dir, args.bootstrap_samples, args.confidence))

    if not args.skip_opportunities:

        checks.append(run_opportunities(results, inputs, out_dir))

    manifest = {

        "generated_at": datetime.now(timezone.utc).isoformat(),

        "results_dir": str(results),

        "inputs": [str(path) for path in inputs],

        "out_dir": str(out_dir),

        "checks": checks,

        "ready": all(check["exit_code"] == 0 for check in checks),

    }

    manifest_path = out_dir / "manifest.json"

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

    print(f"Readiness bundle: {out_dir}")

    print(f"Manifest: {manifest_path}")

    for check in checks:

        status = "PASS" if check["exit_code"] == 0 else "FAIL"

        print(f"{status} {check['name']}: {check.get('path')}")

    return 0 if manifest["ready"] else 1

if __name__ == "__main__":

    raise SystemExit(main())