# -*- coding: utf-8 -*-
from __future__ import annotations
import argparse,copy,gc,time
from pathlib import Path
import joblib
import numpy as np
import pandas as pd
import torch
import torch.nn.functional as F
from torch.utils.data import DataLoader,WeightedRandomSampler

from suite25_common import *
from suite25_data import *
from suite25_retrieval import *
from suite25_model import StructureAwareChronologicalRetrieval
from suite25_reporting import *

VARIANTS=[('mlp','suite25_mlp'),('tabr','suite25_tabr'),('sacr','suite25_sacr')]


def move_batch(batch,device):return {k:(v.to(device,non_blocking=True) if torch.is_tensor(v) else v) for k,v in batch.items()}

def pairwise_rank_loss(logits,y,faculty,max_pairs=2048):
    losses=[]
    for f in torch.unique(faculty):
        m=faculty==f;pos=torch.where(m&(y>0.5))[0];neg=torch.where(m&(y<=0.5))[0]
        if not len(pos) or not len(neg):continue
        n=min(max_pairs,max(len(pos),len(neg))*4);ip=pos[torch.randint(len(pos),(n,),device=logits.device)];ineg=neg[torch.randint(len(neg),(n,),device=logits.device)];losses.append(F.softplus(-(logits[ip]-logits[ineg])).mean())
    return torch.stack(losses).mean() if losses else logits.sum()*0

def train_epoch(model,loader,opt,device,args):
    model.train();tot=0.;n=0.;db=0.;dr=0.
    for batch in loader:
        b=move_batch(batch,device);opt.zero_grad(set_to_none=True);z=model(b);y=b['y'];bce=F.binary_cross_entropy_with_logits(z,y);rank=pairwise_rank_loss(z,y,b['faculty_idx']);loss=bce+args.rank_weight*rank;loss.backward();torch.nn.utils.clip_grad_norm_(model.parameters(),args.grad_clip);opt.step();bs=len(z);tot+=float(loss.detach())*bs;db+=float(bce.detach())*bs;dr+=float(rank.detach())*bs;n+=bs
    return tot/max(n,1),db/max(n,1),dr/max(n,1)

@torch.no_grad()
def predict_model(model,dataset,device,batch_size=512,ablate=None,return_aux=False,context_override=None):
    model.eval();loader=DataLoader(dataset,batch_size=batch_size,shuffle=False,num_workers=0,pin_memory=True);p=[];idx=[];auxs=[]
    for batch in loader:
        b=move_batch(batch,device);z,a=model(b,return_aux=True,ablate=ablate,context_override=context_override);p.append(torch.sigmoid(z).cpu().numpy());idx.append(batch['bundle_index'].numpy())
        if return_aux:auxs.append({k:v.detach().cpu() for k,v in a.items() if torch.is_tensor(v)})
    p=np.concatenate(p) if p else np.zeros(0);idx=np.concatenate(idx) if idx else np.zeros(0,int)
    if not return_aux:return p,idx
    merged={k:torch.cat([a[k] for a in auxs],0).numpy() for k in auxs[0]} if auxs else {};return p,idx,merged

def validation_metrics(bundle,mask,score):
    aps=[];f2=[];br=[]
    for fi in range(len(bundle.faculty_names)):
        m=np.asarray(mask)&(bundle.faculty_idx==fi)
        if not m.any():continue
        aps.append(safe_ap(bundle.y[m],score[m]));md=metric_dict(bundle.y[m],score[m]);f2.append(md['fbeta_at_20']);br.append(md['brier'])
    return float(np.nanmean(aps)),float(np.nanmean(f2)),float(np.nanmean(br))

def make_model(variant,n_features,n_faculties,args):
    return StructureAwareChronologicalRetrieval(n_features,n_faculties,variant,args.d_main,args.key_dim,args.faculty_dim,args.encoder_blocks,args.predictor_blocks,args.dropout,args.context_dropout,args.context_size,args.pool_context)

def make_loader(query,bank,store,indices,args,weighted=True,bank_y_override=None):
    ds=RetrievalDataset(query,bank,store,indices,bank_y_override)
    if not weighted:return DataLoader(ds,batch_size=args.batch_size,shuffle=False,num_workers=0,pin_memory=True)
    idx=np.asarray(indices,np.int64);weights=faculty_sampling_weights(query.faculty_idx[idx],len(query.faculty_names));ns=min(args.samples_per_epoch,len(idx)) if args.samples_per_epoch>0 else len(idx);sampler=WeightedRandomSampler(torch.as_tensor(weights,dtype=torch.double),num_samples=max(ns,1),replacement=True);return DataLoader(ds,batch_size=args.batch_size,sampler=sampler,num_workers=0,pin_memory=True)

