r"""
train_v2.py — AtmosIQ training, faithful to SSL_ROADMAP v1.1 + MODEL_BLUEPRINT v1.1.
Three stages (SSL_ROADMAP §0 pipeline):
  pretrain  : masked-reconstruction (pre-pool, masked∧observed §2) + smoothness (§3),
              subgraph on PRUNED training graph (structural holdout §5). -> encoder ckpt
  probe     : freeze encoder, Linear(d->7), full-graph held-out R² (§7), three-branch verdict
  finetune  : LogStudentTHead (§8), Student-t NLL (horizons 0-3) + physics losses (§9, λ_phys)
Auto-config from tensors/meta.json (n_landuse, calendar dim, n_grap).
Run (GPU VM):  python data\models\train_v2.py --tensors data\tensors --stage all
"""
from __future__ import annotations
import os, sys, json, argparse, pathlib, time
import numpy as np, torch, torch.nn as nn, torch.nn.functional as F
torch.set_num_threads(os.cpu_count() or 8)
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
from model import AtmosIQNet, student_t_nll, ssl_recon_loss
from dataset_v2 import AtmosData, ssl_mask, recon_masked

def grads_finite(net):
    for p in net.parameters():
        if p.grad is not None and not torch.isfinite(p.grad).all(): return False
    return True

def build_model(meta, dev):
    n_recon=9+meta["dimsB"]+meta["dimsC_static"]+meta["dimsC_yearly"]   # A9 + B + C(static+yearly)
    cfg={"calendar_num_dim":meta["dimsD_num"],"n_recon_channels":n_recon,
         "categorical":{"land_use_class":4,"grap_stage":3,"n_landuse":meta["n_landuse"],"n_grap":meta["n_grap"]}}
    return AtmosIQNet(cfg).to(dev), cfg

def smoothness(net, b, gm, h_seq):
    """§3: ||h_seq(x) - h_seq(x+δ)||² on continuous inputs (δ small Gaussian)."""
    noisy=[{k:(v+0.1*torch.randn_like(v) if k in ("satellite","meteorology","static_num","calendar_num") else v)
            for k,v in g.items()} for g in b["groups_t"]]
    h2=net.encode(noisy, b["ei"], b["e_hat"], b["n_hat"], b["wu"], b["wv"], b["blh"], gm)
    return ((h_seq-h2)**2).mean()

def pretrain(data, net, meta, a, dev):
    opt=torch.optim.AdamW(net.parameters(), lr=a.lr, weight_decay=1e-4)
    days=[t for t in range(data.w-1, data.D)]
    for ep in range(a.ssl_epochs):
        net.train(); np.random.shuffle(days); tot=0; t0=time.time()
        used=days[:a.days_per_epoch] if a.days_per_epoch else days
        for i,t in enumerate(used):
            nodes,ei,eh,nh=data.subgraph(size=a.subgraph, fold=0)   # PRUNED training graph
            b=data.window(t,nodes,ei,eh,nh)
            gm=ssl_mask(b["groups_t"])                              # 3 modes, Group D never
            h_seq=net.encode(b["groups_t"],b["ei"],b["e_hat"],b["n_hat"],b["wu"],b["wv"],b["blh"],gm)
            recon=net.recon(h_seq)                                  # [n,T,30]
            tgt,obs=data.recon_from_groups(b["groups_t"])
            rmask=recon_masked(gm, data.RECON_GROUP).to(dev)
            L_rec=ssl_recon_loss(recon, tgt, rmask*obs)            # masked ∧ observed
            loss=L_rec
            if a.lam_smooth>0 and (i % a.smooth_every==0):
                loss=loss + a.lam_smooth*smoothness(net,b,gm,h_seq)
            opt.zero_grad()
            if not torch.isfinite(loss): continue
            loss.backward()
            if not grads_finite(net): opt.zero_grad(); continue
            torch.nn.utils.clip_grad_norm_(net.parameters(), 5.0)
            opt.step(); tot+=L_rec.item()
            if (i+1)%a.log_every==0: print(f"  [SSL {ep+1}] {i+1}/{len(used)} recon={tot/(i+1):.4f} {(time.time()-t0)/(i+1):.2f}s/it",flush=True)
        print(f"[SSL {ep+1}/{a.ssl_epochs}] recon_mse={tot/len(used):.4f} {time.time()-t0:.0f}s",flush=True)
    torch.save(net.state_dict(), pathlib.Path(a.tensors).parent/"encoder_pretrained.pt")
    print("-> encoder_pretrained.pt")

