# -*- coding: utf-8 -*-
"""Committee-Anchored Cross-Faculty Joint Residual Mixture-of-Experts.

One shared residual specialist bank is trained per temporal fold using chronology-
safe OOF Committee predictions from all participating faculties. Faculty-specific
canonical Committees remain frozen/read-only.
"""
from __future__ import annotations
import argparse,json,math,time
from pathlib import Path
from dataclasses import asdict
import numpy as np
import pandas as pd
import torch
from torch.utils.data import TensorDataset,DataLoader,WeightedRandomSampler

import train_v3 as core
from suite2_common import safe_ap,safe_auc,equal_budget_metrics
from cross_faculty_common import (
    FeatureStandardizer,discover_faculties,parse_faculties,common_raw_features,
    load_fold_caches,build_historical_bundle,build_target_bundle,subset_bundle,
    faculty_class_sampling_weights,latest_block_split,per_faculty_validation_rows,
    model_selection_score,save_json,
)
from cross_faculty_residual_moe import ResidualMoE,residual_moe_loss,router_diagnostics,seed_everything,choose_device
from cross_faculty_eval import evaluate_faculty

BUDGETS=(.10,.15,.20,.25)


def _tensor_loader(bundle,scaler,mask,args,seed,sampled=True):
    mask=np.asarray(mask,bool);X=scaler.transform(bundle.X[mask]);y=bundle.y[mask].astype(np.float32);q=bundle.q[mask].astype(np.float32);f=bundle.faculty_idx[mask].astype(np.int64)
    ds=TensorDataset(torch.from_numpy(X),torch.from_numpy(f),torch.from_numpy(q),torch.from_numpy(y))
    if sampled:
        names=bundle.faculty_names
        w,_=faculty_class_sampling_weights(bundle.y[mask],bundle.faculty_idx[mask],names,args.sampling_beta)
        gen=torch.Generator();gen.manual_seed(int(seed))
        n=len(ds) if args.samples_per_epoch<=0 else int(args.samples_per_epoch)
        sampler=WeightedRandomSampler(torch.as_tensor(w,dtype=torch.double),num_samples=n,replacement=True,generator=gen)
        return DataLoader(ds,batch_size=args.batch_size,sampler=sampler,num_workers=0,pin_memory=False)
    return DataLoader(ds,batch_size=args.predict_batch_size,shuffle=False,num_workers=0)


def _make_model(input_dim,n_faculties,args):
    return ResidualMoE(input_dim,n_faculties,args.n_experts,args.faculty_dim,args.encoder_hidden,args.representation_dim,args.expert_hidden,args.delta_max,args.dropout,args.router_temperature)


def train_epoch(model,loader,optimizer,device,args):
    model.train();acc={'total':0.,'prediction':0.,'router':0.,'specialization_mi':0.,'magnitude':0.};n=0
    for X,f,q,y in loader:
        X=X.to(device);f=f.to(device);q=q.to(device);y=y.to(device)
        optimizer.zero_grad(set_to_none=True);out=model(X,f,q)
        ls=residual_moe_loss(out,y,q,args.router_lambda,args.specialization_lambda,args.magnitude_lambda,args.utility_temperature)
        ls['total'].backward();torch.nn.utils.clip_grad_norm_(model.parameters(),args.grad_clip);optimizer.step()
        b=len(y);n+=b
        for k in acc:acc[k]+=float(ls[k].detach().cpu())*b
    return {k:v/max(n,1) for k,v in acc.items()}


@torch.no_grad()
def predict_bundle(model,bundle,scaler,mask,device,args):
    model.eval();loader=_tensor_loader(bundle,scaler,mask,args,0,sampled=False)
    ps=[];ws=[];rs=[];cs=[]
    for X,f,q,y in loader:
        out=model(X.to(device),f.to(device),q.to(device));ps.append(out['final_prob'].cpu().numpy());ws.append(out['weights'].cpu().numpy());rs.append(out['residuals'].cpu().numpy());cs.append(out['correction'].cpu().numpy())
    if not ps:return np.array([]),np.empty((0,args.n_experts+1)),np.empty((0,args.n_experts)),np.array([])
    return np.concatenate(ps),np.concatenate(ws),np.concatenate(rs),np.concatenate(cs)


