# -*- coding: utf-8 -*-
"""Suite5 — Failure-aware competence Council.

Preserves Suite4's four experts while changing the competence learning problem:
normal-dominated symmetric regret is retained as a counterfactual, but the new
Council learns failure-aware decision utility and boundary-aware competence.
The final gate is selected strictly on historical forward blocks and then
receives a V2/Suite3-compatible frozen decision-policy evaluation.
"""
from __future__ import annotations
import argparse
from types import SimpleNamespace
from dataclasses import dataclass
from pathlib import Path
import numpy as np
import pandas as pd

import train_v3 as core
import suite4_council_reference as legacy
from suite4_common import (
    load_cache, parse_folds, safe_ap, safe_auc, equal_budget_metrics, metric_row,
    print_metrics, save_csv, history_regimes, binary_logloss_each,
    fit_hgb_regressor, summarize_records,
)
from suite5_common import (
    boundary_context, failure_aware_utility, competence_sample_weights,
    mix_council, align_expert_matrix, weight_diagnostics,
    decision_change_diagnostics, choose_robust_candidate,
)

EXPERT_NAMES=['committee','global_hgb','recent_hgb','relational']


def _space(E,score_space):
    return np.asarray(E,float) if score_space=='raw' else align_expert_matrix(E)


def enhanced_features(base_features,E,budget):
    bz,bn,_=boundary_context(E,budget)
    return np.column_stack([np.asarray(base_features,float),bz]),bn


def fit_failure_competence(rows,score_space,args,seed):
    if not rows:return None
    Xs=[];Us=[];Ws=[];infos=[]
    for r in rows:
        E=_space(r['experts'],score_space)
        F,_=enhanced_features(r['features'],E,args.competence_budget)
        U,ui=failure_aware_utility(
            r['y'],E,args.competence_budget,args.positive_regret_scale,
            args.rescue_bonus,args.lost_tp_penalty,args.fp_remove_bonus,
            args.fp_add_penalty,args.utility_boundary_scale,args.utility_cap)
        w,wi=competence_sample_weights(
            r['y'],E,args.competence_budget,args.positive_weight,
            args.missed_failure_weight,args.boundary_sample_weight,args.boundary_sigma)
        Xs.append(F);Us.append(U);Ws.append(w);infos.append({**ui,**wi})
    X=np.concatenate(Xs);U=np.concatenate(Us);w=np.concatenate(Ws)
    models=[]
    for j in range(3):
        models.append(fit_hgb_regressor(
            X,U[:,j],seed+j*19,max_iter=args.competence_max_iter,
            max_leaf_nodes=args.competence_leaf_nodes,
            min_samples_leaf=args.competence_min_leaf,
            learning_rate=args.competence_lr,l2_regularization=args.competence_l2,
            sample_weight=w))
    return {'models':models,'train_rows':len(X),'utility':U,'weights':w,'infos':infos}


def predict_failure_competence(fitted,base_features,E,args):
    if fitted is None:return np.zeros((len(E),3),float)
    F,_=enhanced_features(base_features,E,args.competence_budget)
    return np.column_stack([m.predict(core.clean_X(F)) for m in fitted['models']])


def fit_legacy_competence(rows,args,seed):
    x=legacy.fit_competence(rows,args,seed)
    return None if x is None else x[0]


def predict_legacy_competence(models,F):
    if models is None:return np.zeros((len(F),3),float)
    return legacy.predict_regrets(models,F)


def _uniform_score(E,alpha):
    E=np.asarray(E,float);a=float(alpha)
    if a<=0:return E[:,0].copy(),np.column_stack([np.ones(len(E)),np.zeros((len(E),3))])
    W=np.full(E.shape,1/E.shape[1],float);mix=E.mean(axis=1)
    return np.clip((1-a)*E[:,0]+a*mix,1e-7,1-1e-7),W


def _committee_score(E):
    E=np.asarray(E,float);W=np.column_stack([np.ones(len(E)),np.zeros((len(E),3))])
    return E[:,0].copy(),W


def _apply_candidate(prep,c):
    mode=c['gate_mode'];space=c.get('score_space','raw');alpha=float(c.get('alpha',0.0));temp=float(c.get('temperature',1.0))
    E=prep[f'E_{space}']
    if mode=='committee':return _committee_score(E)
    if mode=='uniform':return _uniform_score(E,alpha)
    if mode=='legacy':return mix_council(E,prep['R_legacy'],alpha,temp)
    if mode=='failure':return mix_council(E,prep[f'R_failure_{space}'],alpha,temp)
    raise ValueError(mode)