def selection_train(variant,query,bank,store,tr_mask,va_mask,args,device,seed):
    tr_idx=np.where(tr_mask)[0];va_idx=np.where(va_mask)[0];set_seed(seed);model=make_model(variant,query.current.shape[1],len(query.faculty_names),args).to(device);opt=torch.optim.AdamW(model.parameters(),lr=args.lr,weight_decay=args.weight_decay);loader=make_loader(query,bank,None if variant=='mlp' else store,tr_idx,args,True);vds=RetrievalDataset(query,bank,None if variant=='mlp' else store,va_idx);best=None;bad=0;hist=[]
    for ep in range(1,args.max_epochs+1):
        loss,bce,rank=train_epoch(model,loader,opt,device,args);pv,ii=predict_model(model,vds,device,args.eval_batch_size);full=np.full(len(query.y),np.nan);full[ii]=pv;ap,f2,br=validation_metrics(query,va_mask,full);key=(ap,f2,-br);row={'epoch':ep,'loss':loss,'bce':bce,'rank':rank,'macro_ap':ap,'macro_f2_at20':f2,'brier':br};hist.append(row)
        if best is None or key>best['key']:best={'key':key,'epoch':ep,'state':copy.deepcopy({k:v.detach().cpu() for k,v in model.state_dict().items()}),'val_score':full.copy()};bad=0
        elif ep>=args.min_epochs:bad+=1
        print(f'[SELECT {variant.upper()}] epoch={ep:02d}/{args.max_epochs} loss={loss:.5f} BCE={bce:.5f} rank={rank:.5f} macroAP={ap:.4f} F2@20={f2:.4f} Brier={br:.4f} best={best["epoch"]:02d}')
        if ep>=args.min_epochs and bad>=args.patience:break
    model.load_state_dict(best['state']);best['history']=hist;return best

def refit_predict(variant,query,bank,store,target,target_store,epochs,args,device,seed,return_aux=False):
    idx=np.arange(len(query));set_seed(seed);model=make_model(variant,query.current.shape[1],len(query.faculty_names),args).to(device);opt=torch.optim.AdamW(model.parameters(),lr=args.lr,weight_decay=args.weight_decay);loader=make_loader(query,bank,None if variant=='mlp' else store,idx,args,True)
    for ep in range(1,int(epochs)+1):
        loss,bce,rank=train_epoch(model,loader,opt,device,args)
        if ep==1 or ep==epochs:print(f'[REFIT {variant.upper()}] epoch={ep:02d}/{epochs} loss={loss:.5f} BCE={bce:.5f} rank={rank:.5f}')
    ds=RetrievalDataset(target,bank,None if variant=='mlp' else target_store);res=predict_model(model,ds,device,args.eval_batch_size,return_aux=return_aux);return model,res

def policy_masks(bundle,val_mask):
    cal=np.zeros(len(bundle.y),bool);pol=np.zeros(len(bundle.y),bool)
    for fi in range(len(bundle.faculty_names)):
        m=np.asarray(val_mask)&(bundle.faculty_idx==fi);blocks=sorted(pd.unique(bundle.blocks[m]));
        if not blocks:continue
        if len(blocks)==1:cal[m]=True;pol[m]=True
        else:pol[m&(bundle.blocks==blocks[-1])]=True;cal[m&np.isin(bundle.blocks,blocks[:-1])]=True
    return cal,pol

def select_blend(bundle,pol,primary,alpha_grid):
    best=None;rows=[]
    for a in alpha_grid:
        p=np.full(len(bundle.y),np.nan);p[pol]=blend_logits(bundle.committee[pol],primary[pol],a);ap,f2,br=validation_metrics(bundle,pol,p);row={'alpha':float(a),'policy_macro_ap':ap,'policy_macro_f2':f2,'policy_brier':br};rows.append(row);key=(ap,f2,-float(a))
        if best is None or key>best[0]:best=(key,row)
    return best[1],pd.DataFrame(rows)

def build_phase_store(rel_index,bank,query,prep,args,label):
    print(f'[RETRIEVAL INDEX] building {label}: bank={len(bank):,} query={len(query):,} PCA={prep.pca.n_components_}')
    bc=prep.coarse(bank);qc=prep.coarse(query);return materialize_retrieval_store(rel_index,bank,query,bc,qc,args.student_pool,args.course_pool,args.struct_pool,args.state_pool,args.struct_courses,args.struct_per_course,args.max_candidates,args.retrieval_progress_every)

