# -*- coding: utf-8 -*-
"""Suite3: calibrated temporal + relational composite for academic early warning.

Evidence-driven composition:
  stable 3-tree committee anchor
  + global all-feature HGB meta expert
  + recent (last6,last4) HGB experts
  + hybrid relational expert for history-rich students only
  + unlabeled blockwise rank-preserving alignment to committee score scale
  + robust prequential convex fusion
"""
from __future__ import annotations
import argparse
from dataclasses import dataclass
from pathlib import Path
import sys
import numpy as np
import pandas as pd

_HERE = Path(__file__).resolve().parent
if str(_HERE) not in sys.path:
    sys.path.insert(0, str(_HERE))

import train_v3 as core
from suite2_common import (
    load_binary_fold, crossfit_committee, fit_production_committee,
    chronological_support_features, support_matrix, v2_meta_features,
    fit_hgb_classifier, predict_positive, effective_weights,
    safe_ap, safe_auc, score_metrics, equal_budget_metrics,
    permutation_rows, save_csv, parse_folds, print_metric_line,
)
from relational_helpers import fit_relational_predict
from suite3_common import (
    blockwise_quantile_align, apply_composite, select_robust_weights,
    score_distribution, spearman_rank_corr, window_indices_before_block,
)


@dataclass
class FoldRecord:
    fold: int
    y: np.ndarray
    committee: np.ndarray
    final: np.ndarray
    a1_raw: np.ndarray
    a1_aligned: np.ndarray
    recent_raw: np.ndarray
    recent_aligned: np.ndarray
    relational_raw: np.ndarray
    relational_aligned: np.ndarray
    base_composite: np.ndarray
    raw_composite: np.ndarray


def build_meta_features(X, p, support, raw_names):
    meta, mn = v2_meta_features(p)
    sup, sn = support_matrix(support)
    z = np.column_stack([core.clean_X(X), meta, sup])
    return np.nan_to_num(z, nan=0.0, posinf=0.0, neginf=0.0), list(raw_names) + mn + sn


def _numeric_blocks(x):
    return np.asarray(pd.to_numeric(pd.Series(np.asarray(x)), errors='coerce'), float)


def _fit_hgb_window(Z, y, idx, args, seed):
    idx=np.asarray(idx,int)
    if len(idx) < args.min_window_rows or int(np.asarray(y)[idx].sum()) < args.min_window_failures or np.unique(np.asarray(y)[idx]).size < 2:
        return None
    w,_=effective_weights(np.asarray(y)[idx],args.effective_beta)
    return fit_hgb_classifier(
        Z[idx], np.asarray(y)[idx], seed=seed, max_iter=args.meta_max_iter,
        max_leaf_nodes=args.meta_leaf_nodes, min_samples_leaf=args.meta_min_leaf,
        learning_rate=args.meta_lr, l2_regularization=args.meta_l2,
        sample_weight=w,
    )


def _eligible_blocks(blocks,y,args):
    out=[]
    for b in sorted(v for v in pd.unique(blocks[np.isfinite(blocks)])):
        m=blocks==b
        if int(m.sum())>=args.transition_min_rows and int(np.asarray(y)[m].sum())>=args.transition_min_failures:
            out.append(float(b))
    return out[-args.prequential_blocks:]


def _target_blocks(frame):
    g,_=core.extract_temporal_groups(frame)
    g=_numeric_blocks(g)
    if not np.isfinite(g).any(): return np.zeros(len(frame),float)
    # Preserve unknown target rows as a separate group rather than mixing them.
    fill=(np.nanmax(g[np.isfinite(g)])+1) if np.isfinite(g).any() else 0.
    g[~np.isfinite(g)]=fill
    return g


def _align(source,q,blocks):
    return blockwise_quantile_align(np.asarray(source,float),np.asarray(q,float),np.asarray(blocks))


def _regimes(support):
    d=np.asarray(support['history_semesters'],int)
    return np.where(d<=0,'history0',np.where(d<=2,'history1_2','history3plus'))