def probe(data, net, meta, a, dev):
    """§7: freeze encoder, Linear(d->7), FULL-GRAPH held-out R². Three-branch vs M1 XGBoost."""
    ck=pathlib.Path(a.tensors).parent/"encoder_pretrained.pt"
    if ck.exists(): net.load_state_dict(torch.load(ck,map_location=dev)); print("loaded encoder_pretrained.pt")
    for p in net.parameters(): p.requires_grad=False
    d=meta.get("d_model",96); lin=nn.Linear(d,7).to(dev)
    opt=torch.optim.Adam(lin.parameters(), lr=1e-2)
    all_nodes=torch.arange(data.N,device=data.store)     # native to resident store
    ei=data.ei.to(dev); eh,nh=data.e_hat.to(dev),data.n_hat.to(dev)
    tr_days=data.target_days(0)
    import time as _t
    for ep in range(a.probe_epochs):
        np.random.shuffle(tr_days); tot=0; t0=_t.time(); dd=tr_days[:a.probe_days]
        for i,t in enumerate(dd):
            b=data.window(t, all_nodes, ei, eh, nh)
            with torch.no_grad():
                z=net.encode(b["groups_t"],b["ei"],b["e_hat"],b["n_hat"],b["wu"],b["wv"],b["blh"])[:,-1]
            pred=lin(z)                                            # [N,7] (horizon-0 proxy)
            y=b["y"][:,0,:]; m=b["m"][:,0,:]*(data.split==0).float().unsqueeze(-1).to(dev)
            loss=((pred-torch.log(y.clamp_min(0)+1e-3))**2*m).sum()/m.sum().clamp_min(1)
            opt.zero_grad(); loss.backward(); opt.step(); tot+=loss.item()
            if (i+1)%10==0: print(f"  [PROBE {ep+1}] {i+1}/{len(dd)} mse={tot/(i+1):.3f} {(_t.time()-t0)/(i+1):.2f}s/it",flush=True)
        print(f"[PROBE {ep+1}/{a.probe_epochs}] {_t.time()-t0:.0f}s",flush=True)
    # full-graph held-out eval (§7): every held-out node gets a prediction
    net.eval(); ys=[];ps=[];ms=[]
    for t in data.target_days(2)[:a.probe_days]:
        b=data.window(t, all_nodes, ei, eh, nh)
        with torch.no_grad():
            z=net.encode(b["groups_t"],b["ei"],b["e_hat"],b["n_hat"],b["wu"],b["wv"],b["blh"])[:,-1]
            pred=lin(z)
        te=(data.split==2).float().unsqueeze(-1).to(dev)
        ys.append(torch.log(b["y"][:,0,:].clamp_min(0)+1e-3)); ps.append(pred); ms.append(b["m"][:,0,:]*te)
    Y=torch.cat(ys);P=torch.cat(ps);M=torch.cat(ms)
    print("\n§7 LINEAR PROBE — spatial-held-out R² per pollutant:")
    POLL=["pm2_5","pm10","no2","so2","co","o3","nh3"]
    refs=json.load(open(a.refs)) if a.refs and os.path.exists(a.refs) else {}
    for j,pn in enumerate(POLL):
        mm=M[:,j]>0
        if mm.sum()<5: print(f"  {pn}: n<5 skip"); continue
        y=Y[mm,j];p=P[mm,j]; r2=1-((y-p)**2).sum()/((y-y.mean())**2).sum()
        xg=refs.get(pn,{}).get("xgboost"); tag=f" (xgb {xg:+.2f})" if xg is not None else ""
        print(f"  {pn}: probe R²={r2.item():+.3f}{tag}")
    print("  branch: FROZEN if probe≥xgboost on PM2.5 ∧ ≥1 sparse; REFUTED if <50% gap; else INCONCLUSIVE")

def physics_losses(pred_log, b):
    """§9 fine-tune physics (ablatable): BLH-trapping + rain washout on horizon-0 PM."""
    pm=pred_log[:,0,0]                                    # log pm2_5 horizon 0
    blh=b["blh"][-1]; rain=b["groups_t"][-1]["meteorology"][:,7]   # era5_rainfall (std)
    # low BLH -> higher conc: penalize positive corr of pm with BLH (want negative)
    pm=torch.nan_to_num(pm); blh=torch.nan_to_num(blh); rain=torch.nan_to_num(rain)
    L_blh=F.relu((pm-pm.mean())*(blh-blh.mean())).mean().clamp(max=10.0)
    L_rain=F.relu((pm-pm.mean())*(rain-rain.mean())).mean().clamp(max=10.0)
    return torch.nan_to_num(L_blh+L_rain)