def ablation_rows_for_fold(fold,model,target,bank,store,base_score,calibration,device,args):
    rows=[];a,b=calibration;ds=RetrievalDataset(target,bank,store)
    for mode in ['no_retrieval','no_labels','no_student_pool','no_same_course_pool','no_structural_pool','no_state_pool','no_relation_meta','fixed_pool_gates']:
        p,ii=predict_model(model,ds,device,args.eval_batch_size,ablate=[mode]);score=apply_platt(p,a,b);full=np.full(len(target.y),np.nan);full[ii]=score
        for fi,fac in enumerate(target.faculty_names):
            m=target.faculty_idx==fi;rows.append({'fold':fold,'faculty':fac,'ablation':mode,'delta_ap':safe_ap(target.y[m],full[m])-safe_ap(target.y[m],base_score[m]),'mean_abs_probability_change':float(np.mean(np.abs(full[m]-base_score[m])))})
    return rows

def label_shuffle_rows_for_fold(fold,model,target,bank,store,base_score,calibration,device,args):
    sy=shuffled_bank_labels(bank,args.seed+fold*991);ds=RetrievalDataset(target,bank,store,bank_y_override=sy);p,ii=predict_model(model,ds,device,args.eval_batch_size);full=np.full(len(target.y),np.nan);full[ii]=apply_platt(p,*calibration);rows=[]
    for fi,fac in enumerate(target.faculty_names):
        m=target.faculty_idx==fi;rows.append({'fold':fold,'faculty':fac,'delta_ap':safe_ap(target.y[m],full[m])-safe_ap(target.y[m],base_score[m]),'mean_abs_probability_change':float(np.mean(np.abs(full[m]-base_score[m])))})
    return rows

def retrieval_diag_rows(fold,target,bank,store,aux):
    att=np.asarray(aux['candidate_attention'],float);pg=np.asarray(aux['pool_gate'],float);mask=store.candidate_idx>=0;safe=np.where(mask,store.candidate_idx,0);cy=np.asarray(bank.y,int)[safe];rows=[]
    for fi,fac in enumerate(target.faculty_names):
        m=target.faculty_idx==fi;ifm=np.where(m)[0]
        if not len(ifm):continue
        aa=att[m];yy=target.y[m];context_fail=(aa*cy[m]).sum(1);den=aa.sum(1);context_fail=np.divide(context_fail,den,out=np.zeros_like(context_fail),where=den>1e-8);top=np.argmax(aa,1);toplab=cy[m][np.arange(len(ifm)),top];weighted_rec=(aa*store.recency[m]).sum(1);cross=(aa*(1-store.same_faculty[m])).sum(1)
        row={'fold':fold,'faculty':fac,'rows':int(m.sum()),'bank_prevalence':float(bank.y.mean()),'weighted_neighbor_fail_rate':float(context_fail.mean()),'weighted_neighbor_fail_rate_for_failures':float(context_fail[yy==1].mean()) if np.any(yy==1) else np.nan,'weighted_neighbor_fail_rate_for_normals':float(context_fail[yy==0].mean()) if np.any(yy==0) else np.nan,'neighbor_label_lift':float(context_fail.mean()-bank.y.mean()),'top1_label_agreement':float(np.mean(toplab==yy)),'attention_top1_mean':float(np.max(aa,1).mean()),'cross_faculty_attention_mass':float(cross.mean()),'weighted_recency':float(weighted_rec.mean())}
        for p,name in enumerate(POOL_NAMES):row[f'gate_{name}']=float(pg[m,p].mean())
        rows.append(row)
    return rows

def relation_attention_rows(fold,target,store,aux):
    att=np.asarray(aux['candidate_attention'],float);rows=[]
    for code in range(14):
        m=(store.relation_code==code)&(store.candidate_idx>=0)
        if m.any():rows.append({'fold':fold,'relation_code':code,'tokens':int(m.sum()),'mean_attention':float(att[m].mean()),'attention_mass':float(att[m].sum())})
    return rows

def k_sensitivity_rows(fold,model,target,bank,store,calib,device,args):
    rows=[];ds=RetrievalDataset(target,bank,store)
    for k in [4,8,16]:
        p,ii=predict_model(model,ds,device,args.eval_batch_size,context_override=k);score=apply_platt(p,*calib);full=np.full(len(target.y),np.nan);full[ii]=score
        for fi,fac in enumerate(target.faculty_names):
            m=target.faculty_idx==fi;rows.append({'fold':fold,'faculty':fac,'context_per_pool':k,'ap':safe_ap(target.y[m],full[m]),'auc':safe_auc(target.y[m],full[m])})
    return rows