def prepare_validation_transitions(rows,args,fold):
    if len(rows)<2:return []
    val_rows=rows[-min(args.competence_val_blocks,len(rows)-1):]
    out=[]
    for vr in val_rows:
        train=[r for r in rows if r['block']<vr['block']]
        if not train:continue
        legacy_models=fit_legacy_competence(train,args,args.seed+fold*31000+int(vr['block']))
        fraw=fit_failure_competence(train,'raw',args,args.seed+fold*32000+int(vr['block']))
        falign=fit_failure_competence(train,'aligned',args,args.seed+fold*33000+int(vr['block']))
        Eraw=np.asarray(vr['experts'],float);Ealigned=align_expert_matrix(Eraw)
        out.append({
            'block':vr['block'],'y':np.asarray(vr['y'],int),
            'E_raw':Eraw,'E_aligned':Ealigned,
            'R_legacy':predict_legacy_competence(legacy_models,vr['features']),
            'R_failure_raw':predict_failure_competence(fraw,vr['features'],Eraw,args),
            'R_failure_aligned':predict_failure_competence(falign,vr['features'],Ealigned,args),
        })
    return out


def policy_candidates(args):
    rows=[{'gate_mode':'committee','score_space':'raw','alpha':0.,'temperature':1.,'name':'committee'}]
    for sp in args.score_spaces:
        for a in args.alpha_grid:
            if a<=0:continue
            rows.append({'gate_mode':'uniform','score_space':sp,'alpha':a,'temperature':1.,'name':f'uniform_{sp}_a{a:g}'})
    for a in args.alpha_grid:
        if a<=0:continue
        for t in args.legacy_temperature_grid:
            rows.append({'gate_mode':'legacy','score_space':'raw','alpha':a,'temperature':t,'name':f'legacy_raw_a{a:g}_t{t:g}'})
    for sp in args.score_spaces:
        for a in args.alpha_grid:
            if a<=0:continue
            for t in args.temperature_grid:
                rows.append({'gate_mode':'failure','score_space':sp,'alpha':a,'temperature':t,'name':f'failure_{sp}_a{a:g}_t{t:g}'})
    return rows


def evaluate_candidates(transitions,args):
    results=[]
    for c in policy_candidates(args):
        dap=[];df2=[];dauc=[];combined=[];eff=[];ent=[];acc_loss=[];acc_utility=[];resc=[];lost=[]
        for tr in transitions:
            p,W=_apply_candidate(tr,c);y=tr['y'];q=tr['E_raw'][:,0]
            bq=equal_budget_metrics(y,q,args.competence_budget,2.0);bp=equal_budget_metrics(y,p,args.competence_budget,2.0)
            da=safe_ap(y,p)-safe_ap(y,q);df=bp['fbeta']-bq['fbeta'];du=safe_auc(y,p)-safe_auc(y,q)
            dap.append(da);df2.append(df);dauc.append(du);combined.append(da+args.selection_f2_weight*df)
            wd=weight_diagnostics(W);eff.append(wd['mean_effective_experts']);ent.append(wd['normalized_entropy'])
            # Diagnostic-only hindsight competence accuracy.
            E=tr[f"E_{c.get('score_space','raw')}"]
            loss=np.column_stack([binary_logloss_each(y,E[:,j]) for j in range(4)])
            true_loss=np.argmin(loss,axis=1);pred=np.argmax(W,axis=1);acc_loss.append(float((true_loss==pred).mean()))
            U,_=failure_aware_utility(y,E,args.competence_budget,args.positive_regret_scale,args.rescue_bonus,args.lost_tp_penalty,args.fp_remove_bonus,args.fp_add_penalty,args.utility_boundary_scale,args.utility_cap)
            util=np.column_stack([np.zeros(len(y)),U]);true_util=np.argmax(util,axis=1);acc_utility.append(float((true_util==pred).mean()))
            dc=decision_change_diagnostics(y,q,p,args.competence_budget);resc.append(dc['rescued_failures']);lost.append(dc['lost_existing_tp'])
        if not dap:
            if c['gate_mode']=='committee':
                results.append({**c,'median_delta_ap':0.,'mean_delta_ap':0.,'worst_delta_ap':0.,'median_delta_f2':0.,'mean_delta_f2':0.,'worst_delta_f2':0.,'combined_win_rate':0.,'mean_effective_experts':4.,'mean_normalized_entropy':1.})
            continue
        results.append({**c,
            'median_delta_ap':float(np.median(dap)),'mean_delta_ap':float(np.mean(dap)),'worst_delta_ap':float(np.min(dap)),
            'median_delta_f2':float(np.median(df2)),'mean_delta_f2':float(np.mean(df2)),'worst_delta_f2':float(np.min(df2)),
            'median_delta_auc':float(np.median(dauc)),'combined_win_rate':float((np.asarray(combined)>0).mean()),
            'mean_effective_experts':float(np.mean(eff)),'mean_normalized_entropy':float(np.mean(ent)),
            'loss_top1_accuracy':float(np.mean(acc_loss)),'failure_utility_top1_accuracy':float(np.mean(acc_utility)),
            'mean_rescued_failures':float(np.mean(resc)),'mean_lost_existing_tp':float(np.mean(lost)),
        })
    if not any(r['gate_mode']=='committee' for r in results):
        results.insert(0,{'gate_mode':'committee','score_space':'raw','alpha':0.,'temperature':1.,'name':'committee','median_delta_ap':0.,'mean_delta_ap':0.,'worst_delta_ap':0.,'median_delta_f2':0.,'mean_delta_f2':0.,'worst_delta_f2':0.,'combined_win_rate':0.,'mean_effective_experts':4.,'mean_normalized_entropy':1.})
    return results


