# -*- 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

COMMITTEE='committee';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';S12='suite12_collaborative_evidence_moe';S13='suite13_committee_preserving_collaborative_moe';E13='suite13_e0_global';V2='v2_classifier';COUNCIL='suite4_competence_council';E0='suite14_e0_global';FULL='suite14_full_authority_candidate';CAL='suite14_calibrated_candidate';MODEL='suite14_authority_safe_final';BUDGETS=(.10,.15,.20,.25)

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)}
    roots=[(SHARED,args.shared_results_dir,SHARED),(ADAPTER,args.suite7_results_dir,ADAPTER),(S8,args.suite8_results_dir,S8),(S9C,args.suite9_results_dir,S9C),(S9F,args.suite9_results_dir,S9F),(S10C,args.suite10_results_dir,S10C),(S10F,args.suite10_results_dir,S10F),(S11C,args.suite11_results_dir,S11C),(S11F,args.suite11_results_dir,S11F),(S12,getattr(args,'suite12_results_dir',None),S12),(S13,getattr(args,'suite13_results_dir',None),S13),(E13,getattr(args,'suite13_results_dir',None),E13)]
    for key,root,col in roots:
        z=optional_scores(root,fold,faculty,col,y)
        if z is not None:s[key]=z
    z=v2_score(args.v2_results_dir,fold,faculty,y)
    if z is not None:s[V2]=z
    z=council_score(args.council_results_dir,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':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)}
        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,V2,COUNCIL,S12,S13,E0,FULL,CAL,MODEL,S9F,S10C,S11C}
    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,warning,candidate=MODEL):
    po=warning[warning.fold.astype(str)=='POOLED'] if len(warning) else pd.DataFrame();refs=[COMMITTEE,E0,FULL,CAL,S13,E13,S12,SHARED,ADAPTER,S8,S9C,S9F,S10C,S10F,S11C,S11F,COUNCIL,V2]
    print('\nSUITE14 WIN-RATE AUDIT (overlapping faculties only)')
    for ref in refs:
        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}')
        a=po[(po.model==candidate)&(po.policy=='drift')][['faculty','fbeta']].rename(columns={'fbeta':'a'});b=po[(po.model==ref)&(po.policy=='drift')][['faculty','fbeta']].rename(columns={'fbeta':'b'});d=a.merge(b,on='faculty')
        if len(d):delta=d.a-d.b;bits.append(f'driftF2: {(delta>0).sum()}/{len(d)} wins meanΔ={delta.mean():+.4f} medΔ={delta.median():+.4f}')
        if bits:print(f'  vs {ref}: '+' | '.join(bits))

def representation_cosine(tokens):
    x=np.asarray(tokens,float);rows=[]
    for i in range(x.shape[1]):
        for j in range(i+1,x.shape[1]):
            a=x[:,i];b=x[:,j];den=np.linalg.norm(a,axis=1)*np.linalg.norm(b,axis=1)+1e-12;rows.append({'expert_i':i,'expert_j':j,'mean_cosine':float(np.mean((a*b).sum(1)/den))})
    return rows

def top20_transitions(y,base,cand):
    y=np.asarray(y,int);n=len(y);k=max(1,int(round(.20*n)));pb=np.zeros(n,int);pc=np.zeros(n,int);pb[np.argpartition(base,-k)[-k:]]=1;pc[np.argpartition(cand,-k)[-k:]]=1
    return {'rescued_failures':int(np.sum((y==1)&(pb==0)&(pc==1))),'lost_failures':int(np.sum((y==1)&(pb==1)&(pc==0))),'removed_false_alarms':int(np.sum((y==0)&(pb==1)&(pc==0))),'added_false_alarms':int(np.sum((y==0)&(pb==0)&(pc==1)))}

def _rank_corr(a,b):
    ra=pd.Series(np.asarray(a,float)).rank(method='average').to_numpy();rb=pd.Series(np.asarray(b,float)).rank(method='average').to_numpy();return float(np.corrcoef(ra,rb)[0,1]) if len(ra)>1 and np.std(ra)>0 and np.std(rb)>0 else np.nan

def _top_overlap(a,b,rate=.20):
    n=len(a);k=max(1,int(round(rate*n)));ia=set(np.argpartition(np.asarray(a),-k)[-k:]);ib=set(np.argpartition(np.asarray(b),-k)[-k:]);return float(len(ia&ib)/k)

def e0_retention_diagnostics(y,committee,e0,delta_logit):
    q=np.asarray(committee,float);p=np.asarray(e0,float);d=np.asarray(delta_logit,float)
    return {'e0_delta_ap':safe_ap(y,p)-safe_ap(y,q),'e0_probability_mae':float(np.mean(np.abs(p-q))),'e0_rank_corr':_rank_corr(p,q),'e0_top20_overlap':_top_overlap(p,q,.20),'e0_logit_delta_abs_mean':float(np.mean(np.abs(d))),'e0_logit_delta_abs_p95':float(np.quantile(np.abs(d),.95))}

def mechanism_diagnostics(target,pred):
    target=np.asarray(target,float);pred=np.clip(np.asarray(pred,float),1e-6,1-1e-6);rows=[]
    names=['student_propensity','course_propensity','row_failure','mastery_deficiency']
    for k,name in enumerate(names):
        t=target[:,k];p=pred[:,k];bce=float(np.mean(-(t*np.log(p)+(1-t)*np.log(1-p))));corr=float(np.corrcoef(t,p)[0,1]) if np.std(t)>0 and np.std(p)>0 else np.nan;rows.append({'mechanism':name,'bce':bce,'mae':float(np.mean(np.abs(t-p))),'corr':corr,'ap_if_binary':safe_ap((t>=.5).astype(int),p) if np.unique(t>=.5).size>1 else np.nan})
    return rows