def fit_with_temporal_validation(bundle,args,seed,label='shared'):
    tr,va=latest_block_split(bundle.faculty_idx,bundle.blocks,args.val_blocks)
    if tr.sum()<args.min_train_rows:raise RuntimeError(f'{label}: only {tr.sum()} chronological training rows')
    if va.sum()<args.min_val_rows:
        print(f'[{label}] validation rows={va.sum():,} < {args.min_val_rows}; using all rows for train and a fixed {args.fallback_epochs} epochs')
        return int(args.fallback_epochs),pd.DataFrame(),pd.DataFrame([{'epoch':0,'selection_score':np.nan,'note':'no_validation'}])
    scaler=FeatureStandardizer.fit(bundle.X[tr]);seed_everything(seed);device=choose_device(args.device);model=_make_model(bundle.X.shape[1],len(bundle.faculty_names),args).to(device)
    opt=torch.optim.AdamW(model.parameters(),lr=args.lr,weight_decay=args.weight_decay)
    best_score=-np.inf;best_epoch=1;pat=0;history=[];best_rows=pd.DataFrame()
    print(f'[{label}] chronological train={tr.sum():,} val={va.sum():,} faculties={len(bundle.faculty_names)} input_dim={bundle.X.shape[1]} device={device}')
    for epoch in range(1,args.epochs+1):
        loader=_tensor_loader(bundle,scaler,tr,args,seed+epoch*997,sampled=True);losses=train_epoch(model,loader,opt,device,args)
        p,w,r,c=predict_bundle(model,bundle,scaler,va,device,args)
        rows=per_faculty_validation_rows(bundle.y[va],bundle.q[va],p,bundle.faculty_idx[va],bundle.faculty_names,args.threshold_beta,.20)
        score,macro=model_selection_score(rows,args.macro_f2_weight)
        hist={'epoch':epoch,'selection_score':score,**losses,**macro,'null_weight':float(w[:,0].mean()) if len(w) else np.nan}
        history.append(hist)
        if epoch==1 or epoch%args.print_every==0:
            print(f'[{label}] epoch={epoch:03d} loss={losses["total"]:.5f} sel={score:+.5f} median ΔAP={macro["median_delta_ap"]:+.4f} median ΔF2@20={macro["median_delta_f2_20"]:+.4f} AP-win={macro["win_rate_ap"]:.1%} NULL={hist["null_weight"]:.3f}')
        if np.isfinite(score) and score>best_score+args.min_selection_improvement:
            best_score=score;best_epoch=epoch;best_rows=rows.copy();pat=0
        else:pat+=1
        if epoch>=args.min_epochs and pat>=args.patience:break
    print(f'[{label}] selected epoch={best_epoch} macro selection score={best_score:+.5f}')
    return best_epoch,best_rows,pd.DataFrame(history)


def refit_full(bundle,args,seed,epochs,label='shared'):
    mask=np.ones(len(bundle.y),bool);scaler=FeatureStandardizer.fit(bundle.X);seed_everything(seed);device=choose_device(args.device);model=_make_model(bundle.X.shape[1],len(bundle.faculty_names),args).to(device)
    opt=torch.optim.AdamW(model.parameters(),lr=args.lr,weight_decay=args.weight_decay)
    for epoch in range(1,max(int(epochs),1)+1):
        loader=_tensor_loader(bundle,scaler,mask,args,seed+epoch*1543,sampled=True);losses=train_epoch(model,loader,opt,device,args)
        if epoch==1 or epoch==epochs or epoch%args.print_every==0:print(f'[{label} refit] epoch={epoch:03d}/{epochs} loss={losses["total"]:.5f}')
    return model,scaler,device


