# -*- coding: utf-8 -*-
"""Paired metrics, external references, operational policy and Suite19 verdicts."""
from __future__ import annotations
from pathlib import Path
import numpy as np
import pandas as pd
from suite19_common import metric_dict, safe_ap, safe_auc, print_table, warn_by_rate


def faculty_fold_rows(fold,faculty_names,faculty_idx,y,scores:dict[str,np.ndarray],beta=2.0):
    y=np.asarray(y,int);fi=np.asarray(faculty_idx,int);rows=[]
    for i,name in enumerate(faculty_names):
        m=fi==i
        if not m.any():continue
        for model,s in scores.items():
            s=np.asarray(s,float);md=metric_dict(y[m],s[m],beta);rows.append({'fold':int(fold),'faculty':name,'model':model,'rows':int(m.sum()),'failures':int(y[m].sum()),'prevalence':float(y[m].mean()),**md})
    return rows


def paired_summary(metrics,candidate,base):
    df=metrics if isinstance(metrics,pd.DataFrame) else pd.DataFrame(metrics)
    needed=['fold','faculty','model','ap','auc','fbeta_at_20'];d=df[[c for c in needed if c in df.columns]].copy()
    a=d[d.model==candidate].drop(columns='model').rename(columns={'ap':'cand_ap','auc':'cand_auc','fbeta_at_20':'cand_f2'});b=d[d.model==base].drop(columns='model').rename(columns={'ap':'base_ap','auc':'base_auc','fbeta_at_20':'base_f2'});z=a.merge(b,on=['fold','faculty'],how='inner')
    if not len(z):return {'candidate':candidate,'base':base,'cells':0,'wins':0,'losses':0,'win_rate':np.nan,'mean_delta_ap':np.nan,'median_delta_ap':np.nan,'q25_delta_ap':np.nan,'mean_delta_auc':np.nan,'mean_delta_f2_at20':np.nan}
    dap=z.cand_ap-z.base_ap;dauc=z.cand_auc-z.base_auc;df2=z.cand_f2-z.base_f2
    return {'candidate':candidate,'base':base,'cells':int(len(z)),'wins':int((dap>0).sum()),'losses':int((dap<0).sum()),'win_rate':float((dap>0).mean()),'mean_delta_ap':float(dap.mean()),'median_delta_ap':float(dap.median()),'q25_delta_ap':float(dap.quantile(.25)),'mean_delta_auc':float(dauc.mean()),'mean_delta_f2_at20':float(df2.mean())}


def paired_table(metrics,candidate,base):
    df=metrics if isinstance(metrics,pd.DataFrame) else pd.DataFrame(metrics)
    a=df[df.model==candidate][['fold','faculty','rows','failures','ap','auc','fbeta_at_20']].rename(columns={'rows':'candidate_rows','failures':'candidate_failures','ap':'candidate_ap','auc':'candidate_auc','fbeta_at_20':'candidate_f2_at20'});b=df[df.model==base][['fold','faculty','rows','failures','ap','auc','fbeta_at_20']].rename(columns={'rows':'base_rows','failures':'base_failures','ap':'base_ap','auc':'base_auc','fbeta_at_20':'base_f2_at20'});z=a.merge(b,on=['fold','faculty'])
    if len(z):z['delta_ap']=z.candidate_ap-z.base_ap;z['delta_auc']=z.candidate_auc-z.base_auc;z['delta_f2_at20']=z.candidate_f2_at20-z.base_f2_at20;z['win']=np.where(z.delta_ap>0,'WIN',np.where(z.delta_ap<0,'LOSS','TIE'))
    return z


def bootstrap_ci(values,seed=42,n_boot=4000,alpha=.05):
    v=np.asarray(values,float);v=v[np.isfinite(v)]
    if len(v)==0:return (np.nan,np.nan,np.nan)
    rng=np.random.default_rng(seed);means=np.empty(int(n_boot),float)
    for i in range(int(n_boot)):means[i]=np.mean(rng.choice(v,len(v),replace=True))
    return float(np.mean(v)),float(np.quantile(means,alpha/2)),float(np.quantile(means,1-alpha/2))


