"""AQ Suite31 data, support, chronology and evaluation contracts."""
from __future__ import annotations
import hashlib, json, math, os, sys, time
from dataclasses import dataclass
from pathlib import Path
import numpy as np
import pandas as pd
from sklearn.metrics import average_precision_score, roc_auc_score, brier_score_loss, log_loss


def stable_hash(x):
    return hashlib.sha256(json.dumps(x, sort_keys=True, default=str, ensure_ascii=False).encode()).hexdigest()

def dump_json(path, obj):
    path=Path(path);path.parent.mkdir(parents=True,exist_ok=True)
    path.write_text(json.dumps(obj,indent=2,default=lambda x: x.item() if isinstance(x,np.generic) else str(x),ensure_ascii=False))

def note(tag, **fields):
    parts=[]
    for k,v in fields.items():
        if isinstance(v,float):v=f'{v:.6f}'
        parts.append(f'{k}={v}')
    print(f'[{tag}] '+' '.join(parts),flush=True)

def load_aq(cache_dir,struct_dir,faculties,fold,feature_names=None):
    from suite25_data import load_fold_bundle, discover_common_feature_names, current_feature_names
    if feature_names is None:feature_names=discover_common_feature_names(cache_dir,faculties,fold)
    h,q,raw=load_fold_bundle(cache_dir,struct_dir,faculties,fold,feature_names)
    for b,name in ((h,'history'),(q,'target')):
        assert len(b.current)==len(b.y)==len(b.student_id)==len(b.row_index),name
        assert b.current.ndim==2 and np.isfinite(b.current).all(),name
        assert np.isin(b.y,[0,1]).all(),name
        assert np.isfinite(b.semester_ordinal).all(),name
    return h,q,current_feature_names(raw),raw

def global_historical_split(h,val_semesters=3):
    """GLOBAL calendar split; do not use faculty-local fold indices."""
    times=np.sort(np.unique(h.semester_ordinal))
    if len(times)<2:raise ValueError('Need >=2 historical origins for chronology')
    n=min(int(val_semesters),len(times)-1)
    cutoff=float(times[-n]); train=h.semester_ordinal<cutoff; valid=~train
    assert np.max(h.semester_ordinal[train])<np.min(h.semester_ordinal[valid])
    note('CHRONOLOGY',train_origins=times[:-n].tolist(),validation_origins=times[-n:].tolist(),cutoff=cutoff,train_rows=int(train.sum()),validation_rows=int(valid.sum()),availability='semester_proxy_not_release_verified')
    return train,valid,cutoff

def audit_target(h,q):
    if len(h) and len(q):
        assert np.max(h.semester_ordinal)<np.min(q.semester_ordinal), 'Future labels in history: target cutoff violated'
    keys=list(zip(q.faculty_idx.tolist(),q.student_id.tolist(),q.course_id.tolist(),q.target_semester.tolist(),q.row_index.tolist()))
    assert len(keys)==len(set(keys)), 'Duplicate canonical target identifiers'
    note('DATA',history_rows=len(h),history_failures=int(h.y.sum()),target_rows=len(q),target_failures=int(q.y.sum()),history_prevalence=float(h.y.mean()) if len(h) else float('nan'),target_prevalence=float(q.y.mean()),history_last=float(h.semester_ordinal.max()),target_first=float(q.semester_ordinal.min()))

def support_select(h,faculty,origin,budget,seed,release_gap=0,allow_empty=True):
    """Temporal support: faculty-local and before origin by at least release_gap semesters.
    release_gap=0 is benchmark-parity semester proxy, NOT grade-release verification.
    """
    eligible=np.flatnonzero((h.faculty_idx==int(faculty)) & (h.semester_ordinal < float(origin)-release_gap))
    rng=np.random.default_rng(int(seed)); size=min(int(budget),len(eligible))
    indices=np.sort(rng.choice(eligible,size=size,replace=False)) if size else np.zeros(0,np.int64)
    if not allow_empty and size==0:raise ValueError('Empty historical support')
    assert np.all(h.semester_ordinal[indices]<float(origin)-release_gap)
    manifest={'faculty_idx':int(faculty),'origin':float(origin),'requested_budget':int(budget),'actual_budget':int(size),'seed':int(seed),'failure_count':int(h.y[indices].sum()),'support_prevalence':float(h.y[indices].mean()) if size else None,'row_identities':[(int(h.faculty_idx[i]),str(h.student_id[i]),str(h.course_id[i]),float(h.target_semester[i]),int(h.row_index[i])) for i in indices],'source_origins':np.unique(h.semester_ordinal[indices]).astype(float).tolist(),'age_mean':float(np.mean(float(origin)-h.semester_ordinal[indices])) if size else None,'release_gap':int(release_gap)}
    manifest['hash']=stable_hash(manifest)
    return indices,manifest