def finetune(data, net, meta, a, dev, ylm=None, yls=None):
    for p in net.parameters(): p.requires_grad=True    # unfreeze (probe may have frozen in --stage all)
    ck=pathlib.Path(a.tensors).parent/"encoder_pretrained.pt"
    if ck.exists(): net.load_state_dict(torch.load(ck,map_location=dev),strict=False); print("loaded pretrained encoder")
    opt=torch.optim.AdamW(net.parameters(), lr=a.lr, weight_decay=a.weight_decay)
    tr=data.target_days(0); va=data.target_days(1); bad=0
    trn=(data.split==0).float().view(-1,1,1).to(dev); van=(data.split==1).float().view(-1,1,1).to(dev)
    best=1e9
    for ep in range(a.ft_epochs):
        net.train(); np.random.shuffle(tr); tot=0; t0=time.time()
        for i,t in enumerate(tr[:a.days_per_epoch or len(tr)]):
            nodes,ei,eh,nh=data.subgraph(size=a.subgraph, fold=0)
            b=data.window(t,nodes,ei,eh,nh)
            out=net(b["groups_t"],b["ei"],b["e_hat"],b["n_hat"],b["wu"],b["wv"],b["blh"],b["comp"])
            nll=student_t_nll(out["mu"],out["log_sigma"],out["nu"],b["y"],b["m"],ylm,yls)
            phys=physics_losses(out["mu"],b) if a.lam_phys>0 else torch.tensor(0.,device=dev)
            loss=nll+a.lam_phys*phys
            opt.zero_grad()
            if not torch.isfinite(loss): continue          # forward guard
            loss.backward()
            if not grads_finite(net):                      # BACKWARD guard (the real culprit) -> skip, no NaN inject
                opt.zero_grad(); continue
            torch.nn.utils.clip_grad_norm_(net.parameters(), 5.0)
            opt.step(); tot+=nll.item()
            if (i+1)%a.log_every==0: print(f"  [FT {ep+1}] {i+1} nll={tot/(i+1):.3f} {(time.time()-t0)/(i+1):.2f}s/it",flush=True)
        # val (full graph, val nodes)
        net.eval(); vt=0; alln=torch.arange(data.N,device=data.store)
        ei_g,eh_g,nh_g=data.ei.to(dev),data.e_hat.to(dev),data.n_hat.to(dev)
        with torch.no_grad():
            for t in va[:a.val_days]:
                b=data.window(t,alln,ei_g,eh_g,nh_g)
                out=net(b["groups_t"],b["ei"],b["e_hat"],b["n_hat"],b["wu"],b["wv"],b["blh"],b["comp"])
                vt+=student_t_nll(out["mu"],out["log_sigma"],out["nu"],b["y"],b["m"]*van,ylm,yls).item()
        vm=vt/max(len(va[:a.val_days]),1); print(f"[FT {ep+1}/{a.ft_epochs}] train_nll={tot/len(tr[:a.days_per_epoch or len(tr)]):.3f} val_nll={vm:.3f} {time.time()-t0:.0f}s",flush=True)
        if vm<best: best=vm; bad=0; torch.save(net.state_dict(), pathlib.Path(a.tensors).parent/"atmosiq_best.pt")
        else:
            bad+=1
            if bad>=a.patience: print(f"early stop (no val improve for {a.patience} epochs)"); break
    print(f"done. best val_nll={best:.3f} -> atmosiq_best.pt")

def main():
    ap=argparse.ArgumentParser()
    ap.add_argument("--tensors",default="data/tensors"); ap.add_argument("--stage",default="all",
                    choices=["pretrain","probe","finetune","all"])
    ap.add_argument("--window",type=int,default=7); ap.add_argument("--subgraph",type=int,default=512)
    ap.add_argument("--ssl_epochs",type=int,default=10); ap.add_argument("--probe_epochs",type=int,default=20)
    ap.add_argument("--ft_epochs",type=int,default=30); ap.add_argument("--lr",type=float,default=5e-4)
    ap.add_argument("--lam_smooth",type=float,default=0.1); ap.add_argument("--lam_phys",type=float,default=0.1)
    ap.add_argument("--smooth_every",type=int,default=4,help="apply smoothness every k steps (speed)")
    ap.add_argument("--days_per_epoch",type=int,default=0); ap.add_argument("--log_every",type=int,default=100)
    ap.add_argument("--refs",default="data/models/refs.json")
    ap.add_argument("--probe_days",type=int,default=60,help="cap full-graph probe train/eval days (speed)")
    ap.add_argument("--val_days",type=int,default=20,help="cap finetune full-graph val days (speed)")
    ap.add_argument("--patience",type=int,default=4,help="early-stop if val_nll no improve for N epochs")
    ap.add_argument("--weight_decay",type=float,default=1e-3,help="stronger reg vs overfit")
    a=ap.parse_args()
    dev="cuda" if torch.cuda.is_available() else "cpu"; print("device:",dev)
    meta=json.load(open(pathlib.Path(a.tensors)/"meta.json"))
    print(f"config: n_landuse={meta['n_landuse']} dimsD_num={meta['dimsD_num']} n_grap={meta['n_grap']}")
    data=AtmosData(a.tensors, window=a.window, device=dev)
    nz=np.load(pathlib.Path(a.tensors)/"norm.npz")
    ylm=torch.tensor(nz["y_logmean"]).float().to(dev) if "y_logmean" in nz else None
    yls=torch.tensor(nz["y_logstd"]).float().to(dev) if "y_logstd" in nz else None
    net,cfg=build_model(meta,dev)
    print(f"model params: {sum(p.numel() for p in net.parameters()):,}")
    if a.stage in ("pretrain","all"): pretrain(data,net,meta,a,dev)
    if a.stage in ("probe","all"):    probe(data,net,meta,a,dev)
    if a.stage in ("finetune","all"): finetune(data,net,meta,a,dev,ylm,yls)

if __name__=="__main__": main()