# -*- coding: utf-8 -*-
from __future__ import annotations
import copy
import numpy as np
import torch
import torch.nn.functional as F
from torch.utils.data import DataLoader,TensorDataset,WeightedRandomSampler
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.metrics import average_precision_score
from suite15_models import ConditionalResidualProbe
from suite15_information import safe_ap
from suite2_common import equal_budget_metrics
from suite7_common import faculty_class_sampling_weights



def _seed_local(seed):
    np.random.seed(int(seed));torch.manual_seed(int(seed))
    if torch.cuda.is_available():torch.cuda.manual_seed_all(int(seed))

def walk_forward_splits(blocks,min_prior_blocks=2):
    b=np.asarray(blocks,float);uniq=np.array(sorted(x for x in np.unique(b) if np.isfinite(x)),float);out=[]
    for i,pred_block in enumerate(uniq):
        prior=uniq[:i]
        if len(prior)<int(min_prior_blocks):continue
        val_block=prior[-1];train_blocks=prior[:-1];out.append({'predict_block':float(pred_block),'train_idx':np.where(np.isin(b,train_blocks))[0],'val_idx':np.where(b==val_block)[0],'pred_idx':np.where(b==pred_block)[0],'train_blocks':train_blocks.copy(),'val_block':float(val_block)})
    return out

def crossfit_coverage_mask(blocks,min_prior_blocks=2):
    m=np.zeros(len(blocks),bool)
    for s in walk_forward_splits(blocks,min_prior_blocks):m[s['pred_idx']]=True
    return m

def _sampling_weights(y,faculty,beta=.9999,faculty_names=None):
    faculty=np.asarray(faculty,int)
    if faculty_names is None:
        uniq=np.unique(faculty);mp={v:i for i,v in enumerate(uniq)};dense=np.asarray([mp[v] for v in faculty],int);names=[str(v) for v in uniq]
        return faculty_class_sampling_weights(np.asarray(y,int),dense,names,beta)[0]
    return faculty_class_sampling_weights(np.asarray(y,int),faculty,list(faculty_names),beta)[0]

def robust_ap_stats(y,cand,base,faculty_idx,faculty_names):
    rows=[]
    for fi,name in enumerate(faculty_names):
        m=np.asarray(faculty_idx)==fi
        if np.sum(m)<2 or np.unique(np.asarray(y)[m]).size<2:continue
        d=safe_ap(np.asarray(y)[m],np.asarray(cand)[m])-safe_ap(np.asarray(y)[m],np.asarray(base)[m]);rows.append((name,d))
    if not rows:return {'score':-np.inf,'median_delta_ap':np.nan,'mean_delta_ap':np.nan,'q25_delta_ap':np.nan,'wins':0,'faculties':0,'rows':[]}
    d=np.asarray([x[1] for x in rows]);return {'score':float(np.median(d)+.25*np.mean(d)+.10*np.quantile(d,.25)),'median_delta_ap':float(np.median(d)),'mean_delta_ap':float(np.mean(d)),'q25_delta_ap':float(np.quantile(d,.25)),'wins':int(np.sum(d>0)),'faculties':len(d),'rows':rows}


def robust_e0_stats(y,cand,committee,faculty_idx,faculty_names,beta=2.,f2_weight=.5,mean_weight=.25):
    rows=[]
    for fi,name in enumerate(faculty_names):
        m=np.asarray(faculty_idx)==fi
        if np.sum(m)<2 or np.unique(np.asarray(y)[m]).size<2:continue
        yc=np.asarray(y)[m];pc=np.asarray(cand)[m];pq=np.asarray(committee)[m]
        da=safe_ap(yc,pc)-safe_ap(yc,pq);df=equal_budget_metrics(yc,pc,.20,beta)['fbeta']-equal_budget_metrics(yc,pq,.20,beta)['fbeta'];rows.append((name,da,df))
    if not rows:return {'score':-np.inf,'median_delta_ap':np.nan,'mean_delta_ap':np.nan,'median_delta_f2':np.nan,'wins':0,'faculties':0,'rows':[]}
    da=np.asarray([r[1] for r in rows]);df=np.asarray([r[2] for r in rows]);return {'score':float(np.median(da)+f2_weight*np.median(df)+mean_weight*np.mean(da)),'median_delta_ap':float(np.median(da)),'mean_delta_ap':float(np.mean(da)),'median_delta_f2':float(np.median(df)),'wins':int(np.sum(da>0)),'faculties':len(rows),'rows':rows}

