"""Shared fold/faculty ranking, operational, uncertainty and baseline reporting."""
from __future__ import annotations
from pathlib import Path
import numpy as np
import pandas as pd
from suite28_metrics import safe_ap,safe_auc,metric_dict,print_table,binary_metrics,warn_by_rate,_select_threshold

REFERENCE_ALIASES={
 'suite22':['suite22_safe_blend','safe_blend','final'],
 'suite25':['suite25_committee_blend','committee_blend','final'],
 'suite25_standalone':['suite25_sacr','sacr','primary'],
 'suite23':['suite23_faculty_safe_fusion','faculty_safe_fusion','final'],
 'suite24':['suite24_evidence_residual','evidence_residual','primary'],
 'suite26':['suite26_tair','tair','primary'],
 'suite17':['suite17_hgb_final','suite17_final','final'],
 'suite18':['suite18_hgb_final','suite18_final','final'],
 'suite21':['suite21_guarded_temporal_residual','suite21_guarded','final'],
 'suite14':['suite14_authority_safe_final','suite14','final'],
 'council':['suite4_competence_council','competence_council','council','final'],
 'v2':['failure_probability_lt5','failure_probability','stacked_probability','final']}

def references(roots,fold,rows):
    results={};records=[]
    for name,root in roots.items():
        if not root:continue
        values=np.full(len(rows),np.nan)
        for i,f in enumerate(rows.faculty_names):
            m=rows.faculty==i;root=Path(root);locs=[root/f'fold_{fold}'/f'{f}_scores.csv',root/f'{f}_fold_{fold}_scores.csv',root/f'fold_{fold}'/f'{f}_target_scores.csv',root/f'{f}_fold_{fold}_target_scores.csv',root/f'{f}_fold_{fold}_test_results.csv']
            path=next((p for p in locs if p.exists()),None)
            if path is None:records.append(dict(fold=fold,faculty=f,reference=name,status='missing'));continue
            try:
                df=pd.read_csv(path)
                col=next((k for k in REFERENCE_ALIASES.get(name,[name,'final']) if k in df),None)
                if col is None:raise ValueError(f'No matching output score column in {path}; columns={df.columns.tolist()[:20]}')
                if len(df)!=m.sum():raise ValueError('Row count mismatch')
                actual=next((z for z in ['actual','actual_failure_lt5','y','label','target'] if z in df),None)
                if actual is not None and not np.array_equal(pd.to_numeric(df[actual],errors='coerce').to_numpy().astype(int),rows.y[m]):raise ValueError('Label mismatch')
                # Explicitly mark positional-only reference alignment. Historical files often lack canonical row IDs.
                p=pd.to_numeric(df[col],errors='coerce').to_numpy(float)
                if not np.isfinite(p).all():raise ValueError('Non-finite prediction')
                values[m]=p;records.append(dict(fold=fold,faculty=f,reference=name,status='loaded_positional_label_checked',path=str(path),column=col))
            except Exception as ex:records.append(dict(fold=fold,faculty=f,reference=name,status='ERROR',detail=str(ex)))
        if np.isfinite(values).any():results[name]=values
    return results,records

def rows_metrics(fold,rows,scores):
    output=[]
    for model,s in scores.items():
        s=np.asarray(s,float)
        for i,f in enumerate(rows.faculty_names):
            m=(rows.faculty==i)&np.isfinite(s);yy=rows.y[m]
            if not len(yy):continue
            output.append({'fold':fold,'faculty':f,'model':model,'rows':int(len(yy)),'failures':int(yy.sum()),'prevalence':float(yy.mean()),**metric_dict(yy,s[m])})
    return output

def summaries(df,folds):
    a=df[df.fold.isin(list(folds))];cols=['ap','auc','brier','ece10','fbeta_at_20','precision_at_20','recall_at_20']
    return a.groupby('model',as_index=False).agg(**{k:(k,'mean') for k in cols},faculties=('faculty','nunique'),cells=('ap','count')).sort_values('ap',ascending=False)

