"""Student-semester episodes; immutable training-only normalization and grade banks."""
from __future__ import annotations
import collections,dataclasses,time,random
import numpy as np
import pandas as pd
import torch
from torch.utils.data import DataLoader
from suite28_data import Rows,CourseBank,fit_preprocessor,apply_preprocessor

@dataclasses.dataclass
class Prepared:
    x:np.ndarray; meta:np.ndarray; cid:np.ndarray; counts:np.ndarray
    y:np.ndarray; grade:np.ndarray; fac:np.ndarray; sem:np.ndarray; student:np.ndarray
    result_index:np.ndarray; update:np.ndarray
    faculty_names:list[str]
    def __len__(self):return len(self.y)

def prepare(train:Rows,query:Rows|None=None,processor=None,course_bank=None,fit=False):
    if fit:
        processor=fit_preprocessor(train);course_bank=CourseBank(train)
    assert processor is not None and course_bank is not None
    stacks=[]
    for part,rows in enumerate((train,query)):
        if rows is None:continue
        x,s=apply_preprocessor(rows,processor)
        # Prior-semester statistics replace cached course-history fields (which may have been computed globally).
        h,cnt,cid=course_bank.query(rows)
        h_scaled=np.stack([np.log1p(h[:,0])/8.,h[:,1]/10.,h[:,2]/5.,h[:,3],h[:,4]],axis=1).astype(np.float32)
        course=np.concatenate([s,np.clip(h_scaled,0,3),np.log1p(cnt)[:,None]/10.],axis=-1)
        assert course.shape[1]==30
        stacks.append((x,course,cid,cnt,np.asarray(rows.y if part==0 else np.zeros(len(rows)),np.float32),np.asarray(rows.grade if part==0 else np.full(len(rows),np.nan),np.float32),rows.faculty,rows.semester,rows.student,
                       np.full(len(rows),-1,np.int64) if part==0 else np.arange(len(rows),dtype=np.int64),np.full(len(rows),part==0,bool)))
    args=[np.concatenate([a[i] for a in stacks]) for i in range(len(stacks[0]))]
    return Prepared(*args,faculty_names=list(train.faculty_names)),processor,course_bank

def episodes(prep:Prepared):
    groups=collections.defaultdict(lambda:collections.defaultdict(list))
    for i,(f,s,t) in enumerate(zip(prep.fac,prep.student,prep.sem)):
        groups[(int(f),str(s))][int(t)].append(i)
    ep=[];counts=[]
    for (faculty,_),v in groups.items():
        ordered=sorted(v.items());ep.append(ordered);counts.append(faculty)
    return ep,np.asarray(counts,np.int16)

class EpisodeCollator:
    def __init__(self,prep):self.d=prep
    def __call__(self,episodes):
        d=self.d;B=len(episodes);T=max(len(z) for z in episodes);M=max(len(ids) for z in episodes for _,ids in z);C=d.x.shape[1]
        arr={
          'context':np.zeros((B,T,C),np.float32), 'course_meta':np.zeros((B,T,M,30),np.float32),
          'course_id':np.zeros((B,T,M),np.int64), 'course_count':np.zeros((B,T,M),np.float32),
          'label':np.zeros((B,T,M),np.float32),'grade':np.full((B,T,M),np.nan,np.float32),
          'mask':np.zeros((B,T,M),bool),'update':np.zeros((B,T,M),bool),
          'faculty':np.zeros((B,T),np.int64),'semester':np.zeros((B,T),np.float32),
          'term_valid':np.zeros((B,T),bool),'result_index':np.full((B,T,M),-1,np.int64)}
        for b,episode in enumerate(episodes):
            for t,(sem,ids) in enumerate(episode):
                ix=np.asarray(ids,dtype=int);r=d.x[ix];v=np.max(np.abs(r-r[:1]),axis=0)
                if np.any(v>1e-2):
                    raise ValueError(f'Student-semester context not shared, maxdiff={float(v.max())}, semester={sem}')
                n=len(ix);arr['context'][b,t]=r[0];arr['course_meta'][b,t,:n]=d.meta[ix]
                arr['course_id'][b,t,:n]=d.cid[ix];arr['course_count'][b,t,:n]=d.counts[ix]
                arr['label'][b,t,:n]=d.y[ix];arr['grade'][b,t,:n]=d.grade[ix]
                arr['mask'][b,t,:n]=True;arr['update'][b,t,:n]=d.update[ix]
                arr['faculty'][b,t]=int(d.fac[ix[0]]);arr['semester'][b,t]=float(sem)
                arr['term_valid'][b,t]=True;arr['result_index'][b,t,:n]=d.result_index[ix]
        return {k:torch.as_tensor(v) for k,v in arr.items()}

