# -*- coding: utf-8 -*-
from __future__ import annotations
from dataclasses import dataclass
import numpy as np
from sklearn.ensemble import HistGradientBoostingClassifier

EPS=1e-6
LOCAL_FEATURE_NAMES=[
    'local_global_p','local_recent_p',
    'local_global_minus_committee','local_recent_minus_committee','local_recent_minus_global',
    'local_global_logit_minus_committee','local_recent_logit_minus_committee','local_recent_logit_minus_global',
    'committee_rank','local_global_rank','local_recent_rank',
    'local_global_rank_minus_committee','local_recent_rank_minus_committee',
    'local_global_available','local_recent_available',
    'local_global_train_rows_log','local_recent_train_rows_log',
    'local_global_train_failure_rate','local_recent_train_failure_rate',
    'committee_disagreement_std'
]

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

def _rank_pct(v):
    v=np.asarray(v,float);n=len(v)
    if n<=1:return np.full(n,.5,np.float32)
    order=np.argsort(v,kind='mergesort');r=np.empty(n,float);r[order]=np.arange(n,dtype=float);return (r/(n-1)).astype(np.float32)

def _class_weights(y,beta=.9999):
    y=np.asarray(y,int);out=np.ones(len(y),np.float32)
    counts=np.bincount(y,minlength=2).astype(float);eff=np.ones(2,float)
    for c in (0,1):
        n=counts[c]
        eff[c]=(1-beta**n)/(1-beta) if n>0 else 1.
    w=1/np.maximum(eff,1e-12);w=w/np.mean(w[counts>0]);out=w[y];return out.astype(np.float32)

def _fit_local_model(X,y,seed,max_iter,max_leaf_nodes,learning_rate,l2,beta,min_train_rows,min_failures):
    y=np.asarray(y,int)
    if len(y)<int(min_train_rows) or np.unique(y).size<2 or int(y.sum())<int(min_failures) or int((y==0).sum())<int(min_failures):return None
    m=HistGradientBoostingClassifier(max_iter=int(max_iter),max_leaf_nodes=int(max_leaf_nodes),learning_rate=float(learning_rate),l2_regularization=float(l2),early_stopping=False,random_state=int(seed))
    m.fit(np.asarray(X,np.float32),y,sample_weight=_class_weights(y,beta));return m

def _predict_or_none(model,X):
    if model is None:return None
    return np.asarray(model.predict_proba(np.asarray(X,np.float32))[:,1],np.float32)

def _model_input(flat,teacher):
    return np.nan_to_num(np.concatenate([np.asarray(flat,np.float32),np.asarray(teacher,np.float32)],1)).astype(np.float32)

def _features_from_predictions(committee,teacher,pg,pr,ag,ar,ngr,nrr,fgr,frr,faculty,rank_group=None):
    q=np.asarray(committee,float);teacher=np.asarray(teacher,float);pg=np.asarray(pg,float);pr=np.asarray(pr,float);fac=np.asarray(faculty,int);n=len(q);out=np.zeros((n,len(LOCAL_FEATURE_NAMES)),np.float32);grp=np.zeros(n,int) if rank_group is None else np.asarray(rank_group)
    lg=_logit(pg)-_logit(q);lr=_logit(pr)-_logit(q);lrg=_logit(pr)-_logit(pg)
    for fi in np.unique(fac):
        for gv in np.unique(grp[fac==fi]):
            m=(fac==fi)&(grp==gv);rq=_rank_pct(q[m]);rg=_rank_pct(pg[m]);rr=_rank_pct(pr[m])
            out[m,8]=rq;out[m,9]=rg;out[m,10]=rr;out[m,11]=rg-rq;out[m,12]=rr-rq
    out[:,0]=pg;out[:,1]=pr;out[:,2]=pg-q;out[:,3]=pr-q;out[:,4]=pr-pg;out[:,5]=lg;out[:,6]=lr;out[:,7]=lrg
    out[:,13]=np.asarray(ag,np.float32);out[:,14]=np.asarray(ar,np.float32);out[:,15]=np.log1p(np.asarray(ngr,float));out[:,16]=np.log1p(np.asarray(nrr,float));out[:,17]=np.asarray(fgr,np.float32);out[:,18]=np.asarray(frr,np.float32);out[:,19]=np.std(teacher,axis=1).astype(np.float32)
    return np.nan_to_num(out).astype(np.float32)

@dataclass
class LocalEvidenceResult:
    hist_features:np.ndarray
    target_features:np.ndarray
    hist_available:np.ndarray
    target_available:np.ndarray
    hist_global:np.ndarray
    hist_recent:np.ndarray
    target_global:np.ndarray
    target_recent:np.ndarray
    diagnostics:list