def fold_metric_rows(fold,target,predictions):
    rows=[]
    for fi,faculty in enumerate(target.faculty_names):
        m=target.faculty_idx==fi;y=target.y[m]
        for model,s in predictions.items():
            if s is None:continue
            ss=np.asarray(s)[m];row={'fold':fold,'faculty':faculty,'model':model,'rows':int(m.sum()),'failures':int(y.sum()),'prevalence':float(y.mean()),'ap':safe_ap(y,ss),'auc':safe_auc(y,ss)}
            for b in BUDGETS:
                z=equal_budget_metrics(y,ss,b,2.0);row[f'precision_at_{int(b*100)}']=z['precision'];row[f'recall_at_{int(b*100)}']=z['recall'];row[f'f1_at_{int(b*100)}']=z['f1'];row[f'f2_at_{int(b*100)}']=z['fbeta']
            rows.append(row)
    return rows


def specialization_rows(fold,target,p,w,residuals):
    rows=[]
    for fi,faculty in enumerate(target.faculty_names):
        base=target.faculty_idx==fi
        groups=[('all',base),('failures',base&(target.y==1)),('normals',base&(target.y==0)),('history0',base&(target.support_history_semesters<=0)),('history1_2',base&(target.support_history_semesters>=1)&(target.support_history_semesters<=2)),('history3plus',base&(target.support_history_semesters>=3))]
        for label,m in groups:
            if not np.any(m):continue
            d=router_diagnostics(w[m],residuals[m]);d.update({'fold':fold,'faculty':faculty,'group':label,'rows':int(m.sum()),'failures':int(target.y[m].sum()),'prevalence':float(target.y[m].mean())});rows.append(d)
    return rows


def residual_correlation_rows(fold,target,residuals):
    rows=[]
    for fi,faculty in enumerate(target.faculty_names):
        m=target.faculty_idx==fi
        if m.sum()<3:continue
        c=np.corrcoef(residuals[m],rowvar=False)
        for i in range(c.shape[0]):
            for j in range(i+1,c.shape[1]):rows.append({'fold':fold,'faculty':faculty,'expert_i':i+1,'expert_j':j+1,'correlation':float(c[i,j]) if np.isfinite(c[i,j]) else np.nan})
    return rows


def train_target_only_ablation(hist,target,faculty,args,common_names,seed,fold,fold_dir):
    fi=hist.faculty_names.index(faculty);hm=hist.faculty_idx==fi;tm=target.faculty_idx==fi
    h=subset_bundle(hist,hm,remap_faculty=True);t=subset_bundle(target,tm,remap_faculty=True)
    if len(h.y)<args.min_train_rows or int(h.y.sum())<args.min_target_only_failures:
        print(f'[target-only {faculty}] SKIP rows={len(h.y):,} failures={int(h.y.sum())}');return None
    be,vr,history=fit_with_temporal_validation(h,args,seed,label=f'target-only:{faculty}:F{fold}')
    model,scaler,device=refit_full(h,args,seed,be,label=f'target-only:{faculty}:F{fold}')
    mask=np.ones(len(t.y),bool);p,w,r,c=predict_bundle(model,t,scaler,mask,device,args)
    history.to_csv(fold_dir/f'{faculty}_target_only_training_history.csv',index=False)
    torch.save({'state_dict':model.state_dict(),'selected_epoch':be,'common_raw_features':common_names,'faculty':faculty},fold_dir/f'{faculty}_target_only_model.pt')
    return p


