#!/usr/bin/env python3
"""Load parquet + train a tiny conv net to predict root_q. CPU-fine."""

from __future__ import annotations

import sys
from pathlib import Path

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Subset

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

from lc0_eval import EvalRootDataset, collate_padded, scatter_policy


class TinyQ(nn.Module):
    def __init__(self, planes: int = 19):
        super().__init__()
        self.net = nn.Sequential(
            nn.Conv2d(planes, 32, 3, padding=1),
            nn.ReLU(),
            nn.Conv2d(32, 32, 3, padding=1),
            nn.ReLU(),
            nn.AdaptiveAvgPool2d(1),
            nn.Flatten(),
            nn.Linear(32, 1),
            nn.Tanh(),
        )

    def forward(self, board: torch.Tensor) -> torch.Tensor:
        return self.net(board).squeeze(-1)


def main() -> None:
    data_dir = ROOT / "data"
    ds = EvalRootDataset(data_dir, split="train", encode_board=True)
    n = min(2048, len(ds))
    loader = DataLoader(
        Subset(ds, range(n)),
        batch_size=64,
        shuffle=True,
        collate_fn=collate_padded,
        num_workers=0,
    )
    model = TinyQ()
    opt = torch.optim.Adam(model.parameters(), lr=1e-3)
    model.train()
    for epoch in range(2):
        total = 0.0
        seen = 0
        for batch in loader:
            pred = model(batch["board"])
            loss = torch.mean((pred - batch["root_q"]) ** 2)
            opt.zero_grad()
            loss.backward()
            opt.step()
            total += float(loss) * batch["root_q"].size(0)
            seen += batch["root_q"].size(0)
        print(f"epoch {epoch} mse={total / seen:.4f}")

    batch = next(iter(loader))
    q_policy = scatter_policy(batch["move_idx"], batch["q"], batch["move_mask"])
    print("dense Q policy shape", tuple(q_policy.shape), "nonzero", int((q_policy != 0).sum()))


if __name__ == "__main__":
    main()