def scoring(y,s):
    y=np.asarray(y,int);s=np.asarray(s,float)
    if not len(y):raise ValueError('Empty evaluation cell')
    if not np.isfinite(s).all() or np.any((s<0)|(s>1)):raise ValueError('Invalid probabilities')
    both=bool((y==1).any() and (y==0).any());p=np.clip(s,1e-8,1-1e-8)
    o={'rows':len(y),'failures':int(y.sum()),'prevalence':float(y.mean()),'mean_score':float(s.mean()),'ap':float(average_precision_score(y,s)) if both else float('nan'),'auc':float(roc_auc_score(y,s)) if both else float('nan'),'brier':float(brier_score_loss(y,s)),'logloss':float(log_loss(y,p,labels=[0,1]))}
    # ECE10
    bins=np.minimum(np.asarray(s*10,int),9);o['ece10']=float(sum(np.mean(bins==k)*abs(np.mean(y[bins==k])-np.mean(s[bins==k])) for k in range(10) if np.any(bins==k)))
    # Exactly k flagged; stable tie handling across all methods
    order=np.argsort(-s,kind='stable')
    for rate in (.10,.15,.20,.25):
        k=max(1,int(math.ceil(len(y)*rate))); pred=np.zeros(len(y),bool);pred[order[:k]]=True
        tp=int(np.sum(pred & (y==1)));prec=tp/k;rec=tp/max(1,int(y.sum()));f2=(5*prec*rec/(4*prec+rec)) if (4*prec+rec)>0 else 0.
        tag=int(rate*100);o.update({f'precision_at_{tag}':prec,f'recall_at_{tag}':rec,f'fbeta_at_{tag}':f2})
    return o

def cell_rows(b,p,model,fold,seed,budget,stage,wall=0.,vram=float('nan')):
    out=[]
    for fi,f in enumerate(b.faculty_names):
        m=b.faculty_idx==fi
        if not m.any():continue
        for origin in np.sort(np.unique(b.semester_ordinal[m])):
            mm=m & (b.semester_ordinal==origin)
            row={'fold':int(fold),'faculty':f,'origin':float(origin),'model':model,'support_seed':int(seed),'support_budget':int(budget),'stage':stage,'inference_seconds':float(wall),'peak_vram_gb':float(vram)}
            row.update(scoring(b.y[mm],p[mm]));out.append(row)
    return out

def macro_table(df):
    if df.empty:return pd.DataFrame()
    grp=['model','stage','support_budget','support_seed']
    return df.groupby(grp,dropna=False).agg(macro_ap=('ap','mean'),macro_auc=('auc','mean'),f2_at_20=('fbeta_at_20','mean'),brier=('brier','mean'),ece10=('ece10','mean'),cells=('ap','count'),rows=('rows','sum'),failures=('failures','sum')).reset_index()

def paired_comparison(df):
    if df.empty:return pd.DataFrame()
    keys=['fold','faculty','origin','support_seed','support_budget']
    pv=df.pivot_table(index=keys,columns='model',values='ap',aggfunc='first')
    rows=[]
    for reference in ['hgb_matched','hgb_full','committee','tabicl_frozen','tabicl_ordinary','tabicl_chronological']:
        if reference not in pv:continue
        for model in pv.columns:
            if model==reference:continue
            joined=pv[[reference,model]].dropna()
            if joined.empty:continue
            d=joined[model]-joined[reference]
            rows.append({'model':model,'reference':reference,'mean_delta_ap':float(d.mean()),'median_delta_ap':float(d.median()),'wins':int((d>0).sum()),'losses':int((d<0).sum()),'ties':int((d==0).sum()),'paired_cells':len(d)})
    return pd.DataFrame(rows)

def gpu_peak():
    try:
        import torch
        return torch.cuda.max_memory_allocated()/1024**3 if torch.cuda.is_available() else float('nan')
    except Exception:return float('nan')

def reset_gpu_peak():
    try:
        import torch
        if torch.cuda.is_available():torch.cuda.reset_peak_memory_stats()
    except Exception:pass