def _prequential_components(Xtr,ytr,frame,names,idx,Xo,yo,po,bo,Zo,support_o,args,fold):
    qo=core.committee_statistics(po)['committee_mean']
    full_groups,_=core.extract_temporal_groups(frame);full_groups=_numeric_blocks(full_groups)
    blocks=_eligible_blocks(bo,yo,args)
    rows=[]; ys=[]; qs=[]; a1s=[]; recents=[]; rels=[]; riches=[]; block_arr=[]
    latest_importance=[]
    print(f"[Prequential fusion evidence] blocks={blocks}")
    for j,b in enumerate(blocks):
        va=np.where(bo==b)[0]
        if len(va)==0:continue
        tr_all=window_indices_before_block(bo,b,None)
        tr6=window_indices_before_block(bo,b,6)
        tr4=window_indices_before_block(bo,b,4)
        ma=_fit_hgb_window(Zo,yo,tr_all,args,args.seed+fold*100000+j*100+1)
        m6=_fit_hgb_window(Zo,yo,tr6,args,args.seed+fold*100000+j*100+2)
        m4=_fit_hgb_window(Zo,yo,tr4,args,args.seed+fold*100000+j*100+3)
        q=qo[va]
        pa=q.copy() if ma is None else predict_positive(ma,Zo[va])
        p6=q.copy() if m6 is None else predict_positive(m6,Zo[va])
        p4=q.copy() if m4 is None else predict_positive(m4,Zo[va])
        aa=_align(pa,q,np.full(len(va),b)); a6=_align(p6,q,np.full(len(va),b)); a4=_align(p4,q,np.full(len(va),b)); recent=(a6+a4)/2

        orig_va=idx[va]
        rel_train=np.where(np.isfinite(full_groups) & (full_groups < b))[0]
        rel_target=orig_va
        if len(rel_train)>=args.rel_min_train_rows and np.unique(ytr[rel_train]).size==2:
            prel,ri=fit_relational_predict(
                Xtr[rel_train],ytr[rel_train],frame.iloc[rel_train].reset_index(drop=True),
                Xtr[rel_target],frame.iloc[rel_target].reset_index(drop=True),names,args,
                args.seed+fold*200000+j*100,
            )
        else:
            prel=q.copy();ri={'fallback':True}
        ar=_align(prel,q,np.full(len(va),b))
        rich=np.asarray(support_o.iloc[va]['history_semesters'],int)>=3
        apq=safe_ap(yo[va],q)
        line={
            'fold':fold,'block':b,'rows':len(va),'failures':int(yo[va].sum()),'prevalence':float(yo[va].mean()),
            'committee_ap':apq,'committee_auc':safe_auc(yo[va],q),
            'a1_raw_ap':safe_ap(yo[va],pa),'a1_aligned_ap':safe_ap(yo[va],aa),
            'last6_aligned_ap':safe_ap(yo[va],a6),'last4_aligned_ap':safe_ap(yo[va],a4),'recent_aligned_ap':safe_ap(yo[va],recent),
            'rel_raw_ap':safe_ap(yo[va],prel),'rel_aligned_ap':safe_ap(yo[va],ar),'rich_rate':float(rich.mean()),
            'a1_delta_ap':safe_ap(yo[va],aa)-apq,'recent_delta_ap':safe_ap(yo[va],recent)-apq,
            'rel_rich_delta_ap':safe_ap(yo[va][rich],ar[rich])-safe_ap(yo[va][rich],q[rich]) if rich.sum()>5 and np.unique(yo[va][rich]).size==2 else np.nan,
        }
        rows.append(line)
        print(f"  block={b:g} n={len(va):,} committee={apq:.4f} | A1={line['a1_aligned_ap']:.4f} recent={line['recent_aligned_ap']:.4f} rel={line['rel_aligned_ap']:.4f} rich={rich.mean():.1%}")
        ys.append(yo[va]);qs.append(q);a1s.append(aa);recents.append(recent);rels.append(ar);riches.append(rich);block_arr.append(np.full(len(va),b))
        if j==len(blocks)-1 and ma is not None:
            latest_importance=permutation_rows(ma,Zo[va],yo[va],[],seed=args.seed+fold,top_k=0) if False else []
    if not ys:return None,rows,latest_importance
    return {
        'y':np.concatenate(ys),'q':np.concatenate(qs),'a1':np.concatenate(a1s),'recent':np.concatenate(recents),
        'rel':np.concatenate(rels),'rich':np.concatenate(riches),'blocks':np.concatenate(block_arr)
    },rows,latest_importance


