# -*- coding: utf-8 -*-
from __future__ import annotations
from dataclasses import dataclass
from pathlib import Path
import json, math, os, random
import numpy as np
import pandas as pd
from sklearn.metrics import average_precision_score, roc_auc_score

EPS = 1e-8


def set_seed(seed:int):
    random.seed(seed); np.random.seed(seed)
    try:
        import torch
        torch.manual_seed(seed)
        if torch.cuda.is_available(): torch.cuda.manual_seed_all(seed)
    except Exception:
        pass


def safe_ap(y, s):
    y=np.asarray(y,int); s=np.asarray(s,float)
    if len(y)==0 or np.unique(y).size<2: return float('nan')
    return float(average_precision_score(y,s))


def safe_auc(y,s):
    y=np.asarray(y,int); s=np.asarray(s,float)
    if len(y)==0 or np.unique(y).size<2: return float('nan')
    return float(roc_auc_score(y,s))


def brier(y,s):
    y=np.asarray(y,float); s=np.asarray(s,float)
    return float(np.mean((s-y)**2)) if len(y) else float('nan')


def ece(y,s,bins=10):
    y=np.asarray(y,float); s=np.clip(np.asarray(s,float),0,1)
    if not len(y): return float('nan')
    edges=np.linspace(0,1,bins+1); out=0.
    for i in range(bins):
        m=(s>=edges[i]) & ((s<edges[i+1]) if i<bins-1 else (s<=edges[i+1]))
        if m.any(): out += float(m.mean())*abs(float(s[m].mean())-float(y[m].mean()))
    return float(out)


def warn_by_rate(score, rate):
    s=np.asarray(score,float); n=len(s)
    if n==0:return np.zeros(0,np.int8)
    k=int(np.clip(round(float(rate)*n),1,n))
    order=np.argsort(-s,kind='mergesort'); out=np.zeros(n,np.int8); out[order[:k]]=1; return out


def binary_metrics(y,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)))
    precision=tp/max(tp+fp,1); recall=tp/max(tp+fn,1); f1=2*precision*recall/max(precision+recall,EPS); b2=beta*beta; fb=(1+b2)*precision*recall/max(b2*precision+recall,EPS)
    return dict(precision=float(precision),recall=float(recall),f1=float(f1),fbeta=float(fb),tp=tp,fp=fp,fn=fn,tn=tn,flag_rate=float(pred.mean()) if len(pred) else np.nan,accuracy=float((pred==y).mean()) if len(y) else np.nan)


def metric_dict(y,s,beta=2.0):
    y=np.asarray(y,int); s=np.asarray(s,float)
    out={'ap':safe_ap(y,s),'auc':safe_auc(y,s),'brier':brier(y,s),'ece10':ece(y,s,10),'mean_score':float(np.mean(s)) if len(s) else np.nan,'calibration_gap':float(np.mean(s)-np.mean(y)) if len(s) else np.nan}
    for rate in (.10,.15,.20,.25):
        m=binary_metrics(y,warn_by_rate(s,rate),beta)
        tag=str(int(rate*100))
        out[f'precision_at_{tag}']=m['precision'];out[f'recall_at_{tag}']=m['recall'];out[f'f1_at_{tag}']=m['f1'];out[f'fbeta_at_{tag}']=m['fbeta']
    return out


def latest_block_split(faculty_idx, blocks, val_blocks=3):
    faculty_idx=np.asarray(faculty_idx,int); blocks=np.asarray(blocks,float)
    tr=np.zeros(len(blocks),bool); va=np.zeros(len(blocks),bool)
    for fi in np.unique(faculty_idx):
        m=(faculty_idx==fi)&np.isfinite(blocks); ub=sorted(pd.unique(blocks[m]))
        if len(ub)<=1: tr[m]=True; continue
        nv=min(int(val_blocks),len(ub)-1); vb=set(ub[-nv:]); va[m&np.isin(blocks,list(vb))]=True; tr[m&(~np.isin(blocks,list(vb)))]=True
    return tr,va


def faculty_sampling_weights(faculty_idx,n_faculties):
    f=np.asarray(faculty_idx,int); w=np.zeros(len(f),float)
    for i in range(int(n_faculties)):
        m=f==i; n=int(m.sum())
        if n: w[m]=1.0/n
    w*=len(w)/max(w.sum(),EPS); return w.astype(np.float64)