def classify_verdict(conditional_delta_ap,f6_delta_ap,f7_delta_ap,win_rate,it_delta_ap,dominated_by_control):
    d=float(conditional_delta_ap) if np.isfinite(conditional_delta_ap) else -np.inf;f6=float(f6_delta_ap) if np.isfinite(f6_delta_ap) else -np.inf;f7=float(f7_delta_ap) if np.isfinite(f7_delta_ap) else -np.inf;wr=float(win_rate) if np.isfinite(win_rate) else 0.;it=float(it_delta_ap) if np.isfinite(it_delta_ap) else -np.inf
    if dominated_by_control or d<=0:return 'REJECT'
    if d>=.010 and f6>0 and f7>0 and wr>=.60 and it>=-.005:return 'BREAKTHROUGH'
    if d>=.005 and f6>0 and f7>0 and wr>=.55 and it>=-.005:return 'PROMISING'
    return 'WEAK'


def _score_file_candidates(root,fold,faculty):
    r=Path(root);return [r/f'fold_{fold}'/f'{faculty}_scores.csv',r/f'{faculty}_fold_{fold}_scores.csv',r/f'fold_{fold}'/f'{faculty}_target_scores.csv',r/f'{faculty}_fold_{fold}_target_scores.csv',r/f'{faculty}_fold_{fold}_test_results.csv']


def load_reference_score(root,fold,faculty,y,column_aliases,actual_aliases=('actual','actual_failure_lt5','y','label','target')):
    if not root:return None,None,None
    p=next((x for x in _score_file_candidates(root,fold,faculty) if x.exists()),None)
    if p is None:return None,None,None
    df=pd.read_csv(p);actual=next((c for c in actual_aliases if c in df.columns),None)
    if actual is not None:
        av=pd.to_numeric(df[actual],errors='coerce').to_numpy()
        if len(df)!=len(y) or not np.array_equal(av.astype(int),np.asarray(y,int)):raise ValueError(f'reference alignment mismatch: {p}')
    col=next((c for c in column_aliases if c in df.columns),None)
    if col is None:return None,p,None
    s=pd.to_numeric(df[col],errors='coerce').to_numpy(float)
    if len(s)!=len(y) or not np.isfinite(s).all():raise ValueError(f'invalid reference score {p}:{col}')
    return s,p,col


REFERENCE_ALIASES={
    'suite17_final':['suite17_hgb_final','suite17_final','final'],
    'suite17_raw':['suite17_hgb_raw','suite17_raw','raw'],
    'suite18_final':['suite18_hgb_final','suite18_final','final'],
    'suite18_raw':['suite18_hgb_raw','suite18_raw','raw'],
    'suite16':['suite16_hgb_final','suite16_conditional_tree_boosting','suite16','final'],
    'suite14':['suite14_authority_safe_final','suite14','final'],
    'v2':['failure_probability_lt5','failure_probability','v2','final','stacked_probability','stacked_prob'],
    'council':['suite4_competence_council','council','final','council_probability'],
}


def reference_scores_for_faculty(reference_dirs:dict[str,str],fold,faculty,y):
    out={};meta=[]
    for name,root in (reference_dirs or {}).items():
        aliases=REFERENCE_ALIASES.get(name,[name,'final'])
        try:s,p,col=load_reference_score(root,fold,faculty,y,aliases)
        except Exception as e:meta.append({'reference':name,'faculty':faculty,'fold':fold,'status':'error','detail':str(e)});continue
        if s is not None:out[name]=s;meta.append({'reference':name,'faculty':faculty,'fold':fold,'status':'loaded','path':str(p),'column':col})
        else:meta.append({'reference':name,'faculty':faculty,'fold':fold,'status':'missing','path':str(p) if p else '','column':''})
    return out,meta


