#!/usr/bin/env python3
"""Train or resume the Cuphead YOLO26 detector with safe 4090 defaults."""

from __future__ import annotations

import argparse
import json
import platform
import sys
from datetime import datetime, timezone
from pathlib import Path

import torch
import ultralytics
from ultralytics import YOLO


def batch_value(text: str) -> int | float:
    if "." in text:
        value = float(text)
        if not 0 < value <= 1:
            raise argparse.ArgumentTypeError("fractional --batch must be in (0,1]")
        return value
    value = int(text)
    if value == 0 or value < -1:
        raise argparse.ArgumentTypeError("integer --batch must be -1 or positive")
    return value


def check_gpu(device: str, min_free_gib: float) -> list[dict]:
    if device.lower() == "cpu":
        return []
    if not torch.cuda.is_available():
        raise SystemExit("CUDA is not available; check NVIDIA driver and PyTorch CUDA wheel")
    gpu_rows = []
    for token in device.split(","):
        index = int(token)
        with torch.cuda.device(index):
            free_bytes, total_bytes = torch.cuda.mem_get_info()
        row = {
            "index": index,
            "name": torch.cuda.get_device_name(index),
            "free_gib": free_bytes / 2**30,
            "total_gib": total_bytes / 2**30,
        }
        gpu_rows.append(row)
        print(
            f"GPU {index}: {row['name']} free={row['free_gib']:.2f} GiB "
            f"total={row['total_gib']:.2f} GiB"
        )
        if row["free_gib"] < min_free_gib:
            raise SystemExit(
                f"GPU {index} has only {row['free_gib']:.2f} GiB free; "
                f"need at least {min_free_gib:.2f} GiB"
            )
    return gpu_rows


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--model", type=Path, default=Path("models/yolo26s.pt"))
    parser.add_argument("--data", type=Path, required=True)
    parser.add_argument("--project", type=Path, default=Path("runs"))
    parser.add_argument("--name", default="yolo26s_960_cuphead_v2")
    parser.add_argument("--device", default="0")
    parser.add_argument("--epochs", type=int, default=150)
    parser.add_argument("--imgsz", type=int, default=960)
    parser.add_argument("--batch", type=batch_value, default=-1)
    parser.add_argument("--workers", type=int, default=8)
    parser.add_argument("--patience", type=int, default=30)
    parser.add_argument("--cache", choices=("false", "ram", "disk"), default="false")
    parser.add_argument("--save-period", type=int, default=10)
    parser.add_argument("--seed", type=int, default=33)
    parser.add_argument("--min-free-gib", type=float, default=18.0)
    parser.add_argument(
        "--resume",
        type=Path,
        help="path to last.pt; restores optimizer/scheduler/epoch and ignores --model",
    )
    args = parser.parse_args()

    data = args.data.expanduser().resolve()
    if not data.is_file():
        raise SystemExit(f"data YAML not found: {data}")
    checkpoint = (args.resume or args.model).expanduser().resolve()
    if not checkpoint.is_file():
        raise SystemExit(f"checkpoint not found: {checkpoint}")
    gpu_rows = check_gpu(args.device, args.min_free_gib)
    args.project.mkdir(parents=True, exist_ok=True)

    run_dir = (args.project / args.name).resolve()
    if not args.resume and run_dir.exists():
        raise SystemExit(f"run directory already exists; choose another --name: {run_dir}")
    metadata = {
        "started_at_utc": datetime.now(timezone.utc).isoformat(),
        "command": sys.argv,
        "python": sys.version,
        "platform": platform.platform(),
        "torch": torch.__version__,
        "torch_cuda": torch.version.cuda,
        "ultralytics": ultralytics.__version__,
        "gpus": gpu_rows,
        "model": str(checkpoint),
        "data": str(data),
        "settings": vars(args) | {"model": str(args.model), "data": str(args.data), "project": str(args.project), "resume": str(args.resume) if args.resume else None},
    }
    model = YOLO(str(checkpoint))
    if args.resume:
        result = model.train(resume=True, device=args.device, workers=args.workers)
    else:
        result = model.train(
            data=str(data),
            epochs=args.epochs,
            imgsz=args.imgsz,
            batch=args.batch,
            device=args.device,
            workers=args.workers,
            patience=args.patience,
            project=str(args.project.resolve()),
            name=args.name,
            exist_ok=False,
            seed=args.seed,
            deterministic=True,
            pretrained=True,
            optimizer="auto",
            close_mosaic=10,
            cache=False if args.cache == "false" else args.cache,
            save_period=args.save_period,
            amp=True,
            plots=True,
            verbose=True,
        )
    save_dir = Path(result.save_dir)
    (save_dir / "launch_metadata.json").write_text(
        json.dumps(metadata, ensure_ascii=False, indent=2, default=str) + "\n",
        encoding="utf-8",
    )
    best = save_dir / "weights" / "best.pt"
    last = save_dir / "weights" / "last.pt"
    if not best.is_file() or not last.is_file():
        raise SystemExit(f"training finished without expected checkpoints under {save_dir / 'weights'}")
    print(f"BEST_CHECKPOINT={best.resolve()}")
    print(f"RESUME_CHECKPOINT={last.resolve()}")


if __name__ == "__main__":
    main()