"""Fully row-aligned faculty/fold ranking, calibration and operational reporting."""
from __future__ import annotations
import math
import numpy as np
import pandas as pd
from sklearn.metrics import average_precision_score,roc_auc_score,brier_score_loss,log_loss, confusion_matrix

def at_rate(y,p,rate):
    k=min(len(y),max(1,int(math.ceil(len(y)*rate))))
    m=np.zeros(len(y),bool);m[np.argsort(-np.asarray(p),kind='stable')[:k]]=True
    return m

def binstats(y,pred):
    y=np.asarray(y,int);pred=np.asarray(pred,bool)
    tp=int(((y==1)&pred).sum());tn=int(((y==0)&~pred).sum())
    fp=int(((y==0)&pred).sum());fn=int(((y==1)&~pred).sum())
    prec=tp/max(1,tp+fp);rec=tp/max(1,tp+fn)
    f1=2*prec*rec/max(1e-12,prec+rec)
    f2=5*prec*rec/max(1e-12,4*prec+rec)
    return {'tp':tp,'fp':fp,'fn':fn,'tn':tn,'precision':prec,'recall':rec,'f1':f1,'f2':f2,'flag_rate':float(pred.mean())}

def score(y,p):
    y=np.asarray(y,int);p=np.asarray(p,float)
    if len(y)==0 or len(y)!=len(p) or not np.isfinite(p).all():raise ValueError('Invalid evaluation data')
    p=np.clip(p,1e-8,1-1e-8);two=len(np.unique(y))==2
    bins=np.clip((p*10).astype(int),0,9)
    ece=float(sum(np.mean(bins==i)*abs(y[bins==i].mean()-p[bins==i].mean()) for i in range(10) if (bins==i).any()))
    d={'rows':len(y),'failures':int(y.sum()),'prevalence':float(y.mean()),
       'ap':float(average_precision_score(y,p)) if two else float('nan'),
       'auc':float(roc_auc_score(y,p)) if two else float('nan'),
       'brier':float(brier_score_loss(y,p)),'ece10':ece,
       'logloss':float(log_loss(y,p,labels=[0,1])),'mean_probability':float(p.mean())}
    for rate in (.10,.15,.20,.25):
        st=binstats(y,at_rate(y,p,rate));name=str(round(rate*100))
        for k in ('precision','recall','f1','f2','flag_rate'):d[f'{k}_at_{name}']=st[k]
    return d

def threshold_by_f2(y,p):
    y=np.asarray(y,int);p=np.asarray(p,float)
    if len(np.unique(y))<2:return .5
    cuts=np.unique(np.quantile(p,np.linspace(0,1,101)))
    best=max(cuts,key=lambda c:(binstats(y,p>=c)['f2'],binstats(y,p>=c)['recall'],-binstats(y,p>=c)['flag_rate']))
    return float(best)

def macro(df,folds):
    f=df[df.fold.isin(folds)]
    if f.empty:return pd.DataFrame()
    columns=['ap','auc','brier','ece10','logloss','precision_at_20','recall_at_20','f1_at_20','f2_at_20']
    out=f.groupby('model').agg(cells=('ap','count'),faculty_count=('faculty','nunique'),
          rows=('rows','sum'),failures=('failures','sum'),**{c:(c,'mean') for c in columns}).reset_index()
    return out.sort_values('ap',ascending=False)

def paired(df,a,b,folds):
    z=df[df.fold.isin(folds)]
    aa=z[z.model==a][['fold','faculty','ap','auc','f2_at_20']]
    bb=z[z.model==b][['fold','faculty','ap','auc','f2_at_20']]
    p=aa.merge(bb,on=['fold','faculty'],suffixes=('_a','_b'))
    if p.empty:return None
    d=p.ap_a-p.ap_b
    return {'candidate':a,'reference':b,'cells':int(d.notna().sum()),
            'wins':int((d>0).sum()),'losses':int((d<0).sum()),'ties':int((d==0).sum()),
            'mean_delta_ap':float(d.mean()),'median_delta_ap':float(d.median()),
            'worst_delta_ap':float(d.min()),'mean_delta_auc':float((p.auc_a-p.auc_b).mean()),
            'mean_delta_f2_at_20':float((p.f2_at_20_a-p.f2_at_20_b).mean())}

def operational(preds,dev_folds=(1,2,3,4,5),holdout=(6,7)):
    """Freeze faculty/model threshold on development ONLY; explicitly fails if missing."""
    frame=pd.concat(preds,ignore_index=True) if preds else pd.DataFrame()
    rows=[]
    if frame.empty:return pd.DataFrame()
    for (f,model),block in frame.groupby(['faculty','model']):
        dev=block[block.fold.isin(dev_folds)]; late=block[block.fold.isin(holdout)]
        if dev.empty or late.empty:continue
        threshold=threshold_by_f2(dev.y.to_numpy(),dev.p.to_numpy())
        for fold,cell in late.groupby('fold'):
            y=cell.y.to_numpy();p=cell.p.to_numpy();stats=binstats(y,p>=threshold)
            rows.append({'faculty':f,'model':model,'fold':int(fold),'policy':'dev_frozen_f2',
                         'threshold':threshold,**stats})
    return pd.DataFrame(rows)

def summary_lines(df,folds):
    m=macro(df,folds)
    return m[['model','cells','faculty_count','ap','auc','f2_at_20','brier','ece10']].to_string(index=False,float_format=lambda x:f'{x:.6f}') if len(m) else 'No eligible cells'