def _loader(X,anchor_logit,y,faculty,batch_size,sampled,beta,seed,samples_per_epoch):
    tensors=[torch.as_tensor(np.asarray(X)),torch.as_tensor(np.asarray(anchor_logit),dtype=torch.float32),torch.as_tensor(np.asarray(y),dtype=torch.float32),torch.as_tensor(np.asarray(faculty),dtype=torch.long)];ds=TensorDataset(*tensors)
    if not sampled:return DataLoader(ds,batch_size=batch_size,shuffle=False,num_workers=0)
    w=_sampling_weights(y,faculty,beta);gen=torch.Generator().manual_seed(int(seed));ns=len(y) if samples_per_epoch<=0 else min(int(samples_per_epoch),max(len(y),1)*4);sam=WeightedRandomSampler(torch.as_tensor(w,dtype=torch.double),num_samples=max(ns,1),replacement=True,generator=gen);return DataLoader(ds,batch_size=batch_size,sampler=sam,num_workers=0)

def predict_residual_probe(model,X,anchor_logit,batch_size=8192,device='cpu'):
    model.eval();out=[];X=np.asarray(X);a=np.asarray(anchor_logit,np.float32)
    with torch.no_grad():
        for i in range(0,len(X),batch_size):
            xb=torch.as_tensor(X[i:i+batch_size],device=device,dtype=torch.float32);aa=torch.as_tensor(a[i:i+batch_size],device=device);inp=torch.cat([xb,aa[:,None]],1);d=model(inp);out.append(torch.sigmoid(aa+d).cpu().numpy())
    return np.concatenate(out) if out else np.array([],float)

def train_residual_probe(X,y,anchor_score,faculty_idx,faculty_names,train_mask,val_mask,max_epochs=8,patience=2,batch_size=4096,lr=1e-3,weight_decay=1e-4,beta=.9999,samples_per_epoch=120000,residual_bound=2.,hidden=(256,128),dropout=.1,seed=0,device='cpu'):
    _seed_local(seed);X=np.asarray(X);y=np.asarray(y,int);anchor=np.clip(np.asarray(anchor_score,float),1e-5,1-1e-5);alog=np.log(anchor/(1-anchor)).astype(np.float32);tr=np.where(train_mask)[0];va=np.where(val_mask)[0]
    model=ConditionalResidualProbe(X.shape[1]+1,hidden=hidden,residual_bound=residual_bound,dropout=dropout).to(device)
    base=anchor[va];best={'score':0.,'epoch':0,'state':copy.deepcopy(model.state_dict()),'stats':robust_ap_stats(y[va],base,base,np.asarray(faculty_idx)[va],faculty_names)};wait=0;opt=torch.optim.AdamW(model.parameters(),lr=lr,weight_decay=weight_decay)
    for ep in range(1,int(max_epochs)+1):
        model.train();ld=_loader(X[tr],alog[tr],y[tr],np.asarray(faculty_idx)[tr],batch_size,True,beta,seed+ep,samples_per_epoch)
        for xb,ab,yb,_ in ld:
            xb=xb.to(device,dtype=torch.float32);ab=ab.to(device);yb=yb.to(device);opt.zero_grad(set_to_none=True);delta=model(torch.cat([xb,ab[:,None]],1));loss=F.binary_cross_entropy_with_logits(ab+delta,yb);loss.backward();torch.nn.utils.clip_grad_norm_(model.parameters(),5.);opt.step()
        pv=predict_residual_probe(model,X[va],alog[va],batch_size*2,device);st=robust_ap_stats(y[va],pv,base,np.asarray(faculty_idx)[va],faculty_names)
        if st['score']>best['score']+1e-6:best={'score':st['score'],'epoch':ep,'state':copy.deepcopy(model.state_dict()),'stats':st};wait=0
        else:wait+=1
        if wait>=patience:break
    model.load_state_dict(best['state']);return model,best

