"""Suite30 helpers, derived from the validated Suite29 data/evaluation contract."""
from __future__ import annotations
import json
from pathlib import Path
import numpy as np
import pandas as pd
from suite25_data import RetrievalBundle
from suite25_common import metric_dict,safe_ap
from suite30_data import EnrollmentDataset

def subset_rows(b,indices):
    indices=np.asarray(indices)
    return RetrievalBundle(**{k:getattr(b,k)[indices] for k in
       ("current","y","committee","faculty_idx","blocks","semester_ordinal",
        "semester_z","target_semester","student_id","course_id","row_index")},
        faculty_names=b.faculty_names)

class Standardizer:
    def __init__(self,raw):
        x=np.nan_to_num(np.asarray(raw.current,np.float32),nan=0.,posinf=0.,neginf=0.)
        self.mean=x.mean(0);self.scale=x.std(0)
        self.scale=np.where(self.scale>1e-6,self.scale,1.)
        self.smean=float(np.mean(raw.semester_ordinal))
        self.sscale=max(float(np.std(raw.semester_ordinal)),1.)
    def apply(self,b):
        x=np.nan_to_num(np.asarray(b.current,np.float32),nan=0.,posinf=0.,neginf=0.)
        return RetrievalBundle(((x-self.mean)/self.scale).astype(np.float32),
           b.y,b.committee,b.faculty_idx,b.blocks,b.semester_ordinal,
           ((b.semester_ordinal-self.smean)/self.sscale).astype(np.float32),
           b.target_semester,b.student_id,b.course_id,b.row_index,b.faculty_names)

def count_binary_failures(x):
    a=np.asarray(x)
    if a.ndim!=1 or not np.all((a==0)|(a==1)):
        raise ValueError("labels must be binary")
    return int(np.count_nonzero(a))

def audit_history_group_completeness(cache_dir,faculties,fold,strict=False):
    """Read original canonical cache and audit the cross-fitted history mask."""
    import joblib
    result=[]
    for fac in faculties:
        d=joblib.load(Path(cache_dir)/f"{fac}_fold_{fold}.joblib")
        fr=d["train_frame"]
        covered=np.asarray(d["cf_covered_mask"],bool)&np.isfinite(
            np.asarray(d["cf_probabilities"],float)).all(1)
        if len(covered)!=len(fr):raise ValueError(f"cache row mismatch {fac} F{fold}")
        full={};selected={}
        ids=fr["IDSV"].astype(str).to_numpy()
        terms=fr["target_NHHK"].astype(str).to_numpy()
        for i in range(len(fr)):
            k=(ids[i],terms[i]);full[k]=full.get(k,0)+1
            if covered[i]:selected[k]=selected.get(k,0)+1
        partial=[(k,n) for k,n in selected.items() if n<full[k]]
        affected=sum(n for _,n in partial)
        row=dict(fold=fold,faculty=fac,full_history_rows=len(fr),
             covered_history_rows=int(covered.sum()),full_groups=len(full),
             retained_groups=len(selected),partial_groups=len(partial),
             rows_in_partial_groups=affected,
             fraction_retained_rows_in_partial_groups=affected/max(int(covered.sum()),1))
        print("[HISTORY COVERAGE] "+json.dumps(row),flush=True)
        if strict and partial:raise ValueError(f"partial historical enrollment set: {row}")
        result.append(row)
    return result

def target_profiles(b,fold):
    grouped=EnrollmentDataset(b).groups
    result=[]
    for fi,fac in enumerate(b.faculty_names):
        groups=[g for g in grouped if int(b.faculty_idx[g[0]])==fi]
        if not groups: continue
        size=np.array([len(g) for g in groups]);cnt=np.array(
            [np.count_nonzero(b.y[g]) for g in groups])
        result.append(dict(fold=fold,faculty=fac,registrations=int(size.sum()),
           groups=len(groups),singletons=int((size==1).sum()),
           singleton_fraction=float((size==1).mean()),
           mean_courses=float(size.mean()),max_courses=int(size.max()),
           groups_any=int((cnt>0).sum()),groups_multiple=int((cnt>1).sum()),
           total_failures=int(cnt.sum()),
           failures_in_multi_fraction=float(cnt[cnt>1].sum()/max(cnt.sum(),1))))
    return result

def rows_for_metrics(b,scores,fold,seed):
    out=[]
    for model,p in scores.items():
        for fi,fac in enumerate(b.faculty_names):
            z=b.faculty_idx==fi
            if not z.any():continue
            if not np.isfinite(p[z]).all():
                print(f"[INCOMPLETE METRIC] F{fold} seed={seed} {fac} {model}",flush=True)
                continue
            md=metric_dict(b.y[z],p[z])
            out.append(dict(fold=fold,seed=seed,faculty=fac,model=model,
               rows=int(z.sum()),failures=int(np.count_nonzero(b.y[z])),
               prevalence=float(np.mean(b.y[z])),**md))
    return out

def bootstrap_delta(b,p_new,p_base,reps,seed):
    rng=np.random.default_rng(seed)
    out=[]
    if reps<=0:return out
    for fi,fac in enumerate(b.faculty_names):
        z=np.where(b.faculty_idx==fi)[0]
        ids=np.asarray(b.student_id[z]).astype(str)
        unique, inv=np.unique(ids,return_inverse=True)
        if len(unique)<3:continue
        grouped=[z[inv==i] for i in range(len(unique))]
        vals=[]
        for _ in range(reps):
            ix=np.concatenate([grouped[i] for i in rng.integers(0,len(unique),len(unique))])
            if len(np.unique(b.y[ix]))<2:continue
            vals.append(float(safe_ap(b.y[ix],p_new[ix])-safe_ap(b.y[ix],p_base[ix])))
        if vals:
            out.append(dict(faculty=fac,bootstrap_reps=len(vals),
              delta_ap=float(safe_ap(b.y[z],p_new[z])-safe_ap(b.y[z],p_base[z])),
              ci_low=float(np.quantile(vals,.025)),ci_high=float(np.quantile(vals,.975))))
    return out

