r"""train.py — SSL masked-reconstruction pretrain, then supervised Student-t
fine-tune on TRAIN-fold labeled cells (spatial split). Run on GPU VM.
Usage: python data\models\train.py --tensors data\tensors --epochs 30
"""
from __future__ import annotations
import os, sys, argparse, pathlib
import numpy as np, torch
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
from model import AtmosIQNet, student_t_nll, ssl_masked_mse
from dataset import AtmosIQData, ssl_corrupt

def run():
    ap = argparse.ArgumentParser()
    ap.add_argument("--tensors", default="data/tensors")
    ap.add_argument("--window", type=int, default=7)
    ap.add_argument("--ssl_epochs", type=int, default=10)
    ap.add_argument("--epochs", type=int, default=30)
    ap.add_argument("--lr", type=float, default=1e-3)
    a = ap.parse_args()
    dev = "cuda" if torch.cuda.is_available() else "cpu"
    print("device:", dev)
    data = AtmosIQData(a.tensors, window=a.window, device=dev)
    net = AtmosIQNet(data.F).to(dev)
    ei, e_hat, n_hat = data.edges()
    opt = torch.optim.AdamW(net.parameters(), lr=a.lr, weight_decay=1e-4)

    # ---- SSL pretrain (all nodes, masked reconstruction) ----
    all_days = list(range(a.window-1, data.D))
    for ep in range(a.ssl_epochs):
        net.train(); np.random.shuffle(all_days); tot = 0
        for t in all_days:
            b = data.window(t); Xc, fm = ssl_corrupt(b["X"])
            out = net(Xc, ei, e_hat, n_hat, b["wu"], b["wv"], b["blh"])
            loss = ssl_masked_mse(out["recon"], b["X"][-1], fm)
            opt.zero_grad(); loss.backward(); opt.step(); tot += loss.item()
        print(f"[SSL {ep+1}/{a.ssl_epochs}] recon_mse={tot/len(all_days):.4f}")

    # ---- supervised fine-tune (Student-t NLL on TRAIN-fold labeled cells) ----
    tr_days = data.target_days(fold=0); va_days = data.target_days(fold=1)
    tr_nodes = (data.split == 0).float().unsqueeze(-1)
    va_nodes = (data.split == 1).float().unsqueeze(-1)
    best = 1e9
    for ep in range(a.epochs):
        net.train(); np.random.shuffle(tr_days); tot = 0
        for t in tr_days:
            b = data.window(t)
            out = net(b["X"], ei, e_hat, n_hat, b["wu"], b["wv"], b["blh"])
            nll = student_t_nll(out["loc"], out["log_scale"], out["log_df"], b["y"], b["m"]*tr_nodes)
            opt.zero_grad(); nll.backward(); opt.step(); tot += nll.item()
        # val
        net.eval(); vtot = 0
        with torch.no_grad():
            for t in va_days:
                b = data.window(t)
                out = net(b["X"], ei, e_hat, n_hat, b["wu"], b["wv"], b["blh"])
                vtot += student_t_nll(out["loc"], out["log_scale"], out["log_df"], b["y"], b["m"]*va_nodes).item()
        vmean = vtot/max(len(va_days),1)
        print(f"[FT {ep+1}/{a.epochs}] train_nll={tot/len(tr_days):.3f}  val_nll={vmean:.3f}")
        if vmean < best:
            best = vmean; torch.save(net.state_dict(), pathlib.Path(a.tensors).parent/"atmosiq_best.pt")
    print(f"done. best val_nll={best:.3f} -> atmosiq_best.pt")

if __name__ == "__main__": run()