# -*- coding: utf-8 -*-
from __future__ import annotations
from dataclasses import dataclass
import copy, math
import numpy as np
import torch
import torch.nn.functional as F
from torch.utils.data import DataLoader,TensorDataset,WeightedRandomSampler
from sklearn.metrics import average_precision_score,precision_recall_curve,f1_score
from suite16_temporal import build_temporal_windows,build_crossfit_windows,aggregate_window_stats
from suite16_hgb import NewtonHGBStage,logit,sigmoid,apply_stage_delta,logistic_newton_target
from suite16_grande import StraightThroughTreeEnsemble
from suite7_common import faculty_class_sampling_weights


def _safe_ap(y,s):
    y=np.asarray(y,int);s=np.asarray(s,float)
    return float(average_precision_score(y,s)) if len(y) and np.unique(y).size>1 else np.nan

def _best_fbeta(y,s,beta=1.):
    y=np.asarray(y,int);s=np.asarray(s,float)
    if len(y)==0 or np.unique(y).size<2:return np.nan
    p,r,t=precision_recall_curve(y,s);b2=float(beta)**2;v=(1+b2)*p*r/(b2*p+r+1e-12);return float(np.nanmax(v))

def _sampling_weights(y,faculty,faculty_names,beta=.9999):
    return faculty_class_sampling_weights(np.asarray(y,int),np.asarray(faculty,int),list(faculty_names),float(beta))[0]

def _window_metric(y,base,cand,faculty,faculty_names):
    aps=[];f1=[];f2=[];wins=0
    y=np.asarray(y);base=np.asarray(base);cand=np.asarray(cand);faculty=np.asarray(faculty)
    for fi,_ in enumerate(faculty_names):
        m=faculty==fi
        if m.sum()<2 or np.unique(y[m]).size<2:continue
        a=_safe_ap(y[m],base[m]);b=_safe_ap(y[m],cand[m]);d=b-a;aps.append(d);wins+=int(d>0);f1.append(_best_fbeta(y[m],cand[m],1)-_best_fbeta(y[m],base[m],1));f2.append(_best_fbeta(y[m],cand[m],2)-_best_fbeta(y[m],base[m],2))
    if not aps:return {'delta_ap':-np.inf,'delta_ap_mean':-np.inf,'delta_f1':0.,'delta_f2':0.,'wins':0,'faculties':0}
    return {'delta_ap':float(np.median(aps)),'delta_ap_mean':float(np.mean(aps)),'delta_f1':float(np.nanmean(f1)),'delta_f2':float(np.nanmean(f2)),'wins':wins,'faculties':len(aps)}

@dataclass
class StageSelection:
    family:str
    eta:float
    complexity:int
    stats:dict
    window_rows:list
    meta_windows:list


def _map_windows_to_global(local_windows,idx):
    out=[]
    for w in local_windows:
        out.append(type(w)(w.index,idx[w.train_idx],idx[w.val_idx],w.val_blocks,w.faculties,w.failures,w.rows))
    return out

def _meta_windows(blocks,y,faculty,active,n_windows,min_prior_blocks,min_faculties,min_failures,min_rows):
    idx=np.where(np.asarray(active,bool))[0]
    ws=build_temporal_windows(np.asarray(blocks)[idx],np.asarray(y)[idx],np.asarray(faculty)[idx],n_windows,min_prior_blocks,min_faculties,min_failures,min_rows)
    return _map_windows_to_global(ws,idx)

def _crossfit_windows(blocks,y,faculty,active,min_prior_blocks,min_faculties,min_failures,min_rows):
    idx=np.where(np.asarray(active,bool))[0]
    ws=build_crossfit_windows(np.asarray(blocks)[idx],np.asarray(y)[idx],np.asarray(faculty)[idx],min_prior_blocks,min_faculties,min_failures,min_rows)
    return _map_windows_to_global(ws,idx)

def _subsample(idx,y,faculty,faculty_names,max_rows,beta,seed):
    idx=np.asarray(idx,int)
    if not max_rows or len(idx)<=int(max_rows):return idx,_sampling_weights(np.asarray(y)[idx],np.asarray(faculty)[idx],faculty_names,beta)
    w=_sampling_weights(np.asarray(y)[idx],np.asarray(faculty)[idx],faculty_names,beta);rng=np.random.default_rng(seed);take=rng.choice(np.arange(len(idx)),size=int(max_rows),replace=False,p=w/w.sum());sel=idx[take];return sel,_sampling_weights(np.asarray(y)[sel],np.asarray(faculty)[sel],faculty_names,beta)