def _production_components(Xtr,ytr,frame,Xte,target,names,idx,yo,po,bo,Zo,args,fold):
    # Fit canonical production committee on all historical rows.
    _,pte,qte=fit_production_committee(Xtr,ytr,Xte,seed=args.seed+fold*17,n_estimators=args.n_estimators,hist_max_iter=args.hist_max_iter)
    support_te=chronological_support_features(frame,target)
    Zte,feat_names=build_meta_features(Xte,pte,support_te,names)
    all_idx=np.arange(len(yo)); blocks=sorted(v for v in pd.unique(bo[np.isfinite(bo)]))
    idx6=np.where(np.isin(bo,blocks[-6:]))[0] if blocks else all_idx
    idx4=np.where(np.isin(bo,blocks[-4:]))[0] if blocks else all_idx
    ma=_fit_hgb_window(Zo,yo,all_idx,args,args.seed+fold*300001)
    m6=_fit_hgb_window(Zo,yo,idx6,args,args.seed+fold*300002)
    m4=_fit_hgb_window(Zo,yo,idx4,args,args.seed+fold*300003)
    pa=qte.copy() if ma is None else predict_positive(ma,Zte)
    p6=qte.copy() if m6 is None else predict_positive(m6,Zte)
    p4=qte.copy() if m4 is None else predict_positive(m4,Zte)
    tb=_target_blocks(target)
    aa=_align(pa,qte,tb);a6=_align(p6,qte,tb);a4=_align(p4,qte,tb);recent=(a6+a4)/2;recent_raw=(p6+p4)/2
    prel,rel_info=fit_relational_predict(Xtr,ytr,frame,Xte,target,names,args,args.seed+fold*400000)
    ar=_align(prel,qte,tb)
    return {
        'pte':pte,'q':qte,'support':support_te,'target_blocks':tb,
        'a1_raw':pa,'a1_aligned':aa,'last6_raw':p6,'last6_aligned':a6,'last4_raw':p4,'last4_aligned':a4,
        'recent_raw':recent_raw,'recent_aligned':recent,'rel_raw':prel,'rel_aligned':ar,'rel_info':rel_info,
        'all_model':ma,'Zte':Zte,'feature_names':feat_names,
    }


def _calibration_rows(fold,component,raw,aligned,q,blocks):
    rows=[]
    for b in pd.unique(blocks):
        m=blocks==b
        dr=score_distribution(raw[m]);da=score_distribution(aligned[m]);dq=score_distribution(q[m])
        rows.append({'fold':fold,'block':b,'component':component,'rows':int(m.sum()),
                     **{f'raw_{k}':v for k,v in dr.items()},**{f'aligned_{k}':v for k,v in da.items()},**{f'committee_{k}':v for k,v in dq.items()},
                     'raw_to_aligned_spearman':spearman_rank_corr(raw[m],aligned[m]),
                     'aligned_to_committee_spearman':spearman_rank_corr(aligned[m],q[m])})
    return rows


def _pairwise_corr_rows(fold,frame):
    names=list(frame.keys());rows=[]
    for i,a in enumerate(names):
        for b in names[i:]:
            rows.append({'fold':fold,'a':a,'b':b,'spearman':spearman_rank_corr(frame[a],frame[b])})
    return rows