def semester_ordinal(value):
    try:
        x=int(float(value)); y=x//10; t=x%10
        return y*3+(t-1) if t in (1,2,3) else None
    except Exception:return None


def semester_distance(target,event):
    a=semester_ordinal(target); b=semester_ordinal(event)
    return float(a-b) if a is not None and b is not None else np.nan


def stable_hash(*parts):
    import hashlib
    h=hashlib.blake2b('|'.join(map(str,parts)).encode('utf8'),digest_size=8).digest()
    return int.from_bytes(h,'little',signed=False)


def logit(p):
    p=np.clip(np.asarray(p,float),1e-6,1-1e-6); return np.log(p/(1-p))


def sigmoid(z):
    z=np.asarray(z,float); return 1/(1+np.exp(-np.clip(z,-40,40)))


def blend_logits(committee, graph, alpha):
    return sigmoid((1-float(alpha))*logit(committee)+float(alpha)*logit(graph))


def _select_threshold(y,s,beta=2.0):
    y=np.asarray(y,int); s=np.asarray(s,float)
    qs=np.unique(np.quantile(s,np.linspace(.001,.999,min(600,max(50,len(s)))))) if len(s) else np.array([.5])
    best=None
    for t in qs:
        m=binary_metrics(y,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 print_table(title,df,max_rows=200):
    print('\n'+title); print('-'*max(80,len(title)))
    d=pd.DataFrame(df)
    if len(d)>max_rows: d=d.head(max_rows)
    with pd.option_context('display.max_columns',200,'display.width',260,'display.max_colwidth',50):print(d.to_string(index=False))


def save_json(obj,path):
    Path(path).parent.mkdir(parents=True,exist_ok=True)
    Path(path).write_text(json.dumps(obj,indent=2,default=lambda x: x.item() if hasattr(x,'item') else str(x)))


def discover_faculties(cache_dir,fold=1):
    p=Path(cache_dir); out=[]
    for fp in sorted(p.glob(f'*_fold_{int(fold)}.joblib')): out.append(fp.name[:-len(f'_fold_{int(fold)}.joblib')])
    if not out: raise FileNotFoundError(f'No canonical cache files under {p}')
    return out


def parse_faculties(value,available):
    if value is None or str(value).strip().lower() in {'','all','auto'}: return list(available)
    wanted=[x.strip() for x in str(value).split(',') if x.strip()]; missing=[x for x in wanted if x not in available]
    if missing: raise ValueError(f'Unknown faculties: {missing}')
    return wanted

@dataclass
class QueryBundle:
    y:np.ndarray; committee:np.ndarray; faculty_idx:np.ndarray; blocks:np.ndarray; row_index:np.ndarray
    student_id:np.ndarray; course_id:np.ndarray; target_semester:np.ndarray; faculty_names:list[str]
    def subset(self,mask):
        m=np.asarray(mask,bool)
        return QueryBundle(self.y[m],self.committee[m],self.faculty_idx[m],self.blocks[m],self.row_index[m],self.student_id[m],self.course_id[m],self.target_semester[m],self.faculty_names)


def _committee_mean(x):
    a=np.asarray(x,float); return np.clip(a.mean(axis=1),1e-6,1-1e-6)


def load_query_bundles(cache_dir,faculties,fold):
    import joblib
    hist=[]; target=[]
    for fi,f in enumerate(faculties):
        d=joblib.load(Path(cache_dir)/f'{f}_fold_{int(fold)}.joblib')
        cf=np.asarray(d['cf_probabilities'],float); m=np.asarray(d['cf_covered_mask'],bool)&np.isfinite(cf).all(1)
        key='cf_block_ids' if 'cf_block_ids' in d else 'train_groups'; blocks=pd.to_numeric(pd.Series(np.asarray(d.get(key,np.full(len(m),np.nan)),dtype=object)[m]),errors='coerce').to_numpy(float)
        if not np.isfinite(blocks).all(): raise ValueError(f'Non-finite historical temporal blocks {f} F{fold}')
        fr=d['train_frame'].iloc[np.where(m)[0]].reset_index(drop=True)
        sem=pd.to_numeric(fr['target_NHHK'],errors='coerce').to_numpy(float)
        if not np.isfinite(sem).all(): raise ValueError(f'Non-finite target_NHHK in historical frame {f} F{fold}')
        hist.append(QueryBundle(np.asarray(d['ytr'],int)[m],_committee_mean(cf[m]),np.full(m.sum(),fi,np.int16),blocks,np.where(m)[0].astype(np.int32),fr['IDSV'].astype(str).to_numpy(),fr['IDMH'].astype(str).to_numpy(),sem,list(faculties)))
        ft=d['test_frame'].reset_index(drop=True); semt=pd.to_numeric(ft['target_NHHK'],errors='coerce').to_numpy(float)
        try:
            import train_v3 as core; tb,_=core.extract_temporal_groups(d['test_frame']); tb=np.asarray(tb,float)
        except Exception: tb=np.full(len(ft),float(fold),float)
        target.append(QueryBundle(np.asarray(d['yte'],int),np.asarray(d['qte'],float),np.full(len(ft),fi,np.int16),tb,np.arange(len(ft),dtype=np.int32),ft['IDSV'].astype(str).to_numpy(),ft['IDMH'].astype(str).to_numpy(),semt,list(faculties)))
    def cat(parts):
        return QueryBundle(*(np.concatenate([getattr(p,k) for p in parts]) for k in ['y','committee','faculty_idx','blocks','row_index','student_id','course_id','target_semester']),faculty_names=list(faculties))
    return cat(hist),cat(target)


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


def macro_summary(metrics,folds=None):
    d=pd.DataFrame(metrics)
    if folds is not None:d=d[d.fold.isin(list(folds))]
    cols=['ap','auc','brier','ece10','mean_score','calibration_gap','precision_at_20','recall_at_20','f1_at_20','fbeta_at_20']
    return d.groupby('model',as_index=False).agg(faculties=('faculty','nunique'),**{f'mean_fold_{c}':(c,'mean') for c in cols}).sort_values('mean_fold_ap',ascending=False)


def paired_summary(metrics,candidate,base,folds=None):
    d=pd.DataFrame(metrics)
    if folds is not None:d=d[d.fold.isin(list(folds))]
    a=d[d.model==candidate][['fold','faculty','ap','auc','fbeta_at_20']].rename(columns={'ap':'a_ap','auc':'a_auc','fbeta_at_20':'a_f2'})
    b=d[d.model==base][['fold','faculty','ap','auc','fbeta_at_20']].rename(columns={'ap':'b_ap','auc':'b_auc','fbeta_at_20':'b_f2'})
    z=a.merge(b,on=['fold','faculty'])
    if not len(z):return {'candidate':candidate,'base':base,'cells':0}
    x=z.a_ap-z.b_ap
    return {'candidate':candidate,'base':base,'cells':len(z),'wins':int((x>0).sum()),'losses':int((x<0).sum()),'mean_delta_ap':float(x.mean()),'median_delta_ap':float(x.median()),'worst_delta_ap':float(x.min()),'mean_delta_auc':float((z.a_auc-z.b_auc).mean()),'mean_delta_f2_at20':float((z.a_f2-z.b_f2).mean())}


def operational_metrics(records,dev_folds=(1,2,3,4,5),holdout_folds=(6,7),beta=2.0):
    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 int(r['fold']) in dev_folds])))
        for model in models:
            dev=[r for r in rr if int(r['fold']) in dev_folds and model in r['scores']]; hold=[r for r in rr if int(r['fold']) in holdout_folds and model in r['scores']]
            if not dev or not hold:continue
            yd=np.concatenate([r['y'] for r in dev]); sd=np.concatenate([r['scores'][model] for r in dev]); thr,dev_rate=_select_threshold(yd,sd,beta); ratio=dev_rate/max(yd.mean(),1e-6)
            pools={'fixed':{'y':[],'p':[],'s':[]},'drift':{'y':[],'p':[],'s':[]}}
            for r in sorted(hold,key=lambda x:int(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))
                for pol,pred in [('fixed',s>=thr),('drift',warn_by_rate(s,rate).astype(bool))]:
                    m=binary_metrics(y,pred,beta);rows.append({'faculty':fac,'model':model,'fold':int(r['fold']),'policy':pol,'threshold':thr,'dev_flag_rate':dev_rate,'warning_ratio':ratio,'ap':safe_ap(y,s),'auc':safe_auc(y,s),**m});pools[pol]['y'].append(y);pools[pol]['p'].append(pred);pools[pol]['s'].append(s)
            for pol,z in pools.items():
                y=np.concatenate(z['y']);p=np.concatenate(z['p']);s=np.concatenate(z['s']);m=binary_metrics(y,p,beta);rows.append({'faculty':fac,'model':model,'fold':'POOLED','policy':pol,'threshold':thr,'dev_flag_rate':dev_rate,'warning_ratio':ratio,'ap':safe_ap(y,s),'auc':safe_auc(y,s),**m})
    return pd.DataFrame(rows)