def _fit_hgb_once(X,y,base,faculty,faculty_names,train_idx,max_iter,max_leaf_nodes,lr,l2,bound,max_rows,beta,seed):
    sel,sw=_subsample(train_idx,y,faculty,faculty_names,max_rows,beta,seed);m=NewtonHGBStage(max_iter,max_leaf_nodes,lr,l2,bound,seed).fit(np.asarray(X)[sel],np.asarray(y)[sel],np.asarray(base)[sel],sw);return m

def select_hgb_stage(X,y,base_score,faculty,faculty_names,blocks,active_mask=None,eta_grid=(0.,.1,.2,.3),iter_candidates=(20,40,60,80),n_windows=3,min_prior_blocks=4,min_faculties=8,min_failures=120,min_rows=5000,max_leaf_nodes=31,learning_rate=.05,l2=1.,correction_bound=3.,max_rows=150000,sampling_beta=.9999,seed=0):
    n=len(y);active=np.ones(n,bool) if active_mask is None else np.asarray(active_mask,bool);windows=_meta_windows(blocks,y,faculty,active,n_windows,min_prior_blocks,min_faculties,min_failures,min_rows)
    if not windows:
        z=aggregate_window_stats([]);return StageSelection('HGB',0.,0,z,[],[])
    cache=[];maxit=max(int(x) for x in iter_candidates)
    for wi,w in enumerate(windows):
        model=_fit_hgb_once(X,y,base_score,faculty,faculty_names,w.train_idx,maxit,max_leaf_nodes,learning_rate,l2,correction_bound,max_rows,sampling_beta,seed+wi*101)
        preds={};
        for it,p in enumerate(model.model.staged_predict(np.asarray(X)[w.val_idx]),1):
            if it in iter_candidates:preds[int(it)]=np.clip(np.asarray(p,float),-correction_bound,correction_bound)
        missing=sorted(set(int(x) for x in iter_candidates)-set(preds))
        if missing:
            raise RuntimeError(f'HGB checkpoint grid incomplete: requested={tuple(iter_candidates)} missing={missing} fitted_iterations={getattr(model.model,"n_iter_",None)}. Suite16 requires early_stopping=False so staged checkpoints are exact.')
        cache.append((w,preds))
    best=None
    for it in (0,)+tuple(int(x) for x in iter_candidates):
        for eta in eta_grid:
            if it==0 and float(eta)!=0:continue
            rows=[]
            for w,preds in cache:
                d=np.zeros(len(w.val_idx)) if it==0 else preds[it];cand=sigmoid(apply_stage_delta(logit(np.asarray(base_score)[w.val_idx]),d,eta));rows.append(_window_metric(np.asarray(y)[w.val_idx],np.asarray(base_score)[w.val_idx],cand,np.asarray(faculty)[w.val_idx],faculty_names))
            st=aggregate_window_stats(rows);key=(st['score'],st['mean_delta_ap'],st['median_delta_ap'],-abs(float(eta)),-int(it))
            if best is None or key>best[0]:best=(key,float(eta),int(it),st,rows)
    return StageSelection('HGB',best[1],best[2],best[3],best[4],windows)

class Standardizer:
    """Finite, overflow-safe scaler for differentiable-tree inputs.

    Suite16 view tensors may contain legitimate values above float16 range.  Statistics
    are accumulated in float64 and transforms are chunked to avoid float32 variance
    overflow or a full float64 copy of the training matrix. Non-finite raw values are
    treated as missing/padded zeros; standardized outliers are clipped only for the
    GRANDE-style branch, not for the HGB reference model.
    """
    def __init__(self,mean,scale,clip_z=20.):
        self.mean=np.asarray(mean,np.float64);self.scale=np.asarray(scale,np.float64);self.clip_z=float(clip_z)
    @staticmethod
    def _finite32(X):
        x=np.asarray(X,np.float32)
        if np.isfinite(x).all():return x
        x=x.copy();x[~np.isfinite(x)]=0.;return x
    @classmethod
    def fit(cls,X):
        x=cls._finite32(X)
        m=np.mean(x,axis=0,dtype=np.float64)
        s=np.std(x,axis=0,dtype=np.float64)
        m=np.where(np.isfinite(m),m,0.)
        s=np.where(np.isfinite(s)&(s>1e-6),s,1.)
        return cls(m,s)
    def transform(self,X):
        x=self._finite32(X);out=np.empty(x.shape,dtype=np.float32);chunk=65536
        for i in range(0,len(x),chunk):
            z=(x[i:i+chunk].astype(np.float64)-self.mean)/self.scale
            z=np.nan_to_num(z,nan=0.,posinf=self.clip_z,neginf=-self.clip_z)
            out[i:i+chunk]=np.clip(z,-self.clip_z,self.clip_z).astype(np.float32)
        return out