def refit_residual_probe(X,y,anchor_score,faculty_idx,epochs,**kw):
    _seed_local(kw.get('seed',0));X=np.asarray(X);y=np.asarray(y,int);anchor=np.clip(np.asarray(anchor_score,float),1e-5,1-1e-5);alog=np.log(anchor/(1-anchor)).astype(np.float32);model=ConditionalResidualProbe(X.shape[1]+1,hidden=kw.get('hidden',(256,128)),residual_bound=kw.get('residual_bound',2.),dropout=kw.get('dropout',.1)).to(kw.get('device','cpu'));opt=torch.optim.AdamW(model.parameters(),lr=kw.get('lr',1e-3),weight_decay=kw.get('weight_decay',1e-4))
    for ep in range(int(epochs)):
        for xb,ab,yb,_ in _loader(X,alog,y,faculty_idx,kw.get('batch_size',4096),True,kw.get('beta',.9999),kw.get('seed',0)+ep,kw.get('samples_per_epoch',120000)):
            xb=xb.to(kw.get('device','cpu'),dtype=torch.float32);ab=ab.to(kw.get('device','cpu'));yb=yb.to(kw.get('device','cpu'));opt.zero_grad(set_to_none=True);loss=F.binary_cross_entropy_with_logits(ab+model(torch.cat([xb,ab[:,None]],1)),yb);loss.backward();torch.nn.utils.clip_grad_norm_(model.parameters(),5.);opt.step()
    return model

def tree_probe_pair(control_train,view_train,y_train,control_val,view_val,y_val,max_iter=80,seed=0,max_leaf_nodes=31,learning_rate=.05,l2_regularization=1.):
    c0=HistGradientBoostingClassifier(max_iter=max_iter,max_leaf_nodes=max_leaf_nodes,learning_rate=learning_rate,l2_regularization=l2_regularization,random_state=seed).fit(np.asarray(control_train),np.asarray(y_train,int));x=np.concatenate([np.asarray(control_train),np.asarray(view_train)],1);xv=np.concatenate([np.asarray(control_val),np.asarray(view_val)],1);c1=HistGradientBoostingClassifier(max_iter=max_iter,max_leaf_nodes=max_leaf_nodes,learning_rate=learning_rate,l2_regularization=l2_regularization,random_state=seed).fit(x,np.asarray(y_train,int));p0=c0.predict_proba(control_val)[:,1];p1=c1.predict_proba(xv)[:,1];return {'control_ap':safe_ap(y_val,p0),'view_ap':safe_ap(y_val,p1),'delta_ap':safe_ap(y_val,p1)-safe_ap(y_val,p0),'control_model':c0,'view_model':c1}

# ------------------------------
# Chronology-safe E0 anchor
# ------------------------------
from dataclasses import dataclass
from suite15_models import CommitteePreservingGlobalExpert

@dataclass
class E0Scaler:
    flat_mean:np.ndarray;flat_scale:np.ndarray;context_mean:np.ndarray;context_scale:np.ndarray
    @classmethod
    def fit(cls,bundle,idx):
        idx=np.asarray(idx,int)
        def fs(x):
            z=np.nan_to_num(np.asarray(x,np.float32)[idx]);m=z.mean(0);s=z.std(0);s=np.where(s>1e-6,s,1.);return m.astype(np.float32),s.astype(np.float32)
        fm,fs_=fs(bundle.flat);cm,cs=fs(bundle.e0_context);return cls(fm,fs_,cm,cs)
    def transform(self,bundle,idx=None):
        ix=np.arange(len(bundle.y)) if idx is None else np.asarray(idx,int)
        f=(np.nan_to_num(np.asarray(bundle.flat,np.float32)[ix])-self.flat_mean)/self.flat_scale;c=(np.nan_to_num(np.asarray(bundle.e0_context,np.float32)[ix])-self.context_mean)/self.context_scale
        return f.astype(np.float32),c.astype(np.float32),np.asarray(bundle.faculty_idx)[ix].astype(np.int64),np.asarray(bundle.teacher,np.float32)[ix]