def run_fold(cache_dir,faculties,fold,args,out):
    print('\n'+'='*150);print(f'CROSS-FACULTY RESIDUAL MoE | TARGET FOLD {fold}');print('='*150)
    caches=load_fold_caches(cache_dir,faculties,fold);common=common_raw_features(caches,faculties)
    hist=build_historical_bundle(caches,faculties,common);target=build_target_bundle(caches,faculties,common)
    print(f'[DATA] common raw features={len(common)} final shared inputs={hist.X.shape[1]} historical OOF rows={len(hist.y):,} failures={hist.y.sum():,} ({hist.y.mean():.2%}) target rows={len(target.y):,}')
    fold_dir=out/f'fold_{fold}';fold_dir.mkdir(parents=True,exist_ok=True);save_json({'fold':fold,'faculties':faculties,'common_raw_features':common,'shared_feature_names':hist.feature_names},fold_dir/'feature_schema.json')
    best_epoch,val_rows,history=fit_with_temporal_validation(hist,args,args.seed+fold*100003,label=f'shared:F{fold}')
    history.to_csv(fold_dir/'shared_training_history.csv',index=False);val_rows.to_csv(fold_dir/'shared_best_validation_by_faculty.csv',index=False)
    model,scaler,device=refit_full(hist,args,args.seed+fold*100003,best_epoch,label=f'shared:F{fold}');scaler.save(fold_dir/'shared_scaler.npz')
    torch.save({'state_dict':model.state_dict(),'selected_epoch':best_epoch,'model_config':{'input_dim':hist.X.shape[1],'n_faculties':len(faculties),'n_experts':args.n_experts,'faculty_dim':args.faculty_dim,'encoder_hidden':args.encoder_hidden,'representation_dim':args.representation_dim,'expert_hidden':args.expert_hidden,'delta_max':args.delta_max,'dropout':args.dropout,'router_temperature':args.router_temperature},'faculties':faculties,'common_raw_features':common},fold_dir/'shared_model.pt')
    mask=np.ones(len(target.y),bool);p,w,residuals,corr=predict_bundle(model,target,scaler,mask,device,args)
    predictions={'committee':target.q,'residual_moe_shared':p}
    target_only={}
    for faculty in args.target_only_faculties:
        if faculty not in faculties:continue
        po=train_target_only_ablation(hist,target,faculty,args,common,args.seed+fold*200003+faculties.index(faculty),fold,fold_dir)
        if po is not None:target_only[faculty]=po
    metrics=fold_metric_rows(fold,target,predictions);spec=specialization_rows(fold,target,p,w,residuals);corrrows=residual_correlation_rows(fold,target,residuals)
    pd.DataFrame(metrics).to_csv(fold_dir/'fold_metrics.csv',index=False);pd.DataFrame(spec).to_csv(fold_dir/'specialization_by_faculty.csv',index=False);pd.DataFrame(corrrows).to_csv(fold_dir/'residual_correlations.csv',index=False)
    records=[]
    for fi,faculty in enumerate(faculties):
        m=target.faculty_idx==fi;score_map={'committee':target.q[m],'residual_moe_shared':p[m]}
        if faculty in target_only:score_map['residual_moe_target_only']=target_only[faculty]
        frame=pd.DataFrame({'actual':target.y[m],'committee':target.q[m],'residual_moe_shared':p[m],'correction_logit':corr[m],'history_semesters':target.support_history_semesters[m]})
        for j in range(w.shape[1]):frame[f'weight_{"null" if j==0 else f"expert_{j}"}']=w[m,j]
        for j in range(residuals.shape[1]):frame[f'residual_expert_{j+1}']=residuals[m,j]
        if faculty in target_only:frame['residual_moe_target_only']=target_only[faculty]
        frame.to_csv(fold_dir/f'{faculty}_scores.csv',index=False)
        records.append({'faculty':faculty,'fold':fold,'y':target.y[m],'scores':score_map})
        cm=next(r for r in metrics if r['faculty']==faculty and r['model']=='committee');mm=next(r for r in metrics if r['faculty']==faculty and r['model']=='residual_moe_shared')
        print(f'[TARGET {faculty}] n={m.sum():,} prev={target.y[m].mean():.2%} AP {cm["ap"]:.4f}->{mm["ap"]:.4f} ({mm["ap"]-cm["ap"]:+.4f}) AUC {cm["auc"]:.4f}->{mm["auc"]:.4f} F2@20 {cm["f2_at_20"]:.4f}->{mm["f2_at_20"]:.4f}')
    return records,metrics,spec,corrrows