def validate_suite29_reference(df,b,fold,seed):
    """Fail closed: exact score-row identity, not simply equal outcomes/count."""
    required={"faculty","student_id","course_id","semester","row_index","actual"}
    if not required.issubset(df.columns):raise ValueError(f"Suite29 missing keys {required-set(df.columns)}")
    if len(df)!=len(b.y):raise ValueError(f"Suite29 F{fold} seed{seed} length mismatch")
    expected_fac=np.asarray(b.faculty_names,dtype=object)[b.faculty_idx]
    checks={
        "faculty":np.array_equal(df.faculty.astype(str).to_numpy(),expected_fac),
        "student_id":np.array_equal(df.student_id.astype(str).to_numpy(),b.student_id.astype(str)),
        "course_id":np.array_equal(df.course_id.astype(str).to_numpy(),b.course_id.astype(str)),
        "semester":np.allclose(pd.to_numeric(df.semester),b.target_semester,rtol=0,atol=1e-5),
        "row_index":np.array_equal(pd.to_numeric(df.row_index).to_numpy(),b.row_index),
        "actual":np.array_equal(pd.to_numeric(df.actual).to_numpy(),b.y),
    }
    errors=[k for k,v in checks.items() if not v]
    if errors:raise ValueError(f"Suite29 F{fold} seed={seed} row identity mismatch: {errors}")
    result={}
    for name in ("suite29_self_only","suite29_set","suite29_set_no_peers"):
        if name in df:
            p=np.asarray(df[name],float)
            if not np.isfinite(p).all() or (p<0).any() or (p>1).any():
                raise ValueError(f"Invalid {name} reference")
            result[name]=p
    return result

def load_suite29_references(root,b,fold,seed):
    if not root:return {}
    path=Path(root)/f"fold_{fold}_seed_{seed}_scores.csv"
    if not path.is_file():
        print(f"[SUITE29 REFERENCE MISSING] {path}",flush=True)
        return {}
    r=validate_suite29_reference(pd.read_csv(path,dtype={"faculty":str,"student_id":str,"course_id":str}),b,fold,seed)
    print(f"[SUITE29 REFERENCE OK] fold={fold} seed={seed} models={list(r)} "
          "exact row keys and outcomes verified",flush=True)
    return r

def group_diagnostics(b,scores,aux_by_model,fold,seed):
    rows=[]
    for group in EnrollmentDataset(b).groups:
        fi=int(b.faculty_idx[group[0]])
        y=b.y[group].astype(int)
        cnt=int(y.sum())
        for name,p in scores.items():
            if not np.isfinite(p[group]).all():continue
            aux=aux_by_model.get(name)
            pg=p[group]
            # Independent comparator's Poisson-binomial count distribution.
            dp=np.array([1.])
            for qi in pg: dp=np.convolve(dp,[1-float(qi),float(qi)])
            base_any=float(1-dp[0])
            base_multi=float(np.sum(dp[2:]))
            log_joint_base=float(-np.sum(y*np.log(np.clip(pg,1e-7,1))+
                                     (1-y)*np.log(np.clip(1-pg,1e-7,1))))
            if aux is None:
                anyp,multip,jnll=base_any,base_multi,log_joint_base
                pi=0.;shift=0.;gate=0.;peer=0.;top=0.;entropy=0.;magnitude=0.
                excess_covariance=0.
            else:
                i=int(group[0])
                anyp=float(aux["prob_any"][i])
                multip=float(aux["prob_multi"][i])
                jnll=float(aux["joint_nll"][i])
                pi=float(aux["mixture"][i])
                shift=float(aux["state_separation"][i])
                gate=float(np.mean(aux["peer_gate"][group]))
                peer=float(np.mean(aux["peer_mass"][group]))
                top=float(np.mean(aux["peer_top"][group]))
                entropy=float(np.mean(aux["peer_entropy"][group]))
                magnitude=float(np.mean(np.abs(aux["peer_logit_delta"][group])))
                diffs=aux["p_high"][group]-aux["p_low"][group]
                excess_covariance=float(pi*(1-pi)*(float(diffs.sum()**2)-
                       float(np.sum(diffs**2))))
            rows.append(dict(fold=fold,seed=seed,faculty=b.faculty_names[fi],
                model=name,student_id=str(b.student_id[group[0]]),
                semester=float(b.target_semester[group[0]]),size=len(group),
                observed_failures=cnt,expected_failures=float(pg.sum()),
                count_abs_error=float(abs(cnt-pg.sum())),joint_nll=jnll,
                any_observed=int(cnt>0),any_predicted=anyp,
                multi_observed=int(cnt>1),multi_predicted=multip,
                any_brier=(anyp-int(cnt>0))**2,
                multi_brier=(multip-int(cnt>1))**2,
                mixture=pi,state_separation=shift,peer_gate=gate,peer_mass=peer,
                peer_top=top,peer_entropy=entropy,mean_abs_logit_delta=magnitude,
                independent_predicted_multiple=base_multi,
                joint_minus_independent_multi=multip-base_multi,
                excess_correlated_count_variance=excess_covariance))
    return rows

def save_csv(rows,path):
    if rows:pd.DataFrame(rows).to_csv(path,index=False)
