"""``explicit-smoke`` — honest CPU contract smoke and GPU-launch admission."""

from __future__ import annotations

import argparse
import json
import sys
from pathlib import Path

from ..training.data import AdmissionError
from ..training.launcher import check_launcher_environment
from ..training.ledger import LedgerError
from ..training.offline import offline_contract_smoke


def _offline(args: argparse.Namespace) -> int:
    try:
        summary = offline_contract_smoke(
            steps_per_arm=args.steps_per_arm,
            seed=args.seed,
            token_cap=args.token_cap,
        )
    except (AdmissionError, LedgerError, ValueError) as exc:
        print(f"OFFLINE SMOKE FAILED: {exc}", file=sys.stderr)
        return 1
    summary["requested_smoke"] = args.command
    print(json.dumps(summary, sort_keys=True))
    return 0


def _gpu_check(args: argparse.Namespace) -> int:
    if not args.config:
        print(
            f"{args.command} BLOCKED: choose --offline or provide at least one --config",
            file=sys.stderr,
        )
        return 2
    results = []
    ok = True
    for path in args.config:
        check = check_launcher_environment(path)
        ok = ok and check.ok
        results.append(
            {
                "config": str(path),
                "ok": check.ok,
                "errors": check.errors,
                "warnings": check.warnings,
            }
        )
    print(
        json.dumps(
            {
                "mode": "gpu_launch_admission",
                "trained": False,
                "ok": ok,
                "results": results,
            },
            sort_keys=True,
        )
    )
    return 0 if ok else 2


def cmd_smoke(args: argparse.Namespace) -> int:
    return _offline(args) if args.offline else _gpu_check(args)


def _add_common(parser: argparse.ArgumentParser, *, default_steps: int) -> None:
    parser.add_argument("--offline", action="store_true")
    parser.add_argument("--config", type=Path, action="append")
    parser.add_argument("--steps-per-arm", type=int, default=default_steps)
    parser.add_argument("--seed", type=int, default=20260728)
    parser.add_argument("--token-cap", type=int, default=24_000_000)
    parser.set_defaults(func=cmd_smoke)


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(prog="explicit-smoke")
    sub = parser.add_subparsers(dest="command", required=True)
    compatibility = sub.add_parser(
        "compatibility", help="Offline contracts or frozen GPU-plan admission."
    )
    _add_common(compatibility, default_steps=1)
    common = sub.add_parser(
        "common-smoke",
        help="Short CPU all-arm contract smoke; this does not train.",
    )
    _add_common(common, default_steps=5)
    return parser


def main(argv: list[str] | None = None) -> int:
    if argv == []:
        build_parser().print_usage(sys.stderr)
        return 2
    args = build_parser().parse_args(argv)
    return int(args.func(args))


if __name__ == "__main__":
    raise SystemExit(main())