def paired(df,primary,other,folds=(6,7)):
    a=df[(df.model==primary)&df.fold.isin(folds)][['fold','faculty','ap','fbeta_at_20']].rename(columns={'ap':'ap_a','fbeta_at_20':'f2_a'})
    b=df[(df.model==other)&df.fold.isin(folds)][['fold','faculty','ap','fbeta_at_20']].rename(columns={'ap':'ap_b','fbeta_at_20':'f2_b'})
    z=a.merge(b,on=['fold','faculty']);z['delta_ap']=z.ap_a-z.ap_b;z['delta_f2']=z.f2_a-z.f2_b
    return z

def bootstrap(y,a,b,cluster,n=200,seed=42):
    rng=np.random.default_rng(seed);cluster=np.asarray(cluster).astype(str);uniq,inv=np.unique(cluster,return_inverse=True);parts=[np.flatnonzero(inv==i) for i in range(len(uniq))]
    if len(uniq)<2 or len(set(y))<2:return (np.nan,np.nan,np.nan,0)
    vals=[]
    for _ in range(n):
        choice=rng.integers(len(uniq),size=len(uniq));ids=np.concatenate([parts[i] for i in choice]);yy=y[ids]
        if len(np.unique(yy))<2:continue
        vals.append(safe_ap(yy,a[ids])-safe_ap(yy,b[ids]))
    return (safe_ap(y,a)-safe_ap(y,b),float(np.quantile(vals,.025)) if vals else np.nan,float(np.quantile(vals,.975)) if vals else np.nan,len(vals))

def stratified(fold,rows,score_a,score_b,course_prior,history_counts):
    labels={'history':[(history_counts==0,'0'),((history_counts>=1)&(history_counts<=4),'1-4'),((history_counts>=5)&(history_counts<=16),'5-16'),(history_counts>=17,'17+')],
            'course_support':[(course_prior==0,'unseen'),((course_prior>0)&(course_prior<10),'rare1-9'),(course_prior>=10,'supported10+')],
            'student_identity':[(history_counts==0,'no_recorded_history'),(history_counts>0,'recorded_history')]}
    out=[]
    for fi,f in enumerate(rows.faculty_names):
        for group,bins in labels.items():
            for mask,label in bins:
                m=mask&(rows.faculty==fi)
                if not m.any():continue
                for name,s in [('primary',score_a),('committee',score_b)]:
                    out.append(dict(fold=fold,faculty=f,stratum=group,group=label,model=name,rows=int(m.sum()),failures=int(rows.y[m].sum()),ap=safe_ap(rows.y[m],s[m]),auc=safe_auc(rows.y[m],s[m])))
    return out

def operational(scores_by_fold,metrics_df,dev_folds=(1,2,3,4,5),holdout=(6,7)):
    """Threshold selected on F1-F5 per faculty/model; F6-F7 never select."""
    pred=[];params=[]
    for (f,model),group in _pool_scores(scores_by_fold,dev_folds).items():
        yy=np.concatenate([x[0] for x in group]);s=np.concatenate([x[1] for x in group])
        if len(set(yy))<2:continue
        thr,rate=_select_threshold(yy,s);params.append(dict(faculty=f,model=model,threshold=thr,dev_flag_rate=rate,dev_rows=len(yy),dev_failures=int(yy.sum())))
        for fold in holdout:
            item=scores_by_fold.get((fold,f,model))
            if item is None:continue
            a,b=item
            for policy in ('fixed','rate'):
                pred_bool=b>=thr if policy=='fixed' else warn_by_rate(b,rate).astype(bool)
                pred.append(dict(fold=fold,faculty=f,model=model,policy=policy,rows=len(a),failures=int(a.sum()),**binary_metrics(a,pred_bool)))
    return pd.DataFrame(params),pd.DataFrame(pred)

def _pool_scores(s,folds):
    out={}
    for (fold,f,m),(y,p) in s.items():
        if fold in folds:out.setdefault((f,m),[]).append((y,p))
    return out