def build_faculty_local_evidence(hist_flat,hist_teacher,y,committee,faculty,blocks,target_flat,target_teacher,target_committee,target_faculty,
                                 recent_blocks=4,min_prior_blocks=4,crossfit_window_blocks=2,min_train_rows=300,min_failures=10,
                                 max_iter=60,max_leaf_nodes=31,learning_rate=.05,l2=1.,sampling_beta=.9999,seed=0):
    """Build dense chronology-safe faculty-local alternative-prediction evidence.

    Historical prediction groups are fixed contiguous block chunks, independent of future labels.
    Unavailable predictions fall back exactly to Committee and expose availability=0.
    """
    X=_model_input(hist_flat,hist_teacher);Xt=_model_input(target_flat,target_teacher);y=np.asarray(y,int);q=np.asarray(committee,np.float32);fac=np.asarray(faculty,int);b=np.asarray(blocks,float);qt=np.asarray(target_committee,np.float32);ft=np.asarray(target_faculty,int)
    pg=q.copy();pr=q.copy();ag=np.zeros(len(y),np.float32);ar=np.zeros(len(y),np.float32);ngr=np.zeros(len(y),np.float32);nrr=np.zeros(len(y),np.float32);fgr=np.zeros(len(y),np.float32);frr=np.zeros(len(y),np.float32);diags=[]
    uniq=np.array(sorted(x for x in np.unique(b) if np.isfinite(x)),float);start=int(min_prior_blocks);wid=0
    while start<len(uniq):
        vals=uniq[start:min(start+max(1,int(crossfit_window_blocks)),len(uniq))];vi=np.where(np.isin(b,vals))[0];train=np.where(b<vals[0])[0]
        for fi in np.unique(fac[vi]):
            vfi=vi[fac[vi]==fi];tr=train[fac[train]==fi]
            if not len(vfi):continue
            modelg=_fit_local_model(X[tr],y[tr],seed+wid*1009+int(fi)*17,max_iter,max_leaf_nodes,learning_rate,l2,sampling_beta,min_train_rows,min_failures)
            predg=_predict_or_none(modelg,X[vfi]);
            if predg is not None:
                pg[vfi]=predg;ag[vfi]=1.;ngr[vfi]=len(tr);fgr[vfi]=float(np.mean(y[tr]))
            ub=np.array(sorted(np.unique(b[tr])),float);keep=ub[-int(recent_blocks):] if len(ub) else ub;rr=tr[np.isin(b[tr],keep)]
            modelr=_fit_local_model(X[rr],y[rr],seed+wid*1013+int(fi)*19+500000,max_iter,max_leaf_nodes,learning_rate,l2,sampling_beta,min_train_rows,min_failures)
            predr=_predict_or_none(modelr,X[vfi]);
            if predr is not None:
                pr[vfi]=predr;ar[vfi]=1.;nrr[vfi]=len(rr);frr[vfi]=float(np.mean(y[rr]))
            diags.append({'scope':'hist','window':wid,'val_blocks':','.join(str(int(x)) for x in vals),'faculty_idx':int(fi),'val_rows':len(vfi),'global_train_rows':len(tr),'recent_train_rows':len(rr),'global_available':bool(modelg is not None),'recent_available':bool(modelr is not None)})
        start+=max(1,int(crossfit_window_blocks));wid+=1
    # Target predictions use all available historical rows, or exact Committee fallback.
    pgt=qt.copy();prt=qt.copy();agt=np.zeros(len(qt),np.float32);art=np.zeros(len(qt),np.float32);ngt=np.zeros(len(qt),np.float32);nrt=np.zeros(len(qt),np.float32);fgt=np.zeros(len(qt),np.float32);frt=np.zeros(len(qt),np.float32)
    for fi in np.unique(ft):
        ti=np.where(ft==fi)[0];tr=np.where(fac==fi)[0]
        if not len(ti):continue
        mg=_fit_local_model(X[tr],y[tr],seed+900000+int(fi)*23,max_iter,max_leaf_nodes,learning_rate,l2,sampling_beta,min_train_rows,min_failures);g=_predict_or_none(mg,Xt[ti])
        if g is not None:pgt[ti]=g;agt[ti]=1.;ngt[ti]=len(tr);fgt[ti]=float(np.mean(y[tr]))
        ub=np.array(sorted(np.unique(b[tr])),float);keep=ub[-int(recent_blocks):] if len(ub) else ub;rr=tr[np.isin(b[tr],keep)]
        mr=_fit_local_model(X[rr],y[rr],seed+950000+int(fi)*29,max_iter,max_leaf_nodes,learning_rate,l2,sampling_beta,min_train_rows,min_failures);r=_predict_or_none(mr,Xt[ti])
        if r is not None:prt[ti]=r;art[ti]=1.;nrt[ti]=len(rr);frt[ti]=float(np.mean(y[rr]))
        diags.append({'scope':'target','window':-1,'val_blocks':'target','faculty_idx':int(fi),'val_rows':len(ti),'global_train_rows':len(tr),'recent_train_rows':len(rr),'global_available':bool(mg is not None),'recent_available':bool(mr is not None)})
    # Historical ranks are within prediction-time block and faculty; target ranks are within target faculty.
    hf=_features_from_predictions(q,hist_teacher,pg,pr,ag,ar,ngr,nrr,fgr,frr,fac,rank_group=b);tf=_features_from_predictions(qt,target_teacher,pgt,prt,agt,art,ngt,nrt,fgt,frt,ft,rank_group=np.zeros(len(qt),int))
    return LocalEvidenceResult(hf,tf,np.column_stack([ag,ar]).astype(np.float32),np.column_stack([agt,art]).astype(np.float32),pg,pr,pgt,prt,diags)