def summarize_encoder_verdict(encoder_name,metrics_df,holdout_folds=(6,7),raw_model='raw_hgb',candidate_model='committee_residual',pca_summary=None,random_summary=None,primary_faculty='khoa_cong_nghe_thong_tin',business_faculty_keywords=('kinh_doanh','du_lich','business','tourism'),native_ap=np.nan,linear_ap=np.nan,hgb_z_ap=np.nan,hgb_xz_ap=np.nan,raw_hgb_ap=np.nan,runtime=np.nan,latent_dim=np.nan,effective_rank_value=np.nan,native_metric_ap=np.nan):
    d=metrics_df.copy();hold=d[d.fold.isin(list(holdout_folds))];summ=paired_summary(hold,candidate_model,'committee') if 'committee' in set(hold.model) else {'mean_delta_ap':np.nan,'win_rate':np.nan,'wins':0,'cells':0};raw=paired_summary(hold,'hgb_xz',raw_model) if 'hgb_xz' in set(hold.model) and raw_model in set(hold.model) else {'mean_delta_ap':np.nan}
    def fold_delta(f):return paired_summary(hold[hold.fold==f],candidate_model,'committee').get('mean_delta_ap',np.nan)
    f6=fold_delta(holdout_folds[0]) if len(holdout_folds)>0 else np.nan;f7=fold_delta(holdout_folds[1]) if len(holdout_folds)>1 else np.nan
    it=hold[hold.faculty==primary_faculty];its=paired_summary(it,candidate_model,'committee').get('mean_delta_ap',np.nan) if len(it) else np.nan;biz=hold[hold.faculty.astype(str).str.lower().apply(lambda s:any(k in s for k in business_faculty_keywords))];bizd=paired_summary(biz,candidate_model,'committee').get('mean_delta_ap',np.nan) if len(biz) else np.nan
    controls=[x for x in [pca_summary,random_summary] if x is not None and np.isfinite(x)];dominated=bool(controls and np.isfinite(raw.get('mean_delta_ap',np.nan)) and raw['mean_delta_ap']<=max(controls)+1e-4);verdict=classify_verdict(summ.get('mean_delta_ap',np.nan),f6,f7,summ.get('win_rate',np.nan),its,dominated)
    f2=paired_summary(hold,candidate_model,'committee').get('mean_delta_f2_at20',np.nan)
    return {'encoder':encoder_name,'direct_native_ap':native_ap,'native_metric_ap':native_metric_ap,'linear_z_ap':linear_ap,'hgb_z_ap':hgb_z_ap,'hgb_xz_ap':hgb_xz_ap,'raw_hgb_x_ap':raw_hgb_ap,'delta_ap_from_xz':raw.get('mean_delta_ap',np.nan),'committee_residual_delta_ap':summ.get('mean_delta_ap',np.nan),'holdout_f6_delta_ap':f6,'holdout_f7_delta_ap':f7,'faculty_ap_wins':summ.get('wins',0),'faculty_cells':summ.get('cells',0),'faculty_win_rate':summ.get('win_rate',np.nan),'f2_at20_delta':f2,'it_delta_ap':its,'business_delta_ap':bizd,'runtime_seconds':runtime,'latent_dim':latent_dim,'effective_rank':effective_rank_value,'dominated_by_control':dominated,'verdict':verdict}


def next_architecture_decision(verdict_df):
    if verdict_df is None or not len(verdict_df):return 'No encoder evidence was available; do not redesign Suite20 yet.'
    z=verdict_df.copy();rank={'BREAKTHROUGH':3,'PROMISING':2,'WEAK':1,'REJECT':0};z['_r']=z.verdict.map(rank).fillna(0);z=z.sort_values(['_r','committee_residual_delta_ap','delta_ap_from_xz'],ascending=False);best=z.iloc[0]
    if best.verdict in {'BREAKTHROUGH','PROMISING'}:
        n=str(best.encoder).lower()
        if 'nca' in n:return 'ModernNCA/metric learning is the strongest representation principle: design Suite20 as chronology-safe retrieval/memory over learned academic-state embeddings, optionally using R/M mechanisms as representation supervision rather than downstream correction.'
        if 'tabm' in n:return 'TabM is the strongest representation principle: design Suite20 as a learned encoder/consumer audit comparing a neural head against HGB/tree consumers before choosing an end-to-end architecture.'
        if 'rfm' in n:return 'RFM/AGOP is the strongest representation principle: design Suite20 around learned supervised metrics/features consumed by trees, with xRFM-style locality considered only after confirming the audit.'
    return 'No representation reached PROMISING status. Representation-first learning has not exposed enough stable conditional information; Suite20 should investigate a more fundamental prediction architecture rather than incremental encoder tuning.'


def _binary_metrics(y,s,pred,beta=2.0):
    y=np.asarray(y,int);pred=np.asarray(pred,bool);tp=int(np.sum(pred&(y==1)));fp=int(np.sum(pred&(y==0)));fn=int(np.sum((~pred)&(y==1)));tn=int(np.sum((~pred)&(y==0)));p=tp/max(tp+fp,1);r=tp/max(tp+fn,1);f1=2*p*r/max(p+r,1e-12);b2=beta*beta;fb=(1+b2)*p*r/max(b2*p+r,1e-12);return {'precision':float(p),'recall':float(r),'f1':float(f1),'fbeta':float(fb),'flag_rate':float(pred.mean()),'tp':tp,'fp':fp,'fn':fn,'tn':tn,'accuracy':float((pred==y).mean())}


def _select_threshold(y,s,beta=2.0):
    y=np.asarray(y,int);s=np.asarray(s,float)
    if len(y)==0:return .5,.2
    qs=np.unique(np.quantile(s,np.linspace(0.001,.999,min(500,max(30,len(s))))));best=None
    for t in qs:
        m=_binary_metrics(y,s,s>=t,beta);key=(m['fbeta'],m['recall'],m['precision'],-m['flag_rate'])
        if best is None or key>best[0]:best=(key,float(t),m)
    return best[1],best[2]['flag_rate']


def operational_metrics(records,dev_folds,holdout_folds,beta=2.0):
    """Frozen development threshold + fixed warning-ratio drift policy.

    The warning ratio is selected from pooled development.  Holdout fold f uses
    prevalence from fold f-1 when available, otherwise pooled development
    prevalence, matching the project's walk-forward operational interpretation.
    """
    rows=[];faculties=sorted({r['faculty'] for r in records});models=sorted(set().union(*[set(r['scores']) for r in records]))
    for fac in faculties:
        rr=[r for r in records if r['faculty']==fac];prev={int(r['fold']):float(np.mean(r['y'])) for r in rr};devprev=float(np.mean(np.concatenate([r['y'] for r in rr if r['fold'] in dev_folds]))) if any(r['fold'] in dev_folds for r in rr) else np.nan
        for model in models:
            dev=[r for r in rr if r['fold'] in dev_folds and model in r['scores']];hold=[r for r in rr if r['fold'] in holdout_folds and model in r['scores']]
            if not dev or not hold:continue
            yd=np.concatenate([np.asarray(r['y'],int) for r in dev]);sd=np.concatenate([np.asarray(r['scores'][model],float) for r in dev]);thr,dev_rate=_select_threshold(yd,sd,beta);ratio=dev_rate/max(float(yd.mean()),1e-6);pool={k:{'y':[],'pred':[]} for k in ('fixed','drift')}
            for r in sorted(hold,key=lambda x:x['fold']):
                y=np.asarray(r['y'],int);s=np.asarray(r['scores'][model],float);rate=float(np.clip(ratio*prev.get(int(r['fold'])-1,devprev),1e-4,.99));preds={'fixed':s>=thr,'drift':warn_by_rate(s,rate).astype(bool)}
                for pol,pred in preds.items():m=_binary_metrics(y,s,pred,beta);rows.append({'faculty':fac,'model':model,'fold':int(r['fold']),'policy':pol,'dev_selected_threshold':thr,'dev_selected_flag_rate':dev_rate,'warning_ratio':ratio,'ap':safe_ap(y,s),'auc':safe_auc(y,s),**m});pool[pol]['y'].append(y);pool[pol]['pred'].append(pred)
            for pol,z in pool.items():
                y=np.concatenate(z['y']);pred=np.concatenate(z['pred']);s=np.concatenate([np.asarray(r['scores'][model],float) for r in sorted(hold,key=lambda x:x['fold'])]);m=_binary_metrics(y,s,pred,beta);rows.append({'faculty':fac,'model':model,'fold':'POOLED','policy':pol,'dev_selected_threshold':thr,'dev_selected_flag_rate':dev_rate,'warning_ratio':ratio,'ap':safe_ap(y,s),'auc':safe_auc(y,s),**m})
    return pd.DataFrame(rows)


def detailed_faculty_section(metrics_df,faculty,models=None):
    d=metrics_df[metrics_df.faculty==faculty].copy()
    if models is not None:d=d[d.model.isin(models)]
    return d.sort_values(['fold','model'])


def print_verdict_table(df):print_table('SUITE19 REPRESENTATION VERDICT',df)