def _predict_grande(model,scaler,X,batch_size,device):
    z=scaler.transform(X);out=[];model.eval()
    with torch.no_grad():
        for i in range(0,len(z),int(batch_size)):out.append(model(torch.from_numpy(z[i:i+batch_size]).to(device)).detach().cpu().numpy())
    a=np.concatenate(out).astype(np.float32) if out else np.zeros(0,np.float32)
    if not np.isfinite(a).all():
        bad=int((~np.isfinite(a)).sum());raise FloatingPointError(f'GRANDE produced {bad} non-finite correction values after finite robust scaling')
    return a

def _train_grande_epochs(X,y,base,faculty,faculty_names,train_idx,val_idx,max_epochs,n_estimators,depth,selected_variables,split_temperature,feature_temperature,correction_bound,train_eta,lr,batch_size,samples_per_epoch,sampling_beta,seed,device,return_history=True):
    train_idx=np.asarray(train_idx,int);val_idx=np.asarray(val_idx,int);sc=Standardizer.fit(np.asarray(X)[train_idx]);Xt=sc.transform(np.asarray(X)[train_idx]);yb=np.asarray(y)[train_idx].astype(np.float32);bb=logit(np.asarray(base)[train_idx]).astype(np.float32);fac=np.asarray(faculty)[train_idx]
    model=StraightThroughTreeEnsemble(Xt.shape[1],n_estimators,depth,selected_variables,split_temperature,feature_temperature,correction_bound,seed).to(device)
    opt=torch.optim.AdamW([
        {'params':[model.feature_logits],'lr':lr*2.0}, {'params':[model.thresholds],'lr':lr}, {'params':[model.leaf_values],'lr':lr}, {'params':[model.leaf_weight_logits],'lr':lr*.5}],weight_decay=1e-5)
    w=_sampling_weights(yb,fac,faculty_names,sampling_beta);num=min(int(samples_per_epoch),max(len(train_idx),1));sampler=WeightedRandomSampler(torch.as_tensor(w,dtype=torch.double),num_samples=num,replacement=True,generator=torch.Generator().manual_seed(seed));ds=TensorDataset(torch.from_numpy(Xt),torch.from_numpy(yb),torch.from_numpy(bb));loader=DataLoader(ds,batch_size=int(batch_size),sampler=sampler,num_workers=0)
    hist={0:np.zeros(len(val_idx),np.float32)}
    for ep in range(1,int(max_epochs)+1):
        model.train()
        for xb,yy,b0 in loader:
            xb=xb.to(device);yy=yy.to(device);b0=b0.to(device);opt.zero_grad(set_to_none=True);delta=model(xb);loss=F.binary_cross_entropy_with_logits(b0+float(train_eta)*delta,yy)+1e-4*delta.square().mean();loss.backward();torch.nn.utils.clip_grad_norm_(model.parameters(),5.);opt.step()
        if return_history:hist[ep]=_predict_grande(model,sc,np.asarray(X)[val_idx],batch_size*2,device)
    return model,sc,hist

def select_grande_stage(X,y,base_score,faculty,faculty_names,blocks,active_mask=None,eta_grid=(0.,.1,.2,.3),max_epochs=5,n_windows=3,min_prior_blocks=4,min_faculties=8,min_failures=120,min_rows=5000,n_estimators=96,depth=4,selected_variables=.8,split_temperature=.5,feature_temperature=.5,correction_bound=3.,train_eta=.2,lr=.003,batch_size=1024,samples_per_epoch=60000,sampling_beta=.9999,seed=0,device='cpu'):
    n=len(y);active=np.ones(n,bool) if active_mask is None else np.asarray(active_mask,bool);windows=_meta_windows(blocks,y,faculty,active,n_windows,min_prior_blocks,min_faculties,min_failures,min_rows)
    if not windows:
        z=aggregate_window_stats([]);return StageSelection('GRANDE',0.,0,z,[],[])
    cache=[]
    for wi,w in enumerate(windows):
        _,_,hist=_train_grande_epochs(X,y,base_score,faculty,faculty_names,w.train_idx,w.val_idx,max_epochs,n_estimators,depth,selected_variables,split_temperature,feature_temperature,correction_bound,train_eta,lr,batch_size,samples_per_epoch,sampling_beta,seed+wi*103,device,True);cache.append((w,hist))
    best=None
    for ep in range(0,int(max_epochs)+1):
        for eta in eta_grid:
            if ep==0 and float(eta)!=0:continue
            rows=[];valid=True
            for w,hist in cache:
                d=np.asarray(hist[ep],np.float32)
                if not np.isfinite(d).all():valid=False;break
                cand=sigmoid(apply_stage_delta(logit(np.asarray(base_score)[w.val_idx]),d,eta))
                if not np.isfinite(cand).all():valid=False;break
                rows.append(_window_metric(np.asarray(y)[w.val_idx],np.asarray(base_score)[w.val_idx],cand,np.asarray(faculty)[w.val_idx],faculty_names))
            if not valid:continue
            st=aggregate_window_stats(rows);key=(st['score'],st['mean_delta_ap'],st['median_delta_ap'],-abs(float(eta)),-ep)
            if best is None or key>best[0]:best=(key,float(eta),ep,st,rows)
    return StageSelection('GRANDE',best[1],best[2],best[3],best[4],windows)