def _e0_loader(flat,ctx,fac,teacher,y,batch_size,sampled,beta,seed,samples_per_epoch):
    ds=TensorDataset(torch.as_tensor(flat),torch.as_tensor(ctx),torch.as_tensor(fac,dtype=torch.long),torch.as_tensor(teacher),torch.as_tensor(y,dtype=torch.float32))
    if not sampled:return DataLoader(ds,batch_size=batch_size,shuffle=False,num_workers=0)
    w=_sampling_weights(y,fac,beta);gen=torch.Generator().manual_seed(int(seed));ns=len(y) if samples_per_epoch<=0 else min(int(samples_per_epoch),max(len(y),1)*4);sam=WeightedRandomSampler(torch.as_tensor(w,dtype=torch.double),max(ns,1),replacement=True,generator=gen);return DataLoader(ds,batch_size=batch_size,sampler=sam,num_workers=0)

def _new_e0(bundle,args_like):
    return CommitteePreservingGlobalExpert(bundle.flat.shape[1],bundle.e0_context.shape[1],len(bundle.faculty_names),d_model=int(getattr(args_like,'d_model',64)),faculty_dim=int(getattr(args_like,'faculty_dim',8)),residual_bound=float(getattr(args_like,'e0_residual_bound',2.5)),dropout=float(getattr(args_like,'dropout',.1)))

def predict_e0(model,scaler,bundle,idx=None,batch_size=8192,device='cpu'):
    f,c,fac,t=scaler.transform(bundle,idx);out=[];delta=[];recon=[];model.eval()
    with torch.no_grad():
        for i in range(0,len(f),batch_size):
            o=model(torch.as_tensor(f[i:i+batch_size],device=device),torch.as_tensor(c[i:i+batch_size],device=device),torch.as_tensor(fac[i:i+batch_size],device=device),torch.as_tensor(t[i:i+batch_size],device=device));out.append(torch.sigmoid(o['logit']).cpu().numpy());delta.append(o['delta'].cpu().numpy());recon.append(torch.sigmoid(o['teacher_logits']).cpu().numpy())
    return {'score':np.concatenate(out) if out else np.array([]),'delta':np.concatenate(delta) if delta else np.array([]),'teacher_recon':np.concatenate(recon) if recon else np.empty((0,3))}

def select_e0_epochs(bundle,train_idx,val_idx,args_like,seed,device='cpu'):
    _seed_local(seed);train_idx=np.asarray(train_idx,int);val_idx=np.asarray(val_idx,int);scaler=E0Scaler.fit(bundle,train_idx);f,c,fac,t=scaler.transform(bundle,train_idx);y=np.asarray(bundle.y)[train_idx];model=_new_e0(bundle,args_like).to(device);base=np.asarray(bundle.teacher)[val_idx].mean(1);st0=robust_e0_stats(np.asarray(bundle.y)[val_idx],base,base,np.asarray(bundle.faculty_idx)[val_idx],bundle.faculty_names);best={'epoch':0,'score':st0['score'],'stats':st0,'state':copy.deepcopy(model.state_dict())};opt=torch.optim.AdamW(model.parameters(),lr=float(getattr(args_like,'e0_lr',1e-3)),weight_decay=float(getattr(args_like,'weight_decay',1e-4)));bad=0
    max_epochs=int(getattr(args_like,'e0_max_epochs',4));patience=int(getattr(args_like,'e0_patience',2));batch=int(getattr(args_like,'batch_size',4096));beta=float(getattr(args_like,'sampling_beta',.9999));spe=int(getattr(args_like,'e0_samples_per_epoch',120000));pres=float(getattr(args_like,'e0_preserve_lambda',.5));rec=float(getattr(args_like,'e0_recon_lambda',.1))
    for ep in range(1,max_epochs+1):
        model.train()
        for fb,cb,fab,tb,yb in _e0_loader(f,c,fac,t,y,batch,True,beta,seed+ep,spe):
            fb,cb,fab,tb,yb=fb.to(device),cb.to(device),fab.to(device),tb.to(device),yb.to(device);opt.zero_grad(set_to_none=True);o=model(fb,cb,fab,tb);q=tb.mean(1);loss=F.binary_cross_entropy_with_logits(o['logit'],yb)+pres*F.binary_cross_entropy_with_logits(o['logit'],q)+rec*F.binary_cross_entropy_with_logits(o['teacher_logits'],tb);loss.backward();torch.nn.utils.clip_grad_norm_(model.parameters(),5.);opt.step()
        pv=predict_e0(model,scaler,bundle,val_idx,batch*2,device)['score'];st=robust_e0_stats(np.asarray(bundle.y)[val_idx],pv,base,np.asarray(bundle.faculty_idx)[val_idx],bundle.faculty_names)
        if st['score']>best['score']+1e-6:best={'epoch':ep,'score':st['score'],'stats':st,'state':copy.deepcopy(model.state_dict())};bad=0
        else:bad+=1
        if bad>=patience:break
    return best