def official_summary(records,metrics,args,out):
    metric_df=pd.DataFrame(metrics);metric_df.to_csv(out/'cross_faculty_fold_metrics.csv',index=False)
    all_warning=[];policies=[]
    models=['committee','residual_moe_shared']
    if any('residual_moe_target_only' in r['scores'] for r in records):models.append('residual_moe_target_only')
    print('\n'+'='*150);print('OFFICIAL FACULTY-WISE OPERATIONAL EVALUATION — DEVELOPMENT POLICIES FROZEN BEFORE HOLDOUT');print('='*150)
    for faculty in sorted({r['faculty'] for r in records}):
        available={k for r in records if r['faculty']==faculty for k in r['scores']}
        for model in models:
            if model not in available:continue
            pol,rows=evaluate_faculty(records,faculty,model,args.dev_folds,args.holdout_folds,args.threshold_beta,args.min_precision,args.max_warning_ratio,args.min_flags,verbose=(model in {'committee','residual_moe_shared'}))
            policies.append({'faculty':faculty,'model':model,'threshold':pol.threshold,'warning_ratio':pol.warning_ratio,'development_ap':pol.development_ap,'development_auc':pol.development_auc,'development_prevalence':pol.development_prevalence,'development_flag_rate':pol.flag_rate,'development_precision':pol.precision,'development_recall':pol.recall,'development_f1':pol.f1,'development_f2':pol.fbeta,'constraints_relaxed':pol.constraints_relaxed});all_warning.extend(rows)
    wdf=pd.DataFrame(all_warning);wdf.to_csv(out/'cross_faculty_warning_metrics.csv',index=False);pd.DataFrame(policies).to_csv(out/'cross_faculty_threshold_policies.csv',index=False)
    # Pooled holdout ranking/budget table per faculty from fold-level records, independent of thresholds.
    rows=[]
    for faculty in sorted({r['faculty'] for r in records}):
        rr=[r for r in records if r['faculty']==faculty and r['fold'] in args.holdout_folds]
        y=np.concatenate([r['y'] for r in rr])
        available=set.intersection(*[set(r['scores']) for r in rr]) if rr else set()
        for model in sorted(available):
            s=np.concatenate([r['scores'][model] for r in rr]);row={'faculty':faculty,'model':model,'rows':len(y),'failures':int(y.sum()),'prevalence':float(y.mean()),'ap':safe_ap(y,s),'auc':safe_auc(y,s)}
            for b in BUDGETS:
                z=equal_budget_metrics(y,s,b,args.threshold_beta);row[f'f2_at_{int(b*100)}']=z['fbeta'];row[f'precision_at_{int(b*100)}']=z['precision'];row[f'recall_at_{int(b*100)}']=z['recall']
            rows.append(row)
    pooled=pd.DataFrame(rows);pooled.to_csv(out/'cross_faculty_holdout_pooled.csv',index=False)
    piv=[]
    for faculty in sorted(pooled.faculty.unique()):
        c=pooled[(pooled.faculty==faculty)&(pooled.model=='committee')].iloc[0];m=pooled[(pooled.faculty==faculty)&(pooled.model=='residual_moe_shared')].iloc[0]
        piv.append({'faculty':faculty,'committee_ap':c.ap,'residual_ap':m.ap,'delta_ap':m.ap-c.ap,'committee_auc':c.auc,'residual_auc':m.auc,'delta_auc':m.auc-c.auc,'committee_f2_20':c.f2_at_20,'residual_f2_20':m.f2_at_20,'delta_f2_20':m.f2_at_20-c.f2_at_20})
    cmp=pd.DataFrame(piv);cmp.to_csv(out/'cross_faculty_committee_comparison.csv',index=False)
    print('\n'+'='*150);print('CROSS-FACULTY HOLDOUT POOLED — SHARED RESIDUAL MoE vs COMMITTEE');print('='*150)
    print(cmp.to_string(index=False,formatters={'committee_ap':'{:.4f}'.format,'residual_ap':'{:.4f}'.format,'delta_ap':'{:+.4f}'.format,'committee_auc':'{:.4f}'.format,'residual_auc':'{:.4f}'.format,'delta_auc':'{:+.4f}'.format,'committee_f2_20':'{:.4f}'.format,'residual_f2_20':'{:.4f}'.format,'delta_f2_20':'{:+.4f}'.format}))
    for metric in ['delta_ap','delta_auc','delta_f2_20']:
        v=cmp[metric].to_numpy(float);print(f'{metric:16s} mean={np.mean(v):+.4f} median={np.median(v):+.4f} worst={np.min(v):+.4f} win_rate={np.mean(v>0):.1%}')
    # Drift operational macro comparison.
    drift=wdf[(wdf.fold.astype(str)=='POOLED')&(wdf.policy=='drift')&(wdf.model.isin(['committee','residual_moe_shared']))]
    drows=[]
    for faculty in sorted(cmp.faculty):
        cc=drift[(drift.faculty==faculty)&(drift.model=='committee')];mm=drift[(drift.faculty==faculty)&(drift.model=='residual_moe_shared')]
        if cc.empty or mm.empty:continue
        cc=cc.iloc[0];mm=mm.iloc[0];drows.append({'faculty':faculty,'committee_f2':cc.fbeta,'residual_f2':mm.fbeta,'delta_f2':mm.fbeta-cc.fbeta,'committee_precision':cc.precision,'residual_precision':mm.precision,'committee_recall':cc.recall,'residual_recall':mm.recall,'committee_rate':cc.flag_rate,'residual_rate':mm.flag_rate})
    ddf=pd.DataFrame(drows);ddf.to_csv(out/'cross_faculty_drift_comparison.csv',index=False)
    if len(ddf):
        print('\nDRIFT-AWARE OPERATIONAL MACRO:')
        print(f"F2 Δ mean={ddf.delta_f2.mean():+.4f} median={ddf.delta_f2.median():+.4f} worst={ddf.delta_f2.min():+.4f} win_rate={(ddf.delta_f2>0).mean():.1%}")
    # Optional external original V2 / Suite4 references.
    if args.reference_metrics:
        ref=pd.read_csv(args.reference_metrics);ref=ref[ref.split.eq('holdout')] if 'split' in ref else ref
        table=cmp.copy()
        for model in ref.model.unique():
            rr=ref[ref.model==model][['faculty','ap','auc','fixed_f2','drift_f2']].drop_duplicates('faculty')
            rr=rr.rename(columns={c:f'{model}_{c}' for c in ['ap','auc','fixed_f2','drift_f2']})
            table=table.merge(rr,on='faculty',how='left')
        table.to_csv(out/'cross_faculty_official_reference_comparison.csv',index=False)
        print('\n'+'='*150);print('OFFICIAL COMPARISON WITH PROVIDED ORIGINAL V2 / SUITE4 COUNCIL REFERENCES');print('='*150);print(table.to_string(index=False))
    return cmp,wdf