def select_from_grid(grid,args,modes=None):
    rows=grid if modes is None else [r for r in grid if r['gate_mode'] in modes or r['gate_mode']=='committee']
    return choose_robust_candidate(rows,args.min_combined_gain,args.min_win_rate,args.max_worst_ap_drop,args.max_worst_f2_drop,args.selection_f2_weight)


def fit_production_competence(h,args,fold):
    return {
        'legacy':fit_legacy_competence(h['rows'],args,args.seed+fold*80000),
        'failure_raw':fit_failure_competence(h['rows'],'raw',args,args.seed+fold*81002),
        'failure_aligned':fit_failure_competence(h['rows'],'aligned',args,args.seed+fold*81003),
    }


def prepare_target(d,h,args,fold,fit):
    Eraw,Flegacy,fn,rel_info=legacy.production_experts(d,h,args,fold);Ealigned=align_expert_matrix(Eraw)
    return {
        'E_raw':Eraw,'E_aligned':Ealigned,
        'R_legacy':predict_legacy_competence(fit['legacy'],Flegacy),
        'R_failure_raw':predict_failure_competence(fit['failure_raw'],Flegacy,Eraw,args),
        'R_failure_aligned':predict_failure_competence(fit['failure_aligned'],Flegacy,Ealigned,args),
        'Flegacy':Flegacy,'rel_info':rel_info,
    }


def _policy_row(label,c):
    return {'policy_label':label,**{k:v for k,v in c.items() if k not in {'eligible'}}}


def _group_weight_rows(fold,y,q,W,actual_best,pred_best,support):
    regs=history_regimes(support);qwarn=core.warn_by_rate(q,.20).astype(bool)
    masks={
        'all':np.ones(len(y),bool),'failures':y==1,'normals':y==0,
        'missed_failures':(y==1)&(~qwarn),'detected_failures':(y==1)&qwarn,
        'history0':regs=='history0','history1_2':regs=='history1_2','history3plus':regs=='history3plus',
    }
    rows=[]
    for name,m in masks.items():
        if not np.any(m):continue
        wd=weight_diagnostics(W[m]);row={'fold':fold,'group':name,'rows':int(m.sum()),'failures':int(y[m].sum()),
             'top1_accuracy':float((actual_best[m]==pred_best[m]).mean()),**wd}
        for j,en in enumerate(EXPERT_NAMES):row[f'mean_weight_{en}']=float(W[m,j].mean())
        rows.append(row)
    return rows


def exact_suite4_legacy_policy(h,args,fold):
    """Reproduce Suite4 Council policy selection as a diagnostic counterfactual."""
    la=SimpleNamespace(**vars(args))
    la.temperature_grid=list(args.legacy_temperature_grid)
    la.max_worst_drop=float(args.legacy_max_worst_drop)
    la.min_median_gain=float(args.legacy_min_median_gain)
    la.min_win_rate=float(args.legacy_min_win_rate)
    alpha,temp,grid=legacy.select_policy(h['rows'],la,fold)
    return {'alpha':float(alpha),'temperature':float(temp),'grid':grid}


