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

EPS=1e-5

def sigmoid(x):
    x=np.asarray(x,float); return 1./(1.+np.exp(-np.clip(x,-35,35)))

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

def logistic_newton_target(y,p,clip=8.):
    y=np.asarray(y,float); p=np.clip(np.asarray(p,float),1e-4,1-1e-4); h=p*(1-p); r=(y-p)/h; return np.clip(r,-float(clip),float(clip)).astype(np.float32),h.astype(np.float32)

def apply_stage_delta(base_logit,delta,eta):
    return np.asarray(base_logit,float)+float(eta)*np.asarray(delta,float)

class NewtonHGBStage:
    def __init__(self,max_iter=80,max_leaf_nodes=31,learning_rate=.05,l2_regularization=1.,correction_bound=3.,seed=0):
        self.max_iter=int(max_iter);self.max_leaf_nodes=int(max_leaf_nodes);self.learning_rate=float(learning_rate);self.l2_regularization=float(l2_regularization);self.correction_bound=float(correction_bound);self.seed=int(seed);self.model=None
    def fit(self,X,y,base_score,sample_weight=None):
        r,h=logistic_newton_target(y,base_score); w=h if sample_weight is None else h*np.asarray(sample_weight,float)
        self.model=HistGradientBoostingRegressor(max_iter=self.max_iter,max_leaf_nodes=self.max_leaf_nodes,learning_rate=self.learning_rate,l2_regularization=self.l2_regularization,early_stopping=False,random_state=self.seed).fit(np.asarray(X,np.float32),r,sample_weight=w)
        return self
    def predict_delta(self,X):
        if self.model is None:raise RuntimeError('stage not fitted')
        d=self.model.predict(np.asarray(X,np.float32));return np.clip(d,-self.correction_bound,self.correction_bound).astype(np.float32)

def model_feature_usage(model,feature_names=None,top_k=20):
    """Best-effort split-frequency extraction from sklearn HGB internals."""
    if model is None or getattr(model,'model',None) is None:return []
    counts={}
    try:
        for predictors in model.model._predictors:
            for pred in predictors:
                nodes=pred.nodes
                for f,is_leaf in zip(nodes['feature_idx'],nodes['is_leaf']):
                    if not is_leaf:counts[int(f)]=counts.get(int(f),0)+1
    except Exception:return []
    out=[]
    for i,c in sorted(counts.items(),key=lambda kv:(-kv[1],kv[0]))[:int(top_k)]:out.append((feature_names[i] if feature_names and i<len(feature_names) else str(i),int(c)))
    return out