def parse_args():
    p=argparse.ArgumentParser()
    p.add_argument('--cache_dir',required=True);p.add_argument('--models_dir',required=True);p.add_argument('--faculties',default='all');p.add_argument('--dev_folds',default='1,2,3,4,5');p.add_argument('--holdout_folds',default='6,7');p.add_argument('--reference_metrics',default=None)
    p.add_argument('--seed',type=int,default=42);p.add_argument('--device',choices=['auto','cpu','cuda'],default='auto')
    p.add_argument('--n_experts',type=int,default=4);p.add_argument('--faculty_dim',type=int,default=8);p.add_argument('--encoder_hidden',type=int,default=256);p.add_argument('--representation_dim',type=int,default=128);p.add_argument('--expert_hidden',type=int,default=64);p.add_argument('--delta_max',type=float,default=2.0);p.add_argument('--dropout',type=float,default=.10);p.add_argument('--router_temperature',type=float,default=1.0)
    p.add_argument('--epochs',type=int,default=60);p.add_argument('--min_epochs',type=int,default=8);p.add_argument('--patience',type=int,default=8);p.add_argument('--fallback_epochs',type=int,default=20);p.add_argument('--val_blocks',type=int,default=2);p.add_argument('--min_train_rows',type=int,default=800);p.add_argument('--min_val_rows',type=int,default=200);p.add_argument('--batch_size',type=int,default=1024);p.add_argument('--predict_batch_size',type=int,default=4096);p.add_argument('--samples_per_epoch',type=int,default=0);p.add_argument('--lr',type=float,default=1e-3);p.add_argument('--weight_decay',type=float,default=1e-4);p.add_argument('--grad_clip',type=float,default=5.0);p.add_argument('--print_every',type=int,default=5)
    p.add_argument('--router_lambda',type=float,default=.5);p.add_argument('--specialization_lambda',type=float,default=.01);p.add_argument('--magnitude_lambda',type=float,default=.01);p.add_argument('--utility_temperature',type=float,default=.25);p.add_argument('--sampling_beta',type=float,default=.9999);p.add_argument('--macro_f2_weight',type=float,default=1.0);p.add_argument('--min_selection_improvement',type=float,default=1e-5)
    p.add_argument('--target_only_faculties',default='');p.add_argument('--min_target_only_failures',type=int,default=20)
    p.add_argument('--threshold_beta',type=float,default=2.0);p.add_argument('--min_precision',type=float,default=.15);p.add_argument('--max_warning_ratio',type=float,default=2.5);p.add_argument('--min_flags',type=int,default=5)
    a=p.parse_args();a.dev_folds=[int(x) for x in a.dev_folds.split(',') if x.strip()];a.holdout_folds=[int(x) for x in a.holdout_folds.split(',') if x.strip()];a.target_only_faculties=[x.strip() for x in a.target_only_faculties.split(',') if x.strip()];return a


