#!/usr/bin/env python3
"""Train the compact chess policy/value network on prepared arrays."""

from __future__ import annotations

import argparse
import time
from pathlib import Path

import numpy as np
import torch
from torch import nn
from torch.utils.data import DataLoader, Dataset

from model import ChessNet


class PreparedDataset(Dataset):
    def __init__(self, root: Path, split: str):
        self.planes = np.load(root / f"{split}_planes.npy", mmap_mode="r")
        self.legal = np.load(root / f"{split}_legal.npy", mmap_mode="r")
        self.move = np.load(root / f"{split}_move.npy", mmap_mode="r")
        self.value = np.load(root / f"{split}_value.npy", mmap_mode="r")
        self.wdl = np.load(root / f"{split}_wdl.npy", mmap_mode="r")

    def __len__(self):
        return len(self.move)

    def __getitem__(self, index):
        planes = np.array(self.planes[index], dtype=np.float32)
        planes[18] /= 100.0
        legal = np.unpackbits(np.array(self.legal[index], dtype=np.uint8)).astype(np.bool_)
        return (
            torch.from_numpy(planes),
            torch.from_numpy(legal),
            torch.tensor(int(self.move[index]), dtype=torch.long),
            torch.tensor(float(self.value[index]), dtype=torch.float32),
            torch.tensor(int(self.wdl[index]), dtype=torch.long),
        )


def run_epoch(model, loader, optimizer, scaler, device, train: bool):
    model.train(train)
    total_loss = 0.0
    correct1 = correct5 = total = 0
    value_abs = 0.0
    wdl_correct = 0

    for planes, legal, target, value, wdl in loader:
        planes = planes.to(device, non_blocking=True)
        legal = legal.to(device, non_blocking=True)
        target = target.to(device, non_blocking=True)
        value = value.to(device, non_blocking=True)
        wdl = wdl.to(device, non_blocking=True)

        with torch.set_grad_enabled(train):
            with torch.autocast("cuda", dtype=torch.float16, enabled=(device.type == "cuda")):
                logits, pred_value, pred_wdl = model(planes, legal)
                policy_loss = nn.functional.cross_entropy(logits.float(), target)
                value_loss = nn.functional.mse_loss(pred_value.float(), value)
                wdl_loss = nn.functional.cross_entropy(pred_wdl.float(), wdl)
                loss = policy_loss + 0.5 * value_loss + 0.25 * wdl_loss

        if train:
            scaler.scale(loss).backward()
            scaler.unscale_(optimizer)
            torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0)
            scaler.step(optimizer)
            scaler.update()
            optimizer.zero_grad(set_to_none=True)

        total_loss += float(loss.detach()) * len(target)
        with torch.no_grad():
            top5 = torch.topk(logits, 5, dim=1).indices
            correct1 += int((top5[:, 0] == target).sum())
            correct5 += int((top5 == target[:, None]).any(dim=1).sum())
            value_abs += float((pred_value.float() - value).abs().sum())
            wdl_correct += int((pred_wdl.argmax(dim=1) == wdl).sum())
            total += len(target)

    return {
        "loss": total_loss / max(total, 1),
        "top1": correct1 / max(total, 1),
        "top5": correct5 / max(total, 1),
        "value_mae": value_abs / max(total, 1),
        "wdl_acc": wdl_correct / max(total, 1),
    }


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--prepared", default="prepared")
    parser.add_argument("--epochs", type=int, default=10)
    parser.add_argument("--batch", type=int, default=256)
    parser.add_argument("--channels", type=int, default=128)
    parser.add_argument("--blocks", type=int, default=10)
    parser.add_argument("--lr", type=float, default=1e-3)
    parser.add_argument("--workers", type=int, default=4)
    parser.add_argument("--device", default="cuda")
    parser.add_argument("--out", default="checkpoints/chessnet.pt")
    parser.add_argument("--max-steps", type=int, default=0)
    args = parser.parse_args()

    device = torch.device(args.device if torch.cuda.is_available() else "cpu")
    root = Path(args.prepared)
    train_ds = PreparedDataset(root, "train")
    val_ds = PreparedDataset(root, "val")
    train_loader = DataLoader(
        train_ds, batch_size=args.batch, shuffle=True,
        num_workers=args.workers, pin_memory=True, drop_last=True,
    )
    val_loader = DataLoader(
        val_ds, batch_size=args.batch, shuffle=False,
        num_workers=args.workers, pin_memory=True,
    )

    model = ChessNet(channels=args.channels, blocks=args.blocks).to(device)
    params = sum(p.numel() for p in model.parameters())
    print(f"device={device} params={params:,} train={len(train_ds):,} val={len(val_ds):,}")

    optimizer = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=0.01)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.epochs)
    scaler = torch.amp.GradScaler("cuda", enabled=(device.type == "cuda"))

    best = -1.0
    out_path = Path(args.out)
    out_path.parent.mkdir(parents=True, exist_ok=True)

    for epoch in range(1, args.epochs + 1):
        started = time.time()
        train_stats = run_epoch(model, train_loader, optimizer, scaler, device, True)
        if args.max_steps:
            break
        val_stats = run_epoch(model, val_loader, optimizer, scaler, device, False)
        scheduler.step()
        elapsed = time.time() - started
        print(
            f"epoch {epoch:02d} {elapsed:6.1f}s | "
            f"train loss {train_stats['loss']:.3f} top1 {train_stats['top1']:.3f} | "
            f"val loss {val_stats['loss']:.3f} top1 {val_stats['top1']:.3f} "
            f"top5 {val_stats['top5']:.3f} value_mae {val_stats['value_mae']:.3f} "
            f"wdl {val_stats['wdl_acc']:.3f}",
            flush=True,
        )
        if val_stats["top1"] > best:
            best = val_stats["top1"]
            torch.save(
                {
                    "model": model.state_dict(),
                    "channels": args.channels,
                    "blocks": args.blocks,
                    "epoch": epoch,
                    "val": val_stats,
                },
                out_path,
            )

    print(f"best top1={best:.3f}; saved {out_path}")


if __name__ == "__main__":
    main()