def run_fold(args,fold,out):
    d=load_cache(args.cache_dir,args.faculty,fold)
    print('\n'+'='*132);print(f'SUITE5 FAILURE-AWARE COMPETENCE COUNCIL | fold={fold}');print('='*132)
    h=legacy.make_forward_experts(d,args,fold)
    exact_legacy=exact_suite4_legacy_policy(h,args,fold)
    transitions=prepare_validation_transitions(h['rows'],args,fold);grid=evaluate_candidates(transitions,args)
    final_policy=select_from_grid(grid,args)
    legacy_policy=select_from_grid(grid,args,{'legacy'})
    failure_policy=select_from_grid(grid,args,{'failure'})
    print('[SELECTED FINAL]',final_policy)
    print('[SELECTED LEGACY]',legacy_policy)
    print('[SELECTED FAILURE-AWARE]',failure_policy)
    print('[EXACT SUITE4 LEGACY]',exact_legacy)
    fit=fit_production_competence(h,args,fold);prep=prepare_target(d,h,args,fold,fit)
    y=np.asarray(d['yte'],int);q=np.asarray(d['qte'],float)
    final,W=_apply_candidate(prep,final_policy)
    legacy_p,Wleg=_apply_candidate(prep,legacy_policy)
    failure_p,Wfail=_apply_candidate(prep,failure_policy)
    suite4_exact,Wexact=legacy.council_score(prep['E_raw'],prep['R_legacy'],exact_legacy['alpha'],exact_legacy['temperature'])
    uniform_raw,Wuni=_uniform_score(prep['E_raw'],1.0)
    uniform_aligned,Wunia=_uniform_score(prep['E_aligned'],1.0)
    print('\n>>> TARGET RANKING / EQUAL-BUDGET METRICS')
    for j,en in enumerate(EXPERT_NAMES):
        print_metrics('expert_'+en,y,prep['E_raw'][:,j],q if j>0 else None,args.competence_budget)
    for name,p in [('uniform_raw',uniform_raw),('uniform_aligned',uniform_aligned),('legacy_council',legacy_p),('suite4_legacy_exact',suite4_exact),('failure_aware_council',failure_p),('suite5_final',final)]:
        print_metrics(name,y,p,q if name!='committee' else None,args.competence_budget)
    # Non-deployable diagnostic ceiling using raw experts.
    losses=np.column_stack([binary_logloss_each(y,prep['E_raw'][:,j]) for j in range(4)])
    actual_best=np.argmin(losses,axis=1);oracle=prep['E_raw'][np.arange(len(y)),actual_best]
    pred_best=np.argmax(W,axis=1)
    print_metrics('NON_DEPLOYABLE_best_expert',y,oracle,q,args.competence_budget)
    print(f'[COMPETENCE] top1 logloss-best accuracy={(actual_best==pred_best).mean():.3f} | weights mean={W.mean(axis=0).round(3)}')
    for glab,gm in [('failures',y==1),('normals',y==0)]:
        if np.any(gm):
            cnt=np.bincount(actual_best[gm],minlength=4);print(f'[HINDSIGHT BEST | {glab}] '+', '.join(f'{EXPERT_NAMES[j]}={cnt[j]/cnt.sum():.1%}' for j in range(4)))
    wd=weight_diagnostics(W);print(f"[SPECIALIZATION] normalized_entropy={wd['normalized_entropy']:.3f} effective_experts={wd['mean_effective_experts']:.3f} max_weight={wd['mean_max_weight']:.3f} top1_margin={wd['mean_top1_margin']:.3f}")
    dc=decision_change_diagnostics(y,q,final,args.competence_budget);print('[BUDGET CHANGE]',dc)
    # Diagnostic failure-aware best expert.
    Esel=prep[f"E_{final_policy.get('score_space','raw')}"]
    U,_=failure_aware_utility(y,Esel,args.competence_budget,args.positive_regret_scale,args.rescue_bonus,args.lost_tp_penalty,args.fp_remove_bonus,args.fp_add_penalty,args.utility_boundary_scale,args.utility_cap)
    util=np.column_stack([np.zeros(len(y)),U]);utility_best=np.argmax(util,axis=1)
    print(f'[FAILURE-UTILITY COMPETENCE] top1 accuracy={(utility_best==pred_best).mean():.3f}')
    # Save artifacts.
    tag=f'{args.faculty}_fold_{fold}'
    save_csv([{'fold':fold,**r} for r in grid],out/f'{tag}_policy_grid.csv')
    save_csv([_policy_row('final',final_policy),_policy_row('legacy_combined_selector',legacy_policy),_policy_row('failure_aware',failure_policy),{'policy_label':'suite4_legacy_exact','gate_mode':'legacy','score_space':'raw','alpha':exact_legacy['alpha'],'temperature':exact_legacy['temperature']}],out/f'{tag}_selected_policies.csv')
    wrows=_group_weight_rows(fold,y,q,W,actual_best,pred_best,d['support_target']);save_csv(wrows,out/f'{tag}_weight_diagnostics.csv')
    print('[WEIGHTS BY OUTCOME / SUPPORT]')
    for wr in wrows:
        if wr['group'] in {'failures','normals','missed_failures','detected_failures','history0','history1_2','history3plus'}:
            ww=[wr[f'mean_weight_{n}'] for n in EXPERT_NAMES]
            print(f"  {wr['group']:18s} n={wr['rows']:,} top1_acc={wr['top1_accuracy']:.3f} eff={wr['mean_effective_experts']:.2f} weights={np.round(ww,3)}")
    # Hindsight best-vs-predicted best confusion matrix (diagnostic only).
    cm=np.zeros((4,4),int)
    for a,pb in zip(actual_best,pred_best):cm[int(a),int(pb)]+=1
    cmrows=[]
    for i,a in enumerate(EXPERT_NAMES):
        for j,b in enumerate(EXPERT_NAMES):cmrows.append({'fold':fold,'actual_best_DIAGNOSTIC':a,'predicted_best':b,'rows':int(cm[i,j])})
    save_csv(cmrows,out/f'{tag}_competence_confusion.csv')
    # History-regime score diagnostics.
    regs=history_regimes(d['support_target']);hr=[]
    for g in ['history0','history1_2','history3plus']:
        m=regs==g
        if not np.any(m):continue
        hr.append({'fold':fold,'regime':g,'rows':int(m.sum()),'failures':int(y[m].sum()),'prevalence':float(y[m].mean()),
                   'committee_ap':safe_ap(y[m],q[m]),'final_ap':safe_ap(y[m],final[m]),'committee_auc':safe_auc(y[m],q[m]),'final_auc':safe_auc(y[m],final[m])})
    save_csv(hr,out/f'{tag}_history_regimes.csv')
    pd.DataFrame({
        'actual':y,'committee':q,'global_hgb':prep['E_raw'][:,1],'recent_hgb':prep['E_raw'][:,2],'relational':prep['E_raw'][:,3],
        'uniform_raw':uniform_raw,'uniform_aligned':uniform_aligned,'legacy_council':legacy_p,'suite4_legacy_exact':suite4_exact,'failure_aware_council':failure_p,'suite5_final':final,
        'predicted_best':pred_best,'actual_best_DIAGNOSTIC':actual_best,'failure_utility_best_DIAGNOSTIC':utility_best,
        **{f'weight_{EXPERT_NAMES[j]}':W[:,j] for j in range(4)},
        **{f'failure_pred_utility_{j+1}':prep[f"R_failure_{final_policy.get("score_space","raw")}"][:,j] if final_policy.get('gate_mode')=='failure' else np.full(len(y),np.nan) for j in range(3)}
    }).to_csv(out/f'{tag}_scores.csv',index=False)
    models={'committee':q,'uniform_raw':uniform_raw,'legacy_council':legacy_p,'suite4_legacy_exact':suite4_exact,'failure_aware_council':failure_p,'suite5_final':final,'NON_DEPLOYABLE_best_expert_oracle':oracle}
    save_csv([metric_row(fold,n,y,p,q if n!='committee' else None,args.competence_budget) for n,p in models.items()],out/f'{tag}_metrics.csv')
    return {'fold':fold,'y':y,'scores':models,'committee':q,'final':final,'legacy':legacy_p,'suite4_exact':suite4_exact,'failure':failure_p,'uniform':uniform_raw}