def refit_e0(bundle,fit_idx,epochs,args_like,seed,device='cpu'):
    _seed_local(seed);fit_idx=np.asarray(fit_idx,int);scaler=E0Scaler.fit(bundle,fit_idx);f,c,fac,t=scaler.transform(bundle,fit_idx);y=np.asarray(bundle.y)[fit_idx];model=_new_e0(bundle,args_like).to(device);opt=torch.optim.AdamW(model.parameters(),lr=float(getattr(args_like,'e0_lr',1e-3)),weight_decay=float(getattr(args_like,'weight_decay',1e-4)));batch=int(getattr(args_like,'batch_size',4096));beta=float(getattr(args_like,'sampling_beta',.9999));spe=int(getattr(args_like,'e0_samples_per_epoch',120000));pres=float(getattr(args_like,'e0_preserve_lambda',.5));rec=float(getattr(args_like,'e0_recon_lambda',.1))
    for ep in range(int(epochs)):
        model.train()
        for fb,cb,fab,tb,yb in _e0_loader(f,c,fac,t,y,batch,True,beta,seed+ep,spe):
            fb,cb,fab,tb,yb=fb.to(device),cb.to(device),fab.to(device),tb.to(device),yb.to(device);opt.zero_grad(set_to_none=True);o=model(fb,cb,fab,tb);q=tb.mean(1);loss=F.binary_cross_entropy_with_logits(o['logit'],yb)+pres*F.binary_cross_entropy_with_logits(o['logit'],q)+rec*F.binary_cross_entropy_with_logits(o['teacher_logits'],tb);loss.backward();torch.nn.utils.clip_grad_norm_(model.parameters(),5.);opt.step()
    return model,scaler

def generate_crossfit_e0(bundle,args_like,seed,device='cpu',min_prior_blocks=2,verbose=True):
    score=np.full(len(bundle.y),np.nan,np.float32);delta=np.full(len(bundle.y),np.nan,np.float32);epochs=[]
    for j,s in enumerate(walk_forward_splits(bundle.blocks,min_prior_blocks)):
        best=select_e0_epochs(bundle,s['train_idx'],s['val_idx'],args_like,seed+1009*j,device);prior=np.concatenate([s['train_idx'],s['val_idx']]);model,scaler=refit_e0(bundle,prior,best['epoch'],args_like,seed+2003*j,device);pr=predict_e0(model,scaler,bundle,s['pred_idx'],int(getattr(args_like,'predict_batch_size',8192)),device);score[s['pred_idx']]=pr['score'];delta[s['pred_idx']]=pr['delta'];epochs.append({'predict_block':s['predict_block'],'selected_epoch':best['epoch'],**{k:v for k,v in best['stats'].items() if np.isscalar(v)}})
        if verbose:print(f'[E0 CROSSFIT block={s["predict_block"]:g}] prior_blocks={len(s["train_blocks"])+1} epoch={best["epoch"]} medΔAP={best["stats"]["median_delta_ap"]:+.4f} wins={best["stats"]["wins"]}/{best["stats"]["faculties"]}')
    return {'score':score,'delta':delta,'covered':np.isfinite(score),'history':epochs}

def fit_target_e0(hist,target,args_like,seed,device='cpu'):
    uniq=np.array(sorted(np.unique(np.asarray(hist.blocks,float))),float)
    if len(uniq)<2:
        epoch=0
    else:
        val=uniq[-1];tr=np.where(np.asarray(hist.blocks)<val)[0];va=np.where(np.asarray(hist.blocks)==val)[0];epoch=select_e0_epochs(hist,tr,va,args_like,seed,device)['epoch'] if len(tr) and len(va) else 0
    model,scaler=refit_e0(hist,np.arange(len(hist.y)),epoch,args_like,seed+7919,device);pr=predict_e0(model,scaler,target,None,int(getattr(args_like,'predict_batch_size',8192)),device);return {'score':pr['score'],'delta':pr['delta'],'epoch':epoch,'model':model,'scaler':scaler}