def run_fold(args,fold,outdir):
    d=load_binary_fold(args.splits_dir,args.faculty,fold)
    if d is None:return None
    Xtr,Xte,ytr,yte,tr,te,names=d
    print('\n'+'='*124)
    print(f'FOLD {fold} | historical={len(ytr):,} target={len(yte):,} raw_features={len(names)} | prevalence={ytr.mean():.2%}->{yte.mean():.2%}')
    print('='*124)
    cf=crossfit_committee(Xtr,ytr,tr,seed=args.seed+fold*31,n_estimators=args.n_estimators,hist_max_iter=args.hist_max_iter,crossfit_folds=args.crossfit_folds,verbose=False)
    idx=np.where(cf.covered_mask)[0]
    Xo=Xtr[idx];yo=ytr[idx];po=cf.probabilities[idx];bo=_numeric_blocks(cf.block_ids[idx])
    support_all=chronological_support_features(tr);support_o=support_all.iloc[idx].reset_index(drop=True)
    Zo,feat_names=build_meta_features(Xo,po,support_o,names)
    preq,preq_rows,_=_prequential_components(Xtr,ytr,tr,names,idx,Xo,yo,po,bo,Zo,support_o,args,fold)
    if preq is None or len(pd.unique(preq['blocks']))<2:
        selected={'w_a1':0.,'w_recent':0.,'rel_alpha':0.,'w_committee':1.,'reason':'committee_fallback_insufficient_prequential_blocks','median_delta_ap':0.,'mean_delta_ap':0.,'worst_delta_ap':0.,'win_rate':0.}
        grid_rows=[]
    else:
        selected,grid_rows=select_robust_weights(
            preq['y'],preq['blocks'],preq['q'],preq['a1'],preq['recent'],preq['rel'],preq['rich'],
            weight_values=args.weight_grid,rel_values=args.rel_alpha_grid,min_median_delta_ap=args.min_median_delta_ap,
            min_win_rate=args.min_win_rate,worst_delta_ap=args.worst_delta_ap,
        )
    print('[Fusion selection]')
    print(f"  weights: committee={selected.get('w_committee',1):.2f} A1={selected['w_a1']:.2f} recent={selected['w_recent']:.2f} rel-rich alpha={selected['rel_alpha']:.2f}")
    print(f"  evidence: median ΔAP={selected.get('median_delta_ap',0):+.4f} mean={selected.get('mean_delta_ap',0):+.4f} worst={selected.get('worst_delta_ap',0):+.4f} wins={selected.get('win_rate',0):.0%} | {selected['reason']}")

    c=_production_components(Xtr,ytr,tr,Xte,te,names,idx,yo,po,bo,Zo,args,fold)
    q=c['q'];rich=np.asarray(c['support']['history_semesters'],int)>=3
    base,final=apply_composite(q,c['a1_aligned'],c['recent_aligned'],c['rel_aligned'],rich,selected['w_a1'],selected['w_recent'],selected['rel_alpha'])
    raw_base,raw_final=apply_composite(q,c['a1_raw'],c['recent_raw'],c['rel_raw'],rich,selected['w_a1'],selected['w_recent'],selected['rel_alpha'])

    print('[Temporal target — component counterfactuals]')
    print_metric_line('committee',yte,q)
    print_metric_line('A1 raw',yte,c['a1_raw'],q);print_metric_line('A1 aligned',yte,c['a1_aligned'],q)
    print_metric_line('recent mean raw',yte,c['recent_raw'],q);print_metric_line('recent mean aligned',yte,c['recent_aligned'],q)
    print_metric_line('relational raw',yte,c['rel_raw'],q);print_metric_line('relational aligned',yte,c['rel_aligned'],q)
    print_metric_line('composite raw',yte,raw_final,q);print_metric_line('composite aligned FINAL',yte,final,q)
    print(f"  history-rich={rich.mean():.1%} | relational cold student/course={c['rel_info'].get('new_student_rate',np.nan):.1%}/{c['rel_info'].get('new_course_rate',np.nan):.1%}")
    print(f"  F2@20% committee={equal_budget_metrics(yte,q,.20)['fbeta']:.4f} final={equal_budget_metrics(yte,final,.20)['fbeta']:.4f}")

    tag=f'{args.faculty}_fold_{fold}'
    reg=_regimes(c['support'])
    score_df=pd.DataFrame({
        'actual':yte,'committee':q,'a1_raw':c['a1_raw'],'a1_aligned':c['a1_aligned'],
        'last6_raw':c['last6_raw'],'last6_aligned':c['last6_aligned'],'last4_raw':c['last4_raw'],'last4_aligned':c['last4_aligned'],
        'recent_raw':c['recent_raw'],'recent_aligned':c['recent_aligned'],'relational_raw':c['rel_raw'],'relational_aligned':c['rel_aligned'],
        'base_composite':base,'raw_composite':raw_final,'suite3_final':final,'history_regime':reg,'target_block':c['target_blocks'],
        **{col:c['support'][col].to_numpy() for col in c['support'].columns},
    })
    score_df.to_csv(outdir/f'{tag}_scores.csv',index=False)
    save_csv(preq_rows,outdir/f'{tag}_prequential_components.csv')
    save_csv([{'fold':fold,**r} for r in grid_rows],outdir/f'{tag}_fusion_grid.csv')
    save_csv([{'fold':fold,**selected}],outdir/f'{tag}_selected_fusion.csv')
    cal=[]
    for nm,raw,aligned in [('a1',c['a1_raw'],c['a1_aligned']),('last6',c['last6_raw'],c['last6_aligned']),('last4',c['last4_raw'],c['last4_aligned']),('relational',c['rel_raw'],c['rel_aligned'])]:
        cal += _calibration_rows(fold,nm,raw,aligned,q,c['target_blocks'])
    save_csv(cal,outdir/f'{tag}_calibration_diagnostics.csv')
    corr=_pairwise_corr_rows(fold,{'committee':q,'a1':c['a1_aligned'],'recent':c['recent_aligned'],'relational':c['rel_aligned'],'final':final})
    save_csv(corr,outdir/f'{tag}_component_correlations.csv')
    regime_rows=[]
    for rg in ['history0','history1_2','history3plus']:
        m=reg==rg
        if not m.any():continue
        for mn,sc in [('committee',q),('a1_aligned',c['a1_aligned']),('recent_aligned',c['recent_aligned']),('relational_aligned',c['rel_aligned']),('final',final)]:
            regime_rows.append({'fold':fold,'regime':rg,'model':mn,'rows':int(m.sum()),'failures':int(yte[m].sum()),'prevalence':float(yte[m].mean()),'ap':safe_ap(yte[m],sc[m]),'auc':safe_auc(yte[m],sc[m])})
    save_csv(regime_rows,outdir/f'{tag}_history_regimes.csv')
    # Permutation importance of production A1 evaluated on target is diagnostic-only and never used for selection.
    imp=[]
    if (not args.skip_importance) and c['all_model'] is not None and np.unique(yte).size==2:
        try:
            imp=permutation_rows(c['all_model'],c['Zte'],yte,c['feature_names'],seed=args.seed+fold,top_k=30)
        except Exception as e:
            print(f'  [importance warning] {e}')
    save_csv([{'fold':fold,'diagnostic_only_target_labels':True,**r} for r in imp],outdir/f'{tag}_a1_feature_importance.csv')
    metrics=[]
    for mn,sc in [('committee',q),('a1_raw',c['a1_raw']),('a1_aligned',c['a1_aligned']),('recent_raw',c['recent_raw']),('recent_aligned',c['recent_aligned']),('relational_aligned',c['rel_aligned']),('raw_composite',raw_final),('suite3_final',final)]:
        eb=equal_budget_metrics(yte,sc,.20)
        metrics.append({'fold':fold,'model':mn,**score_metrics(yte,sc), 'budget20_precision':eb['precision'],'budget20_recall':eb['recall'],'budget20_fbeta':eb['fbeta'],'budget20_flag_rate':eb['flag_rate']})
    save_csv(metrics,outdir/f'{tag}_metrics.csv')
    return FoldRecord(fold,yte,q,final,c['a1_raw'],c['a1_aligned'],c['recent_raw'],c['recent_aligned'],c['rel_raw'],c['rel_aligned'],base,raw_final)