def _cm(label,m):
    print(f'  {label:27s} 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 _record_score(r,model):
    return {
        'suite5_final':r['final'],
        'committee':r['committee'],
        'suite4_legacy_exact':r['suite4_exact'],
        'legacy_council':r['legacy'],
        'failure_aware_council':r['failure'],
        'uniform_raw':r['uniform'],
    }[model]


def tune_model_policies(dev,args):
    models=['suite5_final','suite4_legacy_exact','failure_aware_council','legacy_council','uniform_raw','committee']
    y=np.concatenate([r['y'] for r in dev]);policies={}
    print('\n>>> DEVELOPMENT-SELECTED F2 POLICIES (EACH MODEL TUNED ONLY ON DEVELOPMENT)')
    for model in models:
        s=np.concatenate([_record_score(r,model) for r in dev])
        pol=core.tune_threshold(y,s,None,None,args.threshold_beta,args.min_precision,args.max_warning_ratio,args.min_flags,False)
        policies[model]=pol
        print(f'  {model:28s} AP/AUC={pol.development_ap:.4f}/{pol.development_auc:.4f} threshold={pol.threshold:.6f} warning_ratio={pol.warning_ratio:.3f} dev_rate={pol.flag_rate:.2%} F2={pol.fbeta:.4f}')
    return policies


def evaluate_decision_policies(dev,hold,policies,out,faculty,beta):
    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_models={'suite5_final','committee','suite4_legacy_exact','failure_aware_council'}
    pooled_drift={split:{m:{'y':[],'s':[],'pred':[]} for m in policies} for split in ['development','holdout']}
    for split,recs in [('development',dev),('holdout',hold)]:
        print(f'\n### {split.upper()} — MODEL-SPECIFIC FROZEN PRODUCTION POLICIES')
        for r in recs:
            y=r['y'];print(f'fold {r["fold"]}: prevalence={np.mean(y):.2%}')
            for model,policy in policies.items():
                s=_record_score(r,model)
                rate=float(np.clip(policy.warning_ratio*prevmap.get(r['fold']-1,fallback),1e-4,.99))
                pf=core.apply_decision_rule(s,policy.threshold);pdri=core.warn_by_rate(s,rate)
                mf=core.report(y,s,pf,beta);md=core.report(y,s,pdri,beta)
                if model in print_models:
                    print(f'  {model}: threshold={policy.threshold:.6f} drift_rate={rate:.2%}')
                    _cm('fixed',mf);_cm('drift',md)
                rows += [
                    {'split':split,'fold':r['fold'],'policy':'fixed_own_dev_threshold','model':model,'threshold':policy.threshold,'warning_ratio':policy.warning_ratio,**mf},
                    {'split':split,'fold':r['fold'],'policy':'drift_own_dev_ratio','model':model,'threshold':policy.threshold,'warning_ratio':policy.warning_ratio,**md},
                ]
                pooled_drift[split][model]['y'].append(y);pooled_drift[split][model]['s'].append(s);pooled_drift[split][model]['pred'].append(pdri)
        if recs:
            print(f'\n  {split.upper()} POOLED')
            for model,policy in policies.items():
                yy=np.concatenate([r['y'] for r in recs]);ss=np.concatenate([_record_score(r,model) for r in recs])
                pfix=core.apply_decision_rule(ss,policy.threshold);mf=core.report(yy,ss,pfix,beta)
                yd=np.concatenate(pooled_drift[split][model]['y']);sd=np.concatenate(pooled_drift[split][model]['s']);pdri=np.concatenate(pooled_drift[split][model]['pred']);md=core.report(yd,sd,pdri,beta)
                rows += [
                    {'split':split,'fold':'POOLED','policy':'fixed_own_dev_threshold','model':model,'threshold':policy.threshold,'warning_ratio':policy.warning_ratio,**mf},
                    {'split':split,'fold':'POOLED','policy':'drift_own_dev_ratio','model':model,'threshold':policy.threshold,'warning_ratio':policy.warning_ratio,**md},
                ]
                if model in print_models:
                    print(f'  {model}:')
                    _cm('POOLED fixed',mf);_cm('POOLED drift',md)
    save_csv(rows,out/f'{faculty}_warning_metrics.csv')
    prows=[]
    for model,p in policies.items():prows.append({'model':model,**p.__dict__})
    pd.DataFrame(prows).to_csv(out/f'{faculty}_threshold_policy.csv',index=False)

def parse_args():
    p=argparse.ArgumentParser()
    p.add_argument('--cache_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',required=True)
    p.add_argument('--seed',type=int,default=42);p.add_argument('--effective_beta',type=float,default=.9999);p.add_argument('--recent_blocks',type=int,default=4);p.add_argument('--min_train_rows',type=int,default=800);p.add_argument('--min_block_rows',type=int,default=200);p.add_argument('--min_block_failures',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('--regret_cap',type=float,default=2.5);p.add_argument('--competence_max_iter',type=int,default=250);p.add_argument('--competence_leaf_nodes',type=int,default=15);p.add_argument('--competence_min_leaf',type=int,default=30);p.add_argument('--competence_lr',type=float,default=.04);p.add_argument('--competence_l2',type=float,default=2.0);p.add_argument('--competence_val_blocks',type=int,default=2)
    p.add_argument('--legacy_min_win_rate',type=float,default=.5);p.add_argument('--legacy_max_worst_drop',type=float,default=.01);p.add_argument('--legacy_min_median_gain',type=float,default=0.0)
    p.add_argument('--competence_budget',type=float,default=.20);p.add_argument('--positive_regret_scale',type=float,default=2.0);p.add_argument('--rescue_bonus',type=float,default=1.5);p.add_argument('--lost_tp_penalty',type=float,default=2.0);p.add_argument('--fp_remove_bonus',type=float,default=.35);p.add_argument('--fp_add_penalty',type=float,default=.50);p.add_argument('--utility_boundary_scale',type=float,default=.50);p.add_argument('--utility_cap',type=float,default=3.0)
    p.add_argument('--positive_weight',type=float,default=3.0);p.add_argument('--missed_failure_weight',type=float,default=4.0);p.add_argument('--boundary_sample_weight',type=float,default=1.5);p.add_argument('--boundary_sigma',type=float,default=.10)
    p.add_argument('--alpha_grid',type=lambda s:[float(x) for x in s.split(',')],default=[0,.25,.5,.75,1]);p.add_argument('--legacy_temperature_grid',type=lambda s:[float(x) for x in s.split(',')],default=[.5,1,2]);p.add_argument('--temperature_grid',type=lambda s:[float(x) for x in s.split(',')],default=[.15,.25,.5,1,2,4]);p.add_argument('--score_spaces',type=lambda s:[x.strip() for x in s.split(',')],default=['raw','aligned'])
    p.add_argument('--selection_f2_weight',type=float,default=1.0);p.add_argument('--min_combined_gain',type=float,default=0.0);p.add_argument('--min_win_rate',type=float,default=.5);p.add_argument('--max_worst_ap_drop',type=float,default=-.01);p.add_argument('--max_worst_f2_drop',type=float,default=-.015)
    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=12);p.add_argument('--section_dim',type=int,default=4);p.add_argument('--rel_epochs',type=int,default=60);p.add_argument('--rel_patience',type=int,default=8);p.add_argument('--rel_lr',type=float,default=1e-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('--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('='*132);print('SUITE5 — FAILURE-AWARE COMPETENCE COUNCIL');print('Experts unchanged from Suite4: committee + global HGB + recent HGB + relational')
    print('Gate candidates: uniform | legacy symmetric regret | failure-aware boundary utility')
    print('Specialization: temperature selected prequentially; sharper weights are NOT forced')
    print('Score space: raw vs unlabeled rank-preserving aligned specialists')
    print('='*132)
    dev=[]
    for f in parse_folds(a.dev_folds):dev.append(run_fold(a,f,out))
    policies=tune_model_policies(dev,a)
    print('\n'+'!'*132);print('HOLDOUT: labels do not tune experts, competence models, specialization, score space, thresholds, or warning budgets.');print('!'*132)
    hold=[]
    for f in parse_folds(a.holdout_folds):hold.append(run_fold(a,f,out))
    records={'development':dev,'holdout':hold};rows=summarize_records(records,out,a.faculty)
    print('\n>>> SCORE SUMMARY')
    for r in rows:print(f"{r['split']:11s} {r['model']:38s} pooled AP/AUC={r['ap']:.4f}/{r['auc']:.4f} mean-fold AP={r['mean_fold_ap']:.4f} F2@20={r['mean_fold_f2']:.4f}")
    evaluate_decision_policies(dev,hold,policies,out,a.faculty,a.threshold_beta)
    print('\n'+'='*132);print(f'Completed Suite5 | outputs: {out}');print('='*132)


if __name__=='__main__':main()