def main():
    args=parse_args();out=Path(args.models_dir);out.mkdir(parents=True,exist_ok=True)
    # Discover available faculties from cache names, not target labels.
    all_fold=min(args.dev_folds+args.holdout_folds);suffix=f'_fold_{all_fold}.joblib';available=sorted([p.name[:-len(suffix)] for p in Path(args.cache_dir).glob(f'*{suffix}')])
    faculties=parse_faculties(args.faculties,available)
    if len(faculties)<2:print('[NOTE] shared run contains <2 faculties; this is effectively a target-only residual MoE.')
    print('='*150);print('COMMITTEE-ANCHORED CROSS-FACULTY JOINT RESIDUAL MoE');print('='*150);print(f'faculties={len(faculties)} folds={args.dev_folds+args.holdout_folds} experts={args.n_experts} device={args.device}')
    save_json({'faculties':faculties,'args':vars(args)},out/'run_config.json')
    records=[];metrics=[];spec=[];corr=[]
    for fold in args.dev_folds+args.holdout_folds:
        rr,mm,ss,cc=run_fold(args.cache_dir,faculties,fold,args,out);records.extend(rr);metrics.extend(mm);spec.extend(ss);corr.extend(cc)
    pd.DataFrame(spec).to_csv(out/'cross_faculty_specialization.csv',index=False);pd.DataFrame(corr).to_csv(out/'cross_faculty_residual_correlations.csv',index=False)
    official_summary(records,metrics,args,out)
    print(f'\nCompleted. Results: {out}')

if __name__=='__main__':main()