def _summary_rows(split,recs):
    y=np.concatenate([r.y for r in recs]);rows=[]
    fields=['committee','a1_raw','a1_aligned','recent_raw','recent_aligned','relational_aligned','raw_composite','final']
    name_map={'final':'suite3_final'}
    for field in fields:
        s=np.concatenate([getattr(r,field) for r in recs]); eb=equal_budget_metrics(y,s,.20)
        rows.append({'split':split,'model':name_map.get(field,field),**score_metrics(y,s),'budget20_precision':eb['precision'],'budget20_recall':eb['recall'],'budget20_fbeta':eb['fbeta'],'budget20_flag_rate':eb['flag_rate']})
    return rows


def _cm(label,m):
    print(f'  {label}: TN={m["tn"]:,} FP={m["fp"]:,} FN={m["fn"]:,} TP={m["tp"]:,} | P={m["precision"]:.4f} R={m["recall"]:.4f} F1={m["f1"]:.4f} F2={m["fbeta"]:.4f} rate={m["flag_rate"]:.2%}')


def _evaluate_decision_policy(dev,hold,policy,outdir,faculty):
    allrecs=dev+hold;prevmap={r.fold:float(np.mean(r.y)) for r in allrecs};fallback=float(np.mean(np.concatenate([r.y for r in dev])))
    rows=[]
    print('\n>>> FROZEN DEVELOPMENT DECISION POLICY')
    print(f'AP/AUC={policy.development_ap:.4f}/{policy.development_auc:.4f} threshold={policy.threshold:.6f} warning_ratio={policy.warning_ratio:.3f} dev_rate={policy.flag_rate:.2%} F2={policy.fbeta:.4f}')
    for split,recs in [('development',dev),('holdout',hold)]:
        print(f'\n### {split.upper()} — SUITE3 FINAL')
        for r in recs:
            rate=float(np.clip(policy.warning_ratio*prevmap.get(r.fold-1,fallback),1e-4,.99))
            pf=core.apply_decision_rule(r.final,policy.threshold);pred_drift=core.warn_by_rate(r.final,rate)
            qf=core.apply_decision_rule(r.committee,policy.threshold);qd=core.warn_by_rate(r.committee,rate)
            mf=core.report(r.y,r.final,pf,policy.beta);md=core.report(r.y,r.final,pred_drift,policy.beta);mcf=core.report(r.y,r.committee,qf,policy.beta);mcd=core.report(r.y,r.committee,qd,policy.beta)
            print(f'fold {r.fold}: AP/AUC={safe_ap(r.y,r.final):.4f}/{safe_auc(r.y,r.final):.4f} | committee={safe_ap(r.y,r.committee):.4f}/{safe_auc(r.y,r.committee):.4f}')
            _cm('fixed',mf);_cm('drift',md);print(f'    committee counterfactual fixed F2={mcf["fbeta"]:.4f} drift F2={mcd["fbeta"]:.4f}')
            rows += [
                {'split':split,'fold':r.fold,'policy':'fixed','model':'suite3_final',**mf},
                {'split':split,'fold':r.fold,'policy':'drift','model':'suite3_final',**md},
                {'split':split,'fold':r.fold,'policy':'fixed','model':'committee',**mcf},
                {'split':split,'fold':r.fold,'policy':'drift','model':'committee',**mcd},
            ]
        if recs:
            yy=np.concatenate([r.y for r in recs]);ss=np.concatenate([r.final for r in recs]);qq=np.concatenate([r.committee for r in recs])
            # pooled fixed uses frozen threshold; pooled drift concatenates per-fold decisions to preserve rate protocol
            pfix=core.apply_decision_rule(ss,policy.threshold);qfix=core.apply_decision_rule(qq,policy.threshold)
            mf=core.report(yy,ss,pfix,policy.beta);mcf=core.report(yy,qq,qfix,policy.beta);_cm('POOLED fixed',mf)
            rows += [{'split':split,'fold':'POOLED','policy':'fixed','model':'suite3_final',**mf},{'split':split,'fold':'POOLED','policy':'fixed','model':'committee',**mcf}]
    save_csv(rows,outdir/f'{faculty}_warning_metrics.csv')
    pd.DataFrame([policy.__dict__]).to_csv(outdir/f'{faculty}_threshold_policy.csv',index=False)