def run(args):
    t0=time.time();out=Path(args.out_dir);out.mkdir(parents=True,exist_ok=True);device=torch.device(args.device if args.device!='auto' else ('cuda' if torch.cuda.is_available() else 'cpu'));faculties=parse_faculties(args.faculties,discover_faculties(args.cache_dir,1));folds=[int(x) for x in args.folds.split(',')];dev=[int(x) for x in args.dev_folds.split(',')];hold=[int(x) for x in args.holdout_folds.split(',')];common_names=discover_common_feature_names(args.cache_dir,faculties,1);feat_names=current_feature_names(common_names)
    print('='*176);print('SUITE25 — STRUCTURE-AWARE CHRONOLOGICAL RETRIEVAL (SACR / TabR-inspired)');print('standalone current-state predictor | chronology-safe historical retrieval | learned TabR re-ranking | student/course/structural/state candidate pools | Committee only as ablation');print('='*176)
    print(f'[ENV] device={device} torch={torch.__version__} faculties={len(faculties)} folds={folds} dev={dev} holdout={hold} common_raw={len(common_names)} current_features={len(feat_names)}')
    print('[SCIENTIFIC CONTRACT] A=shared MLP without retrieval; B=direct chronology-safe TabR-like state retrieval; C=structure-aware multi-view chronological retrieval (PRIMARY, fully standalone). Candidate labels always come strictly from earlier semesters. Committee is NOT an input to A/B/C; Committee+SACR is a secondary ablation only. Selection retrieval memory contains TRAIN rows only; validation labels never enter validation memory. F6/F7 never select architecture/epoch/calibration/blend.')
    rel_index=CourseRelationIndex(Path(args.structured_cache_dir)/'raw_index');print(f'[RELATION INDEX] course_pairs={len(rel_index.edge_pair):,} directed_relations={sum(len(v) for v in rel_index.edge_map.values()):,}')
    all_metrics=[];records=[];reference_meta=[];support_rows=[];abl_rows=[];shuffle_rows=[];diag_rows=[];relatt_rows=[];strata_rows=[];novelty_all=[];support_gain=[];comp_rows=[];ks_rows=[];blend_grid_all=[]
    ref_dirs={'suite14':args.suite14_dir,'suite16':args.suite16_dir,'suite17':args.suite17_dir,'suite18':args.suite18_dir,'suite20':args.suite20_dir,'suite21':args.suite21_dir,'suite22':args.suite22_dir,'suite22_primary':args.suite22_dir,'suite22_relational':args.suite22_dir,'suite23':args.suite23_dir,'suite23_graph':args.suite23_dir,'suite24':args.suite24_dir,'suite24_posthoc':args.suite24_dir,'council':args.council_dir,'v2':args.v2_dir}
    for fold in folds:
        fd=out/f'fold_{fold}';fd.mkdir(exist_ok=True);print('\n'+'='*176+f'\nSUITE25 TARGET FOLD {fold}\n'+'='*176)
        hist_raw,target_raw,_=load_fold_bundle(args.cache_dir,args.structured_cache_dir,faculties,fold,common_names);tr,va=latest_block_split(hist_raw.faculty_idx,hist_raw.blocks,args.val_blocks);cal,pol=policy_masks(hist_raw,va);print(f'[DATA] history={len(hist_raw):,} fail={hist_raw.y.sum():,} ({hist_raw.y.mean():.2%}) train={tr.sum():,} validation={va.sum():,} target={len(target_raw):,} fail={target_raw.y.sum():,} ({target_raw.y.mean():.2%})')
        # Selection preprocessing is fitted on training rows only.
        prep_sel=RetrievalPreprocessor.fit(hist_raw,tr,args.seed+fold,args.pca_dim,args.pca_rows);hist_sel=prep_sel.transform(hist_raw);bank_sel=hist_sel.subset(tr)
        bests={};calibs={};val_scores={}
        # A first: no need to build retrieval memory.
        print('\n'+'-'*136+'\n[VARIANT suite25_mlp]');best=selection_train('mlp',hist_sel,bank_sel,None,tr,va,args,device,args.seed+fold*1000);bests['suite25_mlp']=best;aa,bb=fit_platt(hist_raw.y[cal],best['val_score'][cal]);calibs['suite25_mlp']=(aa,bb);val_scores['suite25_mlp']=apply_platt(best['val_score'],aa,bb);pd.DataFrame(best['history']).to_csv(fd/'suite25_mlp_selection_history.csv',index=False)
        print('[RETRIEVAL CACHE] selection phase...');store_sel=build_phase_store(rel_index,bank_sel,hist_sel,prep_sel,args,'selection')
        print_table(f'FOLD {fold} SELECTION RETRIEVAL SUPPORT',retrieval_support_frame(store_sel,hist_sel,bank_sel))
        for vi,(variant,name) in enumerate(VARIANTS[1:],1):
            print('\n'+'-'*136+f'\n[VARIANT {name}]');best=selection_train(variant,hist_sel,bank_sel,store_sel,tr,va,args,device,args.seed+fold*1000+vi*100);bests[name]=best;aa,bb=fit_platt(hist_raw.y[cal],best['val_score'][cal]);calibs[name]=(aa,bb);val_scores[name]=apply_platt(best['val_score'],aa,bb);pd.DataFrame(best['history']).to_csv(fd/f'{name}_selection_history.csv',index=False);save_json({'selected_epoch':best['epoch'],'platt_a':aa,'platt_b':bb},fd/f'{name}_selection.json')
        blend_sel,blend_grid=select_blend(hist_raw,pol,val_scores['suite25_sacr'],tuple(float(x) for x in args.alpha_grid.split(',')));alpha=float(blend_sel['alpha']);blend_grid_all.extend(blend_grid.assign(fold=fold).to_dict('records'));print(f'[COMMITTEE BLEND ABLATION] selected alpha={alpha:.2f} policyAP={blend_sel["policy_macro_ap"]:.4f} policyF2={blend_sel["policy_macro_f2"]:.4f}')
        del store_sel,bank_sel,hist_sel;gc.collect()
        # Production refit: every historical row is allowed as memory only for strictly later queries.
        prep=RetrievalPreprocessor.fit(hist_raw,np.ones(len(hist_raw),bool),args.seed+fold+10000,args.pca_dim,args.pca_rows);hist=prep.transform(hist_raw);target=prep.transform(target_raw);bank=hist
        print('[RETRIEVAL CACHE] production history...');store_hist=build_phase_store(rel_index,bank,hist,prep,args,'production-history');print('[RETRIEVAL CACHE] production target...');store_target=build_phase_store(rel_index,bank,target,prep,args,'production-target');sf=retrieval_support_frame(store_target,target,bank);sf['fold']=fold;support_rows.extend(sf.to_dict('records'));sf.to_csv(fd/'retrieval_support_target.csv',index=False);print_table(f'FOLD {fold} TARGET RETRIEVAL SUPPORT',sf)
        viol=int(store_hist.chronology_violation.sum()+store_target.chronology_violation.sum());print(f'[CHRONOLOGY AUDIT] violations={viol} / {len(hist)+len(target):,} | every retrieved label semester < query semester');assert viol==0
        target_scores={};models={};aux_primary=None
        for vi,(variant,name) in enumerate(VARIANTS):
            ret=refit_predict(variant,hist,bank,None if variant=='mlp' else store_hist,target,None if variant=='mlp' else store_target,bests[name]['epoch'],args,device,args.seed+fold*1000+vi*100,return_aux=(variant=='sacr'));model=ret[0]
            if variant=='sacr':praw,ii,aux=ret[1];aux_primary=aux;models[name]=model
            else:praw,ii=ret[1];models[name]=model
            full=np.full(len(target),np.nan);full[ii]=apply_platt(praw,*calibs[name]);target_scores[name]=full;print(f'[VARIANT {name}] selected_epochs={bests[name]["epoch"]} target macroAP={np.nanmean([safe_ap(target.y[target.faculty_idx==j],full[target.faculty_idx==j]) for j in range(len(faculties))]):.4f}')
            torch.save({'state_dict':model.state_dict(),'variant':variant,'feature_names':feat_names,'selected_epoch':bests[name]['epoch'],'args':vars(args)},fd/f'{name}_model.pt')
        joblib.dump(prep,fd/'production_preprocessor.joblib')
        primary=target_scores['suite25_sacr'];committee_blend=blend_logits(target.committee,primary,alpha);scores={'committee':target.committee,**target_scores,'suite25_committee_blend':committee_blend}
        refs,meta=load_references(ref_dirs,fold,target);reference_meta.extend(meta);scores.update(refs)
        # Mechanism diagnostics on the standalone primary.
        ar=ablation_rows_for_fold(fold,models['suite25_sacr'],target,bank,store_target,primary,calibs['suite25_sacr'],device,args);abl_rows.extend(ar);pd.DataFrame(ar).to_csv(fd/'retrieval_ablations.csv',index=False)
        sr=label_shuffle_rows_for_fold(fold,models['suite25_sacr'],target,bank,store_target,primary,calibs['suite25_sacr'],device,args);shuffle_rows.extend(sr);pd.DataFrame(sr).to_csv(fd/'candidate_label_shuffle.csv',index=False)
        dr=retrieval_diag_rows(fold,target,bank,store_target,aux_primary);diag_rows.extend(dr);pd.DataFrame(dr).to_csv(fd/'retrieval_diagnostics.csv',index=False)
        rr=relation_attention_rows(fold,target,store_target,aux_primary);relatt_rows.extend(rr);pd.DataFrame(rr).to_csv(fd/'relation_attention.csv',index=False)
        kr=k_sensitivity_rows(fold,models['suite25_sacr'],target,bank,store_target,calibs['suite25_sacr'],device,args);ks_rows.extend(kr);pd.DataFrame(kr).to_csv(fd/'context_k_sensitivity.csv',index=False)
        diag_scores={'suite25_sacr':primary,'suite25_tabr':target_scores['suite25_tabr'],'committee':target.committee}
        st=retrieval_strata_rows(fold,target,store_target,diag_scores);strata_rows.extend(st);pd.DataFrame(st).to_csv(fd/'retrieval_support_strata.csv',index=False);nv=novelty_rows(fold,target,store_target,diag_scores);novelty_all.extend(nv);pd.DataFrame(nv).to_csv(fd/'novelty_regimes.csv',index=False);sg=support_gain_rows(fold,target,store_target,target.committee,primary);support_gain.extend(sg);pd.DataFrame(sg).to_csv(fd/'support_gain.csv',index=False);cr=complementarity_rows(fold,target,target.committee,primary,committee_blend);comp_rows.extend(cr);pd.DataFrame(cr).to_csv(fd/'committee_complementarity.csv',index=False)
        # Metrics / reference outputs.
        rows=faculty_fold_metric_rows(fold,target,{k:v for k,v in scores.items() if np.isfinite(v).all()})
        for rn,rs in refs.items():
            if np.isfinite(rs).all():continue
            for fi,fac in enumerate(faculties):
                m=target.faculty_idx==fi;z=rs[m]
                if np.isfinite(z).all():rows.append({'fold':fold,'faculty':fac,'model':rn,'rows':int(m.sum()),'failures':int(target.y[m].sum()),'prevalence':float(target.y[m].mean()),**metric_dict(target.y[m],z)})
        all_metrics.extend(rows);print_table(f'SUITE25 TARGET FOLD {fold} — NEW + AVAILABLE REFERENCE RESULTS',pd.DataFrame(rows).sort_values(['faculty','model']))
        for fi,fac in enumerate(faculties):
            m=target.faculty_idx==fi;fs={k:np.asarray(v)[m] for k,v in scores.items() if np.isfinite(np.asarray(v)[m]).all()};records.append({'fold':fold,'faculty':fac,'y':target.y[m],'student_id':target.student_id[m],'scores':fs});df=pd.DataFrame({'actual':target.y[m],'student_id':target.student_id[m],'course_id':target.course_id[m]});
            for k,v in fs.items():df[k]=v
            df.to_csv(fd/f'{fac}_scores.csv',index=False)
        del store_hist,store_target,models,bank,hist,target;gc.collect();
        if torch.cuda.is_available():torch.cuda.empty_cache()
    # Final report.
    metrics=pd.DataFrame(all_metrics);metrics.to_csv(out/'all_fold_metrics.csv',index=False);pd.DataFrame(reference_meta).to_csv(out/'reference_loading.csv',index=False);pd.DataFrame(support_rows).to_csv(out/'retrieval_support_all.csv',index=False);pd.DataFrame(abl_rows).to_csv(out/'retrieval_ablations_all.csv',index=False);pd.DataFrame(shuffle_rows).to_csv(out/'candidate_label_shuffle_all.csv',index=False);pd.DataFrame(diag_rows).to_csv(out/'retrieval_diagnostics_all.csv',index=False);pd.DataFrame(relatt_rows).to_csv(out/'relation_attention_all.csv',index=False);pd.DataFrame(strata_rows).to_csv(out/'retrieval_support_strata_all.csv',index=False);pd.DataFrame(novelty_all).to_csv(out/'novelty_regimes_all.csv',index=False);pd.DataFrame(support_gain).to_csv(out/'support_gain_all.csv',index=False);pd.DataFrame(comp_rows).to_csv(out/'committee_complementarity_all.csv',index=False);pd.DataFrame(ks_rows).to_csv(out/'context_k_sensitivity_all.csv',index=False);pd.DataFrame(blend_grid_all).to_csv(out/'committee_blend_grid_all.csv',index=False)
    print_table('SUITE25 ALL-FOLD MACRO SUMMARY — F1..F7',macro_summary(metrics,folds));print_table('SUITE25 HOLDOUT MACRO SUMMARY — F6/F7',macro_summary(metrics,hold));primary='suite25_sacr';comparators=['suite25_mlp','suite25_tabr','committee','suite17','suite18','suite21','suite22','suite23','suite24','suite22_relational','suite23_graph','suite24_posthoc','council'];ps=[]
    for b in comparators:
        z=paired_summary(metrics,primary,b,hold)
        if z.get('cells',0):ps.append(z)
    print_table('SUITE25 PRIMARY PAIRED HOLDOUT COMPARISON',ps);pd.DataFrame(ps).to_csv(out/'paired_holdout_summary.csv',index=False)
    hh=[]
    for fac in faculties:
        d=metrics[(metrics.faculty==fac)&metrics.fold.isin(hold)];a=d[d.model==primary].ap.mean();row={'faculty':fac,'suite25_ap':a}
        for b in comparators+['suite25_committee_blend']:
            z=d[d.model==b]
            if len(z):row[f'{b}_ap']=z.ap.mean();row[f'delta_vs_{b}']=a-z.ap.mean()
        hh.append(row)
    hh=pd.DataFrame(hh);hh.to_csv(out/'holdout_faculty_head_to_head.csv',index=False);print_table('SUITE25 HOLDOUT FACULTY HEAD-TO-HEAD',hh.sort_values('delta_vs_committee',ascending=False))
    op=operational_metrics(records,dev,hold);op.to_csv(out/'operational_metrics.csv',index=False);piv=op[op.fold.astype(str)=='POOLED'].groupby(['model','policy'],as_index=False).agg(precision=('precision','mean'),recall=('recall','mean'),f2=('fbeta','mean'),flag_rate=('flag_rate','mean'));print_table('SUITE25 OPERATIONAL HOLDOUT SUMMARY',piv.sort_values(['policy','f2'],ascending=[True,False]))
    for model in [primary,'suite25_tabr','suite25_mlp','suite25_committee_blend','committee','suite22','suite23','suite24','council','v2']:
        for pol in ['fixed','drift']:print_confusion('POOLED F6/F7 CONFUSION MATRIX',op,'khoa_cong_nghe_thong_tin',model,pol)
    # Student-cluster bootstrap for repeated student-course rows.
    br=[]
    for fac in faculties:
        rr=[r for r in records if r['faculty']==fac and int(r['fold']) in hold]
        if not rr or not all(primary in r['scores'] for r in rr):continue
        y=np.concatenate([r['y'] for r in rr]);cand=np.concatenate([r['scores'][primary] for r in rr]);cl=np.concatenate([r['student_id'] for r in rr])
        for ref in ['committee','suite18','suite21','suite22','suite23','suite24','council']:
            if not all(ref in r['scores'] for r in rr):continue
            s=np.concatenate([r['scores'][ref] for r in rr]);d,lo,hi=cluster_bootstrap_ap_delta(y,cand,s,cl,args.bootstrap,args.seed+len(br)*31);br.append({'faculty':fac,'reference':ref,'delta_ap':d,'ci_low':lo,'ci_high':hi,'positive_ci':lo>0,'negative_ci':hi<0})
    br=pd.DataFrame(br);br.to_csv(out/'paired_cluster_bootstrap_holdout.csv',index=False);print_table('SUITE25 STUDENT-CLUSTER BOOTSTRAP — HOLDOUT',br)
    cu=component_uplift(metrics,hold);cu.to_csv(out/'component_uplift_holdout.csv',index=False);print_table('SUITE25 COMPONENT UPLIFT — HOLDOUT',cu)
    if abl_rows:
        a=pd.DataFrame(abl_rows);print_table('SUITE25 RETRIEVAL ABLATION SUMMARY — HOLDOUT',a[a.fold.isin(hold)].groupby('ablation',as_index=False).agg(cells=('delta_ap','size'),mean_delta_ap=('delta_ap','mean'),median_delta_ap=('delta_ap','median'),loss_cells=('delta_ap',lambda x:int((x<0).sum())),mean_abs_prob_change=('mean_abs_probability_change','mean')))
    if shuffle_rows:
        s=pd.DataFrame(shuffle_rows);print_table('SUITE25 CANDIDATE-LABEL SHUFFLE — HOLDOUT',s[s.fold.isin(hold)].groupby(lambda _:0).agg(cells=('delta_ap','size'),mean_delta_ap=('delta_ap','mean'),median_delta_ap=('delta_ap','median'),loss_cells=('delta_ap',lambda x:int((x<0).sum())),mean_abs_prob_change=('mean_abs_probability_change','mean')).reset_index(drop=True))
    if diag_rows:print_table('SUITE25 RETRIEVAL MECHANISM DIAGNOSTICS — HOLDOUT',pd.DataFrame(diag_rows)[pd.DataFrame(diag_rows).fold.isin(hold)])
    if relatt_rows:print_table('SUITE25 RELATION-CODE ATTENTION — HOLDOUT',pd.DataFrame(relatt_rows)[pd.DataFrame(relatt_rows).fold.isin(hold)].groupby('relation_code',as_index=False).agg(tokens=('tokens','sum'),mean_attention=('mean_attention','mean'),attention_mass=('attention_mass','sum')))
    if comp_rows:print_table('SUITE25 COMMITTEE COMPLEMENTARITY — HOLDOUT',pd.DataFrame(comp_rows)[pd.DataFrame(comp_rows).fold.isin(hold)])
    if novelty_all:print_table('SUITE25 COLD/NEW RETRIEVAL REGIMES — HOLDOUT',pd.DataFrame(novelty_all)[pd.DataFrame(novelty_all).fold.isin(hold)])
    if support_gain:
        sgc=support_gain_correlations(support_gain,hold);sgc.to_csv(out/'support_gain_correlations.csv',index=False);print_table('SUITE25 RETRIEVAL-SUPPORT vs GAIN CORRELATIONS — HOLDOUT',sgc)
    if ks_rows:print_table('SUITE25 CONTEXT-K SENSITIVITY — HOLDOUT',pd.DataFrame(ks_rows)[pd.DataFrame(ks_rows).fold.isin(hold)].groupby('context_per_pool',as_index=False).agg(macro_ap=('ap','mean'),macro_auc=('auc','mean')))
    audit=premise_audit(metrics,abl_rows,shuffle_rows,hold);audit.to_csv(out/'premise_audit.csv',index=False);print_table('SUITE25 PREDECLARED PREMISE / SUCCESS AUDIT',audit)
    elapsed=(time.time()-t0)/3600.;save_json({'elapsed_hours':elapsed,'folds':folds,'faculties':faculties,'primary':'suite25_sacr','committee_blend':'suite25_committee_blend','current_features':len(feat_names)},out/'run_summary.json');print(f'\n[DONE] Suite25 complete in {elapsed:.2f} hours | output={out}')

