#!/usr/bin/env python3
from __future__ import annotations

import argparse
import json
import sys
import time
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
if str(ROOT) not in sys.path:
    sys.path.insert(0, str(ROOT))

from services.design_academy_practice_service import practice_service


def emit(payload) -> None:
    print(json.dumps(payload, indent=2))


def main() -> int:
    parser = argparse.ArgumentParser(description="SHiRE Academy practice and certification engine")
    sub = parser.add_subparsers(dest="command", required=True)

    init = sub.add_parser("initialize")
    init.add_argument("--reset", action="store_true")

    sub.add_parser("status")

    queue = sub.add_parser("queue")
    queue.add_argument("--limit", type=int, default=20)

    run_one = sub.add_parser("run-one")
    run_one.add_argument("--skill-id")

    run_batch = sub.add_parser("run-batch")
    run_batch.add_argument("--count", type=int, default=5)
    run_batch.add_argument("--cooldown", type=float, default=10.0)
    run_batch.add_argument("--stop-on-error", action="store_true")

    worker = sub.add_parser("worker")
    worker.add_argument("--cooldown", type=float, default=15.0)
    worker.add_argument("--max-skills", type=int, default=0)

    sub.add_parser("pause")
    sub.add_parser("resume")
    sub.add_parser("reconcile-index")

    args = parser.parse_args()

    if args.command == "initialize":
        emit(practice_service.initialize(reset=args.reset))
        return 0
    if args.command == "status":
        emit(practice_service.status())
        return 0
    if args.command == "queue":
        emit({"ok": True, "queue": practice_service.queue(limit=args.limit)})
        return 0
    if args.command == "run-one":
        payload = practice_service.run_one(skill_id=args.skill_id)
        emit(payload)
        return 0 if payload.get("ok") or payload.get("complete") else 1
    if args.command == "pause":
        emit(practice_service.pause())
        return 0
    if args.command == "resume":
        emit(practice_service.resume())
        return 0
    if args.command == "reconcile-index":
        emit(practice_service.reconcile_index())
        return 0

    if args.command in {"run-batch", "worker"}:
        count = args.count if args.command == "run-batch" else args.max_skills
        cooldown = max(0.0, float(args.cooldown))
        completed = 0
        failures = 0
        while count <= 0 or completed < count:
            status = practice_service.status()
            if status.get("paused"):
                emit({"ok": True, "paused": True, "completed": completed, "status": status})
                return 0
            payload = practice_service.run_one()
            emit(payload)
            if payload.get("complete"):
                break
            completed += 1
            if not payload.get("ok"):
                failures += 1
                if args.command == "run-batch" and args.stop_on_error:
                    return 1
            if cooldown:
                time.sleep(cooldown)
        final = {
            "ok": failures == 0,
            "completed_this_run": completed,
            "failures_this_run": failures,
            "status": practice_service.status(),
        }
        emit(final)
        return 0 if failures == 0 else 1

    return 2


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