def fit_predict_hgb_fixed(X,y,base,faculty,faculty_names,train_idx,pred_idx,selection,**kw):
    if selection.eta==0 or selection.complexity==0:return np.zeros(len(pred_idx),np.float32),None
    m=_fit_hgb_once(X,y,base,faculty,faculty_names,train_idx,selection.complexity,kw.get('max_leaf_nodes',31),kw.get('learning_rate',.05),kw.get('l2',1.),kw.get('correction_bound',3.),kw.get('max_rows',150000),kw.get('sampling_beta',.9999),kw.get('seed',0));return m.predict_delta(np.asarray(X)[pred_idx]),m

def fit_predict_grande_fixed(X,y,base,faculty,faculty_names,train_idx,pred_X,selection,device='cpu',**kw):
    if selection.eta==0 or selection.complexity==0:return np.zeros(len(pred_X),np.float32),None,None
    model,sc,_=_train_grande_epochs(X,y,base,faculty,faculty_names,train_idx,np.asarray(train_idx)[:0],selection.complexity,kw.get('n_estimators',96),kw.get('depth',4),kw.get('selected_variables',.8),kw.get('split_temperature',.5),kw.get('feature_temperature',.5),kw.get('correction_bound',3.),kw.get('train_eta',.2),kw.get('lr',.003),kw.get('batch_size',1024),kw.get('samples_per_epoch',60000),kw.get('sampling_beta',.9999),kw.get('seed',0),device,False);return _predict_grande(model,sc,pred_X,kw.get('batch_size',1024)*2,device),model,sc

def stage_crossfit_hgb(X,y,base,faculty,faculty_names,blocks,active,selection,**kw):
    windows=_crossfit_windows(blocks,y,faculty,active,kw.get('min_prior_blocks',3),kw.get('min_faculties',8),kw.get('min_failures',120),kw.get('min_rows',5000));score=np.asarray(base,float).copy();covered=np.zeros(len(y),bool);rows=[]
    base_seed=kw.get('seed',0);fit_kw=dict(kw);fit_kw.pop('seed',None)
    for wi,w in enumerate(windows):
        d,_=fit_predict_hgb_fixed(X,y,base,faculty,faculty_names,w.train_idx,w.val_idx,selection,seed=base_seed+wi*107,**fit_kw);cand=sigmoid(apply_stage_delta(logit(np.asarray(base)[w.val_idx]),d,selection.eta));score[w.val_idx]=cand;covered[w.val_idx]=True;rows.append(_window_metric(np.asarray(y)[w.val_idx],np.asarray(base)[w.val_idx],cand,np.asarray(faculty)[w.val_idx],faculty_names))
    return score,covered,windows,rows

def stage_crossfit_grande(X,y,base,faculty,faculty_names,blocks,active,selection,device='cpu',**kw):
    windows=_crossfit_windows(blocks,y,faculty,active,kw.get('min_prior_blocks',3),kw.get('min_faculties',8),kw.get('min_failures',120),kw.get('min_rows',5000));score=np.asarray(base,float).copy();covered=np.zeros(len(y),bool);rows=[]
    base_seed=kw.get('seed',0);fit_kw=dict(kw);fit_kw.pop('seed',None)
    for wi,w in enumerate(windows):
        d,_,_=fit_predict_grande_fixed(X,y,base,faculty,faculty_names,w.train_idx,np.asarray(X)[w.val_idx],selection,device,seed=base_seed+wi*109,**fit_kw);cand=sigmoid(apply_stage_delta(logit(np.asarray(base)[w.val_idx]),d,selection.eta));score[w.val_idx]=cand;covered[w.val_idx]=True;rows.append(_window_metric(np.asarray(y)[w.val_idx],np.asarray(base)[w.val_idx],cand,np.asarray(faculty)[w.val_idx],faculty_names))
    return score,covered,windows,rows

def fit_hgb_refit_predict(X_hist,X_target,y,base_hist,faculty,faculty_names,fit_idx,selection,**kw):
    if selection.eta==0 or selection.complexity==0:return np.zeros(len(X_target),np.float32),None
    m=_fit_hgb_once(X_hist,y,base_hist,faculty,faculty_names,fit_idx,selection.complexity,kw.get('max_leaf_nodes',31),kw.get('learning_rate',.05),kw.get('l2',1.),kw.get('correction_bound',3.),kw.get('max_rows',150000),kw.get('sampling_beta',.9999),kw.get('seed',0));return m.predict_delta(X_target),m