def parser():
    root='/root/disk_3tb/earlywarning/30072026';p=argparse.ArgumentParser();p.add_argument('--cache_dir',default=f'{root}/results/cross_faculty_residual_moe/cache');p.add_argument('--structured_cache_dir',default=f'{root}/results/suite12_structured_cache');p.add_argument('--out_dir',default=f'{root}/results/suite25_structure_aware_chronological_retrieval');p.add_argument('--faculties',default='all');p.add_argument('--folds',default='1,2,3,4,5,6,7');p.add_argument('--dev_folds',default='1,2,3,4,5');p.add_argument('--holdout_folds',default='6,7');p.add_argument('--seed',type=int,default=20260928);p.add_argument('--device',default='auto');p.add_argument('--d_main',type=int,default=128);p.add_argument('--key_dim',type=int,default=64);p.add_argument('--faculty_dim',type=int,default=8);p.add_argument('--encoder_blocks',type=int,default=2);p.add_argument('--predictor_blocks',type=int,default=2);p.add_argument('--dropout',type=float,default=.10);p.add_argument('--context_dropout',type=float,default=.10);p.add_argument('--context_size',type=int,default=24);p.add_argument('--pool_context',type=int,default=8);p.add_argument('--lr',type=float,default=1e-3);p.add_argument('--weight_decay',type=float,default=1e-4);p.add_argument('--rank_weight',type=float,default=.10);p.add_argument('--grad_clip',type=float,default=5.);p.add_argument('--batch_size',type=int,default=256);p.add_argument('--eval_batch_size',type=int,default=512);p.add_argument('--max_epochs',type=int,default=10);p.add_argument('--min_epochs',type=int,default=3);p.add_argument('--patience',type=int,default=3);p.add_argument('--samples_per_epoch',type=int,default=180000);p.add_argument('--val_blocks',type=int,default=3);p.add_argument('--pca_dim',type=int,default=24);p.add_argument('--pca_rows',type=int,default=100000);p.add_argument('--student_pool',type=int,default=16);p.add_argument('--course_pool',type=int,default=24);p.add_argument('--struct_pool',type=int,default=24);p.add_argument('--state_pool',type=int,default=32);p.add_argument('--struct_courses',type=int,default=10);p.add_argument('--struct_per_course',type=int,default=4);p.add_argument('--max_candidates',type=int,default=96);p.add_argument('--retrieval_progress_every',type=int,default=25000);p.add_argument('--alpha_grid',default='0,.10,.25,.50,.75');p.add_argument('--bootstrap',type=int,default=500)
    p.add_argument('--suite14_dir',default=f'{root}/results/suite14_authority_safe_collaborative_moe');p.add_argument('--suite16_dir',default=f'{root}/results/suite16_conditional_tree_boosting');p.add_argument('--suite17_dir',default=f'{root}/results/suite17_robust_forward_specialist_boosting');p.add_argument('--suite18_dir',default=f'{root}/results/suite18_fmm_forward_specialist_boosting');p.add_argument('--suite20_dir',default=f'{root}/results/suite20_semester_target_transformer');p.add_argument('--suite21_dir',default=f'{root}/results/suite21_guarded_temporal_residual');p.add_argument('--suite22_dir',default=f'{root}/results/suite22_sftr_tabm');p.add_argument('--suite23_dir',default=f'{root}/results/suite23_cs_hagt');p.add_argument('--suite24_dir',default=f'{root}/results/suite24_target_conditioned_structural_residual');p.add_argument('--council_dir',default=f'{root}/results/suite4/2_competence_council');p.add_argument('--v2_dir',default=f'{root}/results/final_train_v2');return p

if __name__=='__main__':run(parser().parse_args())