def parse_args():
    p=argparse.ArgumentParser()
    p.add_argument('--splits_dir',required=True);p.add_argument('--faculty',default='khoa_cong_nghe_thong_tin');p.add_argument('--dev_folds',default='1,2,3,4,5');p.add_argument('--holdout_folds',default='6,7');p.add_argument('--models_dir',default='results/suite3');
    p.add_argument('--seed',type=int,default=42);p.add_argument('--n_estimators',type=int,default=500);p.add_argument('--hist_max_iter',type=int,default=250);p.add_argument('--crossfit_folds',type=int,default=5)
    p.add_argument('--meta_max_iter',type=int,default=250);p.add_argument('--meta_leaf_nodes',type=int,default=31);p.add_argument('--meta_min_leaf',type=int,default=20);p.add_argument('--meta_lr',type=float,default=.05);p.add_argument('--meta_l2',type=float,default=1.0);p.add_argument('--effective_beta',type=float,default=.9999)
    p.add_argument('--prequential_blocks',type=int,default=5);p.add_argument('--transition_min_rows',type=int,default=300);p.add_argument('--transition_min_failures',type=int,default=15);p.add_argument('--min_window_rows',type=int,default=1200);p.add_argument('--min_window_failures',type=int,default=30)
    p.add_argument('--weight_grid',type=lambda s:[float(x) for x in s.split(',')],default=[0,.25,.5,.75,1]);p.add_argument('--rel_alpha_grid',type=lambda s:[float(x) for x in s.split(',')],default=[0,.1,.2,.3,.4]);p.add_argument('--min_median_delta_ap',type=float,default=.001);p.add_argument('--min_win_rate',type=float,default=.6);p.add_argument('--worst_delta_ap',type=float,default=-.005)
    p.add_argument('--top_raw_features',type=int,default=48);p.add_argument('--student_dim',type=int,default=16);p.add_argument('--course_dim',type=int,default=16);p.add_argument('--section_dim',type=int,default=8);p.add_argument('--rel_epochs',type=int,default=40);p.add_argument('--rel_patience',type=int,default=6);p.add_argument('--rel_lr',type=float,default=2e-3);p.add_argument('--rel_batch_size',type=int,default=1024);p.add_argument('--rel_predict_batch',type=int,default=4096);p.add_argument('--rel_min_train_rows',type=int,default=1200);p.add_argument('--rel_val_min_rows',type=int,default=300);p.add_argument('--rel_val_min_failures',type=int,default=15);p.add_argument('--device',choices=['auto','cpu'],default='auto')
    p.add_argument('--skip_importance',action='store_true');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)
    return p.parse_args()