def batches(prep,batch_students=48,seed=42,shuffle=False,balanced=False):
    ep,fi=episodes(prep);rng=np.random.default_rng(seed);order=np.arange(len(ep))
    if shuffle:
        if balanced:
            available=np.unique(fi);drawn=[]
            by={f:np.flatnonzero(fi==f) for f in available}
            for _ in range(len(ep)):
                f=int(rng.choice(available));drawn.append(int(rng.choice(by[f])))
            order=np.asarray(drawn,int)
        else:rng.shuffle(order)
    collate=EpisodeCollator(prep)
    for start in range(0,len(order),batch_students):yield collate([ep[i] for i in order[start:start+batch_students]])

def device_batch(batch,device):return {k:v.to(device,non_blocking=True) for k,v in batch.items()}

def evaluate_model(model,prep,batch_students=64,device='cpu',draws_eval=True,intervention=None,debug=False,return_row_debug=False):
    model.eval();scores=np.full(int(np.sum(prep.result_index>=0)),np.nan,np.float32)
    rows=[];support=[];count=0
    row_debug={k:np.full(len(scores),np.nan,np.float32) for k in ['projected_variance','history_count','mu_norm','cov_trace','retention']+[f'gradebin_{i}' for i in range(6)]} if return_row_debug else None
    with torch.no_grad():
        for bt in batches(prep,batch_students=batch_students):
            batch=device_batch(bt,device)
            _,outputs,d=model(batch,eval_draws=draws_eval,intervention=intervention,return_debug=debug)
            for t,p,ix,mask,extra in outputs:
                valid=mask&(ix>=0)
                ids=ix[valid].detach().cpu().numpy();v=p[valid].detach().cpu().numpy()
                if len(ids):
                    scores[ids]=v
                    if row_debug is not None:
                        for k,z in extra.items():row_debug[k][ids]=z[valid].detach().cpu().numpy()
            if debug:
                for k,z in d.items():
                    if z:rows.extend([])
                # Compact batch-level geometry averages, not huge per-row tensors.
                for k,z in d.items():
                    if z:
                        val=torch.cat([v.reshape(-1,*v.shape[1:]) for v in z],0).float()
                        if k=='cov_eigs':
                            support.append({'cov_min':float(val.min().item()),'cov_max':float(val.max().item()),'cov_mean':float(val.mean().item())})
                        elif k in ('updates','rho','fisher_trace'):
                            support.append({f'{k}_abs_mean':float(val.abs().mean().item())})
            count+=1
    if not np.isfinite(scores).all():
        raise RuntimeError(f'Prediction coverage incomplete: {np.sum(~np.isfinite(scores))}/{len(scores)}')
    return (scores,support,row_debug) if return_row_debug else (scores,support)

def train_epoch(model,prep,optimizer,device='cpu',batch_students=48,seed=42,max_steps=None,clip=1.0):
    model.train();tot=0.;steps=0;start=time.time();grad_stats={}
    for bt in batches(prep,batch_students=batch_students,seed=seed,shuffle=True,balanced=True):
        batch=device_batch(bt,device);optimizer.zero_grad(set_to_none=True)
        loss,_,_=model(batch)
        if not torch.isfinite(loss):raise ValueError('Nonfinite training likelihood')
        loss.backward()
        names={'context':'context.0.weight','course_meta':'course.meta.0.weight','course_id':'course.id.weight',
               'retention':'rho_logit','grade_threshold':'ord_raw'}
        pars=dict(model.named_parameters())
        grad_stats={k:float(pars[v].grad.detach().norm().item()) if pars[v].grad is not None else 0. for k,v in names.items()}
        torch.nn.utils.clip_grad_norm_(model.parameters(),clip);optimizer.step()
        tot+=float(loss.item());steps+=1
        if max_steps and steps>=max_steps:break
    return {'total_loss':tot/max(steps,1),'steps':steps,'sec':time.time()-start,'last_batch_grad_norms':grad_stats}