def fit_platt(y,score):
    from sklearn.linear_model import LogisticRegression
    y=np.asarray(y,int); score=np.clip(np.asarray(score,float),1e-6,1-1e-6)
    if np.unique(y).size<2:return (1.0,0.0)
    z=logit(score).reshape(-1,1); m=LogisticRegression(C=1e3,solver='lbfgs',max_iter=1000).fit(z,y)
    a=float(m.coef_[0,0]); b=float(m.intercept_[0]);
    if a<=0:
        # A negative slope would invert the ranking. Fail safely to identity calibration.
        return 1.0,0.0
    return a,b


def apply_platt(score,a,b):return sigmoid(float(a)*logit(score)+float(b))


def select_safe_fusion(y,committee,graph,faculty_idx,faculty_names,alpha_grid=(0,.10,.25,.50,.75),kappa=50,ap_tol=.002,f2_tol=.005):
    y=np.asarray(y,int);q=np.asarray(committee,float);g=np.asarray(graph,float);fi=np.asarray(faculty_idx,int)
    # global authority maximizes macro AP, then F2, then prefers smaller alpha.
    candidates=[]
    for a in alpha_grid:
        p=blend_logits(q,g,a); aps=[];f2=[]
        for j,_ in enumerate(faculty_names):
            m=fi==j
            if m.any():aps.append(safe_ap(y[m],p[m]));f2.append(metric_dict(y[m],p[m])['fbeta_at_20'])
        candidates.append((np.nanmean(aps),np.nanmean(f2),-a,float(a)))
    global_alpha=max(candidates)[-1]
    rows=[]; final=np.zeros(len(faculty_names),float)
    for j,name in enumerate(faculty_names):
        m=fi==j
        if not m.any():continue
        base_ap=safe_ap(y[m],q[m]);base_f2=metric_dict(y[m],q[m])['fbeta_at_20'];safe=[]
        for a in alpha_grid:
            p=blend_logits(q[m],g[m],a);ap=safe_ap(y[m],p);f2=metric_dict(y[m],p)['fbeta_at_20']
            if ap>=base_ap-ap_tol and f2>=base_f2-f2_tol:safe.append((ap,f2,-a,float(a)))
        raw=max(safe)[-1] if safe else 0.0
        failures=int(y[m].sum());w=failures/(failures+float(kappa));shrunk=float(np.clip(w*raw+(1-w)*global_alpha,0,.75))
        p=blend_logits(q[m],g[m],shrunk);ap=safe_ap(y[m],p);f2=metric_dict(y[m],p)['fbeta_at_20']
        if ap<base_ap-ap_tol or f2<base_f2-f2_tol: shrunk=0.;p=q[m];ap=base_ap;f2=base_f2
        final[j]=shrunk; rows.append({'faculty':name,'rows':int(m.sum()),'failures':failures,'committee_ap':base_ap,'committee_f2_20':base_f2,'raw_alpha':raw,'global_alpha':global_alpha,'shrink_weight':w,'final_alpha':shrunk,'safe_ap':ap,'safe_f2_20':f2})
    return final,float(global_alpha),pd.DataFrame(rows)


def apply_faculty_fusion(committee,graph,faculty_idx,alphas):
    out=np.empty(len(committee),float)
    for i,a in enumerate(alphas):
        m=np.asarray(faculty_idx)==i; out[m]=blend_logits(np.asarray(committee)[m],np.asarray(graph)[m],a)
    return out