def main():
    a=parse_args();out=Path(a.models_dir);out.mkdir(parents=True,exist_ok=True)
    print('='*124);print('SUITE3 — CALIBRATED TEMPORAL + HISTORY-RICH RELATIONAL COMPOSITE')
    print('Anchor: unchanged RF + ExtraTrees + HistGB simple-mean committee')
    print('Components: all-feature A1 HGB + recent last6/last4 HGB + relational(history>=3)')
    print('Alignment: unlabeled blockwise rank-preserving quantile map -> committee score scale')
    print('Fusion: robust prequential convex grid with exact committee fallback')
    print('='*124)
    dev=[]
    for f in parse_folds(a.dev_folds):
        r=run_fold(a,f,out)
        if r is not None:dev.append(r)
    if not dev:raise RuntimeError('No development folds completed')
    yd=np.concatenate([r.y for r in dev]);sd=np.concatenate([r.final for r in dev])
    policy=core.tune_threshold(yd,sd,None,None,a.threshold_beta,a.min_precision,a.max_warning_ratio,a.min_flags,False)
    print('\n'+'!'*124);print('HOLDOUT: labels do not tune experts, alignment, fusion weights, relational gating, threshold, or warning budget.');print('!'*124)
    hold=[]
    for f in parse_folds(a.holdout_folds):
        r=run_fold(a,f,out)
        if r is not None:hold.append(r)
    rows=_summary_rows('development',dev)+(_summary_rows('holdout',hold) if hold else [])
    save_csv(rows,out/f'{a.faculty}_summary.csv')
    print('\n>>> SCORE SUMMARY')
    for r in rows:print(f"{r['split'].upper():11s} {r['model']:20s} AP/AUC={r['ap']:.4f}/{r['auc']:.4f} F2@20%={r['budget20_fbeta']:.4f}")
    _evaluate_decision_policy(dev,hold,policy,out,a.faculty)
    print('\n'+'='*124);print(f'Completed {len(dev)+len(hold)} folds | outputs: {out}');print('='*124)


if __name__=='__main__':main()
