#!/usr/bin/env python3
"""Tiny helper workflow for GPT 5.4 mini provenance.

This wraps mini_guardrail.py into a shorter 3-command path:
1. start   -> create the record
2. receipt -> store accepted child run receipt
3. ready   -> capture exact child output and verify it
"""

from __future__ import annotations

import argparse
import subprocess
import sys
from pathlib import Path

GUARDRAIL = Path("/home/isthekid/.openclaw/workspace/bin/mini_guardrail.py")
PYTHON = sys.executable or "python3"


def run_guardrail(args: list[str]) -> int:
    cmd = [PYTHON, str(GUARDRAIL), *args]
    proc = subprocess.run(cmd)
    return proc.returncode


def cmd_start(args: argparse.Namespace) -> int:
    cmd = [
        "init",
        "--slug", args.slug,
        "--task-kind", args.task_kind,
        "--requested-by", args.requested_by,
        "--require-model", args.require_model,
    ]
    if args.note:
        cmd += ["--note", args.note]
    if args.force:
        cmd.append("--force")
    return run_guardrail(cmd)


def cmd_receipt(args: argparse.Namespace) -> int:
    cmd = [
        "claim-child",
        "--slug", args.slug,
        "--child-session-key", args.child_session_key,
        "--run-id", args.run_id,
        "--requested-model", args.requested_model,
    ]
    if args.model_applied:
        cmd.append("--model-applied")
    return run_guardrail(cmd)


def cmd_capture(args: argparse.Namespace) -> int:
    cmd = [
        "capture-draft",
        "--slug", args.slug,
        "--draft-file", args.draft_file,
        "--source", args.source,
        "--model", args.model,
        "--format", args.format,
    ]
    return run_guardrail(cmd)


def cmd_verify(args: argparse.Namespace) -> int:
    cmd = ["verify", "--slug", args.slug]
    if args.require_model:
        cmd += ["--require-model", args.require_model]
    return run_guardrail(cmd)


def cmd_ready(args: argparse.Namespace) -> int:
    capture_rc = cmd_capture(args)
    if capture_rc != 0:
        return capture_rc
    return cmd_verify(args)


def cmd_show(args: argparse.Namespace) -> int:
    return run_guardrail(["show", "--slug", args.slug])


def build_parser() -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(description="Tiny helper for GPT 5.4 mini provenance workflow")
    sub = p.add_subparsers(dest="cmd", required=True)

    p_start = sub.add_parser("start", help="Create the mini-only task record")
    p_start.add_argument("slug")
    p_start.add_argument("--task-kind", default="email-draft")
    p_start.add_argument("--requested-by", default="Adner")
    p_start.add_argument("--require-model", default="gpt-mini")
    p_start.add_argument("--note")
    p_start.add_argument("--force", action="store_true")
    p_start.set_defaults(func=cmd_start)

    p_receipt = sub.add_parser("receipt", help="Store the accepted mini child receipt")
    p_receipt.add_argument("slug")
    p_receipt.add_argument("child_session_key")
    p_receipt.add_argument("run_id")
    p_receipt.add_argument("--requested-model", default="gpt-mini")
    p_receipt.add_argument("--model-applied", action="store_true", default=True)
    p_receipt.set_defaults(func=cmd_receipt)

    p_capture = sub.add_parser("capture", help="Capture exact child output into guardrail storage")
    p_capture.add_argument("slug")
    p_capture.add_argument("draft_file")
    p_capture.add_argument("--source", default="child", choices=["child", "parent", "manual"])
    p_capture.add_argument("--model", default="gpt-mini")
    p_capture.add_argument("--format", default="text", choices=["text", "json"])
    p_capture.set_defaults(func=cmd_capture)

    p_verify = sub.add_parser("verify", help="Verify the task before send")
    p_verify.add_argument("slug")
    p_verify.add_argument("--require-model")
    p_verify.set_defaults(func=cmd_verify)

    p_ready = sub.add_parser("ready", help="Capture exact child output, then verify immediately")
    p_ready.add_argument("slug")
    p_ready.add_argument("draft_file")
    p_ready.add_argument("--source", default="child", choices=["child", "parent", "manual"])
    p_ready.add_argument("--model", default="gpt-mini")
    p_ready.add_argument("--format", default="text", choices=["text", "json"])
    p_ready.add_argument("--require-model")
    p_ready.set_defaults(func=cmd_ready)

    p_show = sub.add_parser("show", help="Print the stored record")
    p_show.add_argument("slug")
    p_show.set_defaults(func=cmd_show)

    return p


def main() -> None:
    parser = build_parser()
    args = parser.parse_args()
    rc = args.func(args)
    raise SystemExit(rc)


if __name__ == "__main__":
    main()