# -*- coding: utf-8 -*-
from __future__ import annotations
from dataclasses import dataclass
import numpy as np
from sklearn.metrics import average_precision_score, precision_recall_curve
from suite17_temporal import build_temporal_windows,build_crossfit_windows,aggregate_window_stats
from suite17_hgb import NewtonHGBStage,logit,sigmoid,apply_stage_delta
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,_=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=[]
    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]);aps.append(b-a);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,'faculty_delta_ap':[],'delta_f1':0.,'delta_f2':0.,'wins':0,'faculties':0}
    return {'delta_ap':float(np.median(aps)),'delta_ap_mean':float(np.mean(aps)),'faculty_delta_ap':[float(x) for x in aps],'delta_f1':float(np.nanmean(f1)),'delta_f2':float(np.nanmean(f2)),'wins':int(np.sum(np.asarray(aps)>0)),'faculties':len(aps)}

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

@dataclass
class ForwardCandidate:
    name:str
    admitted:bool
    stats:dict
    selection:StageSelection|None=None
    reason:str=''

def choose_forward_candidate(candidates):
    valid=[c for c in candidates if c.admitted]
    if not valid:return None
    return max(valid,key=lambda c:(float(c.stats.get('score',-np.inf)),float(c.stats.get('mean_delta_ap',-np.inf)),float(c.stats.get('median_delta_ap',-np.inf)),-['R','M','L'].index(c.name) if c.name in {'R','M','L'} else -99))

def apply_dense_crossfit_update(base_score,corrected_scores,covered):
    base=np.asarray(base_score,np.float32);m=np.asarray(covered,bool);corr=np.asarray(corrected_scores,np.float32)
    if corr.shape==(len(base),):vals=corr[m]
    elif len(corr)==int(m.sum()):vals=corr
    else:raise ValueError('corrected score length does not match covered mask')
    out=base.copy();out[m]=vals;return out,m.astype(np.float32)

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

def _meta_windows(blocks,y,faculty,n_windows,min_prior_blocks,min_faculties,min_failures,min_rows):
    idx=np.arange(len(y));ws=build_temporal_windows(np.asarray(blocks),np.asarray(y),np.asarray(faculty),n_windows,min_prior_blocks,min_faculties,min_failures,min_rows);return _map_windows_to_global(ws,idx)

def _crossfit_windows(blocks,y,faculty,min_prior_blocks,min_faculties,min_failures,min_rows):
    idx=np.arange(len(y));ws=build_crossfit_windows(np.asarray(blocks),np.asarray(y),np.asarray(faculty),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);return NewtonHGBStage(max_iter,max_leaf_nodes,lr,l2,bound,seed).fit(np.asarray(X)[sel],np.asarray(y)[sel],np.asarray(base)[sel],sw)

def select_hgb_stage(X,y,base_score,faculty,faculty_names,blocks,eta_grid=(0.,.05,.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=2.5,max_rows=180000,sampling_beta=.9999,seed=0):
    windows=_meta_windows(blocks,y,faculty,n_windows,min_prior_blocks,min_faculties,min_failures,min_rows)
    if not windows:return StageSelection('HGB',0.,0,aggregate_window_stats([]),[],[])
    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: missing={missing}, fitted={getattr(model.model,"n_iter_",None)}')
        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)

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',2.5),kw.get('max_rows',180000),kw.get('sampling_beta',.9999),kw.get('seed',0));return m.predict_delta(np.asarray(X)[pred_idx]),m

def stage_crossfit_hgb_dense(X,y,base,faculty,faculty_names,blocks,selection,**kw):
    windows=_crossfit_windows(blocks,y,faculty,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,np.float32).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)).astype(np.float32);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))
    # score is dense by construction: uncovered rows are exact identity fallback.
    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',2.5),kw.get('max_rows',180000),kw.get('sampling_beta',.9999),kw.get('seed',0));return m.predict_delta(X_target),m
