# -*- coding: utf-8 -*-
from __future__ import annotations
from pathlib import Path
import numpy as np
import pandas as pd
from suite2_common import safe_ap,safe_auc,equal_budget_metrics
from suite7_eval import evaluate_faculty

BUDGETS=(.10,.15,.20,.25)
COMMITTEE='committee';FINAL='suite17_hgb_final';RAW='suite17_hgb_raw';S16='suite16_hgb_final';SHARED='residual_moe_shared';ADAPTER='residual_moe_shared_private';S8='residual_moe_true_specialist';S9C='residual_moe_competitive_candidate';S9F='residual_moe_competitive_final';S10C='semantic_specialist_candidate';S10F='semantic_specialist_final';S11C='opportunity_latent_candidate';S11F='opportunity_latent_final';S14='suite14_authority_safe_final';S13='suite13_committee_preserving_collaborative_moe';S12='suite12_collaborative_evidence_moe';V2='v2_classifier';COUNCIL='suite4_competence_council'

def optional_scores(root,fold,faculty,column,y):
    if not root:return None
    p=Path(root)/f'fold_{fold}'/f'{faculty}_scores.csv'
    if not p.exists():return None
    df=pd.read_csv(p)
    if column not in df:return None
    if 'actual' in df and (len(df)!=len(y) or not np.array_equal(df.actual.to_numpy(int),np.asarray(y,int))):raise ValueError(f'alignment mismatch {p}')
    if len(df)!=len(y):raise ValueError(f'row mismatch {p}')
    return df[column].to_numpy(float)

def v2_score(root,fold,faculty,y):
    if not root:return None
    p=Path(root)/f'{faculty}_fold_{fold}_test_results.csv'
    if not p.exists():return None
    df=pd.read_csv(p)
    if 'actual_failure_lt5' not in df or 'failure_probability_lt5' not in df:return None
    if len(df)!=len(y) or not np.array_equal(df.actual_failure_lt5.to_numpy(int),np.asarray(y,int)):raise ValueError(f'V2 alignment mismatch {p}')
    return df.failure_probability_lt5.to_numpy(float)

def council_score(root,fold,faculty,y):
    if not root:return None
    cand=[Path(root)/f'{faculty}_fold_{fold}_scores.csv',Path(root)/f'fold_{fold}'/f'{faculty}_scores.csv'];p=next((x for x in cand if x.exists()),None)
    if p is None:return None
    df=pd.read_csv(p)
    if 'actual' not in df or 'final' not in df:return None
    if len(df)!=len(y) or not np.array_equal(df.actual.to_numpy(int),np.asarray(y,int)):raise ValueError(f'Council alignment mismatch {p}')
    return df.final.to_numpy(float)

def reference_for_faculty(args,fold,faculty,y,q):
    s={COMMITTEE:np.asarray(q,float)}
    refs=[(SHARED,getattr(args,'shared_results_dir',None),SHARED),(ADAPTER,getattr(args,'suite7_results_dir',None),ADAPTER),(S8,getattr(args,'suite8_results_dir',None),S8),(S9C,getattr(args,'suite9_results_dir',None),S9C),(S9F,getattr(args,'suite9_results_dir',None),S9F),(S10C,getattr(args,'suite10_results_dir',None),S10C),(S10F,getattr(args,'suite10_results_dir',None),S10F),(S11C,getattr(args,'suite11_results_dir',None),S11C),(S11F,getattr(args,'suite11_results_dir',None),S11F),(S12,getattr(args,'suite12_results_dir',None),S12),(S13,getattr(args,'suite13_results_dir',None),S13),(S14,getattr(args,'suite14_results_dir',None),S14),(S16,getattr(args,'suite16_results_dir',None),S16)]
    for key,root,col in refs:
        z=optional_scores(root,fold,faculty,col,y)
        if z is not None:s[key]=z
    z=v2_score(getattr(args,'v2_results_dir',None),fold,faculty,y)
    if z is not None:s[V2]=z
    z=council_score(getattr(args,'council_results_dir',None),fold,faculty,y)
    if z is not None:s[COUNCIL]=z
    return s

def metric_row(fold,faculty,model,y,s,beta=2.):
    r={'fold':int(fold),'faculty':faculty,'model':model,'rows':len(y),'failures':int(np.sum(y)),'prevalence':float(np.mean(y)),'ap':safe_ap(y,s),'auc':safe_auc(y,s)}
    for b in BUDGETS:
        z=equal_budget_metrics(y,s,b,beta);t=int(round(100*b));r[f'precision_at_{t}']=z['precision'];r[f'recall_at_{t}']=z['recall'];r[f'f1_at_{t}']=z['f1'];r[f'f2_at_{t}']=z['fbeta']
    return r

def mean_fold_summary(metrics,holdout):
    d=pd.DataFrame(metrics);d=d[d.fold.isin(holdout)];rows=[]
    for (fac,model),g in d.groupby(['faculty','model']):
        r={'faculty':fac,'model':model,'holdout_folds':len(g),'holdout_rows':int(g.rows.sum())}
        for c in ['ap','auc','precision_at_20','recall_at_20','f1_at_20','f2_at_20']:r[f'mean_fold_{c}']=float(g[c].mean())
        rows.append(r)
    return pd.DataFrame(rows)

def operational(records,faculties,args):
    rows=[];models=sorted(set().union(*[set(r['scores']) for r in records]));primary={COMMITTEE,FINAL,RAW,S16,S14,S13,COUNCIL,V2}
    for model in models:
        for fac in faculties:
            use=[r for r in records if r['faculty']==fac]
            if not use or not all(model in r['scores'] for r in use):continue
            verbose=bool(args.verbose_operational or (fac==args.primary_faculty and model in primary))
            try:_,rr=evaluate_faculty(records,fac,model,args.dev_folds,args.holdout_folds,args.threshold_beta,args.min_precision,args.max_warning_ratio,args.min_flags,verbose=verbose);rows.extend(rr)
            except Exception as e:print(f'[WARN] operational evaluation failed faculty={fac} model={model}: {e}')
    return pd.DataFrame(rows)

def macro_summary(meanf,warning):
    po=warning[warning.fold.astype(str)=='POOLED'] if len(warning) else pd.DataFrame();rows=[]
    for model in sorted(meanf.model.unique()):
        g=meanf[meanf.model==model];r={'model':model,'faculties':g.faculty.nunique()}
        for c in ['mean_fold_ap','mean_fold_auc','mean_fold_precision_at_20','mean_fold_recall_at_20','mean_fold_f1_at_20','mean_fold_f2_at_20']:r[c]=float(g[c].mean())
        for pol in ['fixed','drift']:
            d=po[(po.model==model)&(po.policy==pol)]
            for c in ['precision','recall','f1','fbeta','flag_rate']:r[f'{pol}_{c}']=float(d[c].mean()) if len(d) else np.nan
            for c in ['tp','fn','fp','tn']:r[f'{pol}_{c}_total']=int(d[c].sum()) if len(d) else 0
        rows.append(r)
    return pd.DataFrame(rows).sort_values(['mean_fold_ap','drift_fbeta'],ascending=False,na_position='last')

def print_win_rates(meanf,candidate=FINAL):
    refs=[COMMITTEE,S16,S14,S13,S12,S11C,S11F,S10C,S10F,S9C,S9F,S8,ADAPTER,SHARED,COUNCIL,V2,RAW]
    print(f'\nSUITE17 WIN-RATE AUDIT — candidate={candidate}')
    for ref in refs:
        if ref==candidate:continue
        bits=[]
        for label,col in [('AP','mean_fold_ap'),('F2@20','mean_fold_f2_at_20')]:
            a=meanf[meanf.model==candidate][['faculty',col]].rename(columns={col:'a'});b=meanf[meanf.model==ref][['faculty',col]].rename(columns={col:'b'});d=a.merge(b,on='faculty')
            if len(d):delta=d.a-d.b;bits.append(f'{label}: {(delta>0).sum()}/{len(d)} wins meanΔ={delta.mean():+.4f} medΔ={delta.median():+.4f}')
        if bits:print(f'  vs {ref}: '+' | '.join(bits))

def council_overlap_table(meanf,candidate=FINAL):
    cols=['faculty','mean_fold_ap','mean_fold_auc','mean_fold_f2_at_20','holdout_rows'];a=meanf[meanf.model==candidate][cols].rename(columns={c:f's17_{c}' for c in cols if c!='faculty'});b=meanf[meanf.model==COUNCIL][cols].rename(columns={c:f'council_{c}' for c in cols if c!='faculty'});z=a.merge(b,on='faculty')
    if len(z):
        z['delta_ap']=z.s17_mean_fold_ap-z.council_mean_fold_ap;z['delta_auc']=z.s17_mean_fold_auc-z.council_mean_fold_auc;z['delta_f2_at20']=z.s17_mean_fold_f2_at_20-z.council_mean_fold_f2_at_20;z['rows']=z[['s17_holdout_rows','council_holdout_rows']].min(axis=1)
    return z

def council_overlap_summary(z):
    if z is None or not len(z):return pd.DataFrame()
    w=np.asarray(z.rows,float);w=w/w.sum() if w.sum()>0 else np.ones(len(z))/len(z)
    return pd.DataFrame([{
        'faculties':len(z),'s17_ap_macro':z.s17_mean_fold_ap.mean(),'council_ap_macro':z.council_mean_fold_ap.mean(),'delta_ap_macro':z.delta_ap.mean(),'ap_wins':int((z.delta_ap>0).sum()),
        's17_auc_macro':z.s17_mean_fold_auc.mean(),'council_auc_macro':z.council_mean_fold_auc.mean(),'delta_auc_macro':z.delta_auc.mean(),
        's17_f2_at20_macro':z.s17_mean_fold_f2_at_20.mean(),'council_f2_at20_macro':z.council_mean_fold_f2_at_20.mean(),'delta_f2_at20_macro':z.delta_f2_at20.mean(),
        's17_ap_row_weighted':float(np.sum(w*z.s17_mean_fold_ap)),'council_ap_row_weighted':float(np.sum(w*z.council_mean_fold_ap)),'delta_ap_row_weighted':float(np.sum(w*z.delta_ap))
    }])

def print_table(title,df,cols=None,max_rows=None):
    print('\n'+title);print('-'*min(180,max(80,len(title)+4)));z=df if cols is None else df[[c for c in cols if c in df.columns]]
    if max_rows:z=z.head(int(max_rows))
    print(z.to_string(index=False,float_format=lambda x:f'{x:.4f}'))
