#!/usr/bin/env python3

"""Propose-mode overnight loop for Oak perf candidates.

The script selects targets, verifies candidate branches, and writes LEDGER.md.

It never edits Oak and never merges.

"""

from __future__ import annotations

import argparse

import json

import shlex

import sys

from pathlib import Path

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

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

from oakbench.perf_loop import (  # noqa: E402

    append_ledger,

    dry_run_entry,

    evaluate_interleaved_ab,

    load_scorecard,

    parse_ledger,

    run_correctness_gate,

    run_interleaved_commands,

    select_target,

    target_key,

    verification_entry,

)

def parse_args() -> argparse.Namespace:

    parser = argparse.ArgumentParser(description=__doc__)

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

    select = sub.add_parser("select", help="Select the highest-ratio target from a scorecard.")

    select.add_argument("--scorecard", required=True, type=Path)

    select.add_argument("--ledger", type=Path, default=ROOT / "LEDGER.md")

    select.add_argument("--output", type=Path)

    dry = sub.add_parser("dry-run", help="Exercise select -> park -> ledger without editing Oak.")

    dry.add_argument("--scorecard", required=True, type=Path)

    dry.add_argument("--ledger", type=Path, default=ROOT / "LEDGER.md")

    dry.add_argument("--max-candidates", type=int, default=1)

    dry.add_argument("--stop-on-first-red", action="store_true", default=True)

    dry.add_argument("--output", type=Path)

    verify = sub.add_parser("verify", help="Verify a candidate branch in propose mode.")

    verify.add_argument("--target", required=True, type=Path, help="Selected target JSON.")

    verify.add_argument("--ledger", type=Path, default=ROOT / "LEDGER.md")

    verify.add_argument("--oak-repo", required=True, type=Path)

    verify.add_argument("--before-command", required=True, help="Shell-style command for the baseline binary.")

    verify.add_argument("--after-command", required=True, help="Shell-style command for the candidate binary.")

    verify.add_argument("--ab-cwd", required=True, type=Path, help="Same prepared fixture directory for both commands.")

    verify.add_argument("--pairs", type=int, default=20, help="A/B pairs; 20 means 40 subprocesses.")

    verify.add_argument("--min-improvement-pct", type=float, default=3.0)

    verify.add_argument("--diagnosis-file", required=True, type=Path)

    verify.add_argument("--change-summary", required=True)

    verify.add_argument("--oak-gate-verdict", default="MISSING", help="PASS only after the Oak-vs-Oak gate is green.")

    verify.add_argument("--fleet-gate-verdict", default="MISSING", help="PASS only after the fleet reliability gate is green.")

    verify.add_argument("--lever-rejected", action="append", default=[])

    verify.add_argument("--skip-correctness", action="store_true")

    verify.add_argument("--output", type=Path)

    return parser.parse_args()

def _write_optional(path: Path | None, payload: dict) -> None:

    if path:

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

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

def main() -> int:

    args = parse_args()

    if args.command == "select":

        target = select_target(load_scorecard(args.scorecard), parse_ledger(args.ledger))

        if target is None:

            print("no eligible target", file=sys.stderr)

            return 1

        _write_optional(args.output, target)

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

        return 0

    if args.command == "dry-run":

        if args.max_candidates < 1:

            raise SystemExit("--max-candidates must be >= 1")

        scorecard = load_scorecard(args.scorecard)

        if args.stop_on_first_red and scorecard.get("summary", {}).get("gate_verdict") == "regressed":

            print("scorecard is RED; stop-on-first-RED prevented candidate selection", file=sys.stderr)

            return 2

        target = select_target(scorecard, parse_ledger(args.ledger))

        if target is None:

            print("no eligible target", file=sys.stderr)

            return 1

        entry = dry_run_entry(target)

        append_ledger(args.ledger, entry)

        _write_optional(args.output, entry)

        print(f"parked dry-run candidate: {target_key(target)}")

        return 0

    if args.command == "verify":

        target = json.loads(args.target.read_text())

        if not isinstance(target, dict):

            raise SystemExit(f"{args.target}: expected target object")

        diagnosis = args.diagnosis_file.read_text() if args.diagnosis_file.exists() else ""

        correctness = run_correctness_gate(args.oak_repo, skip=args.skip_correctness)

        if correctness and all(int(row.get("returncode", 1)) == 0 for row in correctness):

            samples = run_interleaved_commands(

                shlex.split(args.before_command),

                shlex.split(args.after_command),

                cwd=args.ab_cwd,

                pairs=args.pairs,

            )

            ab_result = evaluate_interleaved_ab(samples, min_pairs=args.pairs, min_improvement_pct=args.min_improvement_pct)

        else:

            ab_result = {"passed": False, "reason": "correctness_gate_failed"}

        entry = verification_entry(

            target=target,

            diagnosis=diagnosis,

            change_summary=args.change_summary,

            correctness_results=correctness,

            ab_result=ab_result,

            oak_gate_verdict=args.oak_gate_verdict,

            fleet_gate_verdict=args.fleet_gate_verdict,

            levers_rejected=args.lever_rejected,

            propose_mode=True,

        )

        append_ledger(args.ledger, entry)

        _write_optional(args.output, entry)

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

        return 0 if entry["reason"] == "verified_propose_mode_human_review_required" else 1

    raise AssertionError(args.command)

if __name__ == "__main__":

    raise SystemExit(main())