"""Greedy hard histogram trees grown on logistic gradients/Hessians.

Memory features are recomputed from *completed* raw ancestor predicates before
each node's candidate scan. The complete predictor is a prevalence intercept
and Newton leaf updates. The reader is immutable during a forest lifetime.
"""
from dataclasses import dataclass, asdict
import time
import numpy as np
import pandas as pd
from scipy.special import expit


@dataclass
class BoostConfig:
    trees: int = 128
    depth: int = 4
    bins: int = 63
    min_leaf: int = 40
    min_hessian: float = 1.
    l2: float = 5.
    split_penalty: float = 0.
    learning_rate: float = .05
    leaf_clip: float = 2.

    def __post_init__(self):
        for key in ('trees','depth','bins','min_leaf'):
            v=getattr(self,key)
            if int(v)!=v or v<1: raise ValueError(f'{key} must be a positive integer')
        if self.bins>255: raise ValueError('bins must be <=255')
        for key in ('min_hessian','l2','split_penalty'):
            if not np.isfinite(getattr(self,key)) or getattr(self,key)<0: raise ValueError(f'Invalid {key}')
        for key in ('learning_rate','leaf_clip'):
            if not np.isfinite(getattr(self,key)) or getattr(self,key)<=0: raise ValueError(f'Invalid {key}')


def split_gain(GL,HL,GR,HR,l2,penalty=0.):
    return .5*(np.asarray(GL)**2/np.maximum(np.asarray(HL)+l2,1e-12)
               +np.asarray(GR)**2/np.maximum(np.asarray(HR)+l2,1e-12)
               -(np.asarray(GL)+GR)**2/np.maximum(np.asarray(HL)+HR+l2,1e-12))-penalty


class ArrayProvider:
    reader_hash=None
    memory_names=()
    path_strength=0.
    def __init__(self,x,names=None):
        self.raw=np.asarray(x,dtype=np.float32)
        if self.raw.ndim!=2 or not np.isfinite(self.raw).all(): raise ValueError('Finite 2D raw features required')
        self.raw_names=list(names or [f'x{i}' for i in range(self.raw.shape[1])])
        self.comparable_features=self.raw.shape[1]
    def features(self,indices,path=()): return np.empty((len(indices),0),dtype=np.float32)
    def root_features(self): return self.features(np.arange(len(self.raw)))
    def assert_immutable(self): pass


def _edges(x,bins):
    unique=np.unique(x)
    if len(unique)<=bins: return unique[:-1].astype(np.float32)
    edges=np.unique(np.quantile(x,np.arange(1,bins)/bins)).astype(np.float32)
    return edges[edges<np.max(x)]


class Booster:
    def __init__(self,config=None): self.config=config or BoostConfig(); self.trees=[]

    def _check(self,provider):
        provider.assert_immutable()
        if provider.reader_hash!=self.reader_hash: raise ValueError('Reader/forest state mismatch: complete regrowth required')
        if list(provider.raw_names)!=self.raw_names: raise ValueError('Forest/raw feature schema mismatch')

    def fit(self,provider,y,weights=None,callback=None):
        provider.assert_immutable()
        x=provider.raw; y=np.asarray(y,dtype=np.float64)
        if len(y)!=len(x) or not len(y) or y.ndim!=1 or not np.isin(y,[0,1]).all(): raise ValueError('Nonempty binary labels required')
        w=np.ones(len(y)) if weights is None else np.asarray(weights,dtype=np.float64)
        if w.shape!=y.shape or not np.isfinite(w).all() or (w<=0).any(): raise ValueError('Positive finite weights required')
        self.reader_hash=provider.reader_hash; self.raw_names=list(provider.raw_names)
        self.memory_names=list(provider.memory_names)
        self.comparable_features=int(provider.comparable_features)
        self.path_strength=float(provider.path_strength)
        root=provider.root_features()
        edges=[_edges(x[:,j],self.config.bins) for j in range(x.shape[1])]
        edges.extend(_edges(root[:,j],self.config.bins) for j in range(root.shape[1]))
        raw_bins=np.column_stack([np.searchsorted(e,x[:,j],side='left').astype(np.uint8) for j,e in enumerate(edges[:x.shape[1]])])
        prevalence=np.clip(np.sum(w*y)/w.sum(),1e-6,1-1e-6)
        self.intercept=float(np.log(prevalence/(1-prevalence))); self.trees=[]
        logits=np.full(len(y),self.intercept,dtype=np.float64)
        start=time.perf_counter()
        for iteration in range(self.config.trees):
            p=expit(logits); g=w*(p-y); h=w*p*(1-p)
            def grow(idx,path,depth):
                G=float(g[idx].sum()); H=float(h[idx].sum()); n=len(idx)
                leaf={'leaf':float(np.clip(-G/max(H+self.config.l2,1e-12),-self.config.leaf_clip,self.config.leaf_clip)),
                      'rows':n,'hessian':H}
                if depth>=self.config.depth or n<2*self.config.min_leaf or H<2*self.config.min_hessian: return leaf
                memory=root[idx] if not path else provider.features(idx,path)
                best=None; best_gain=1e-12
                for j,e in enumerate(edges):
                    if not len(e): continue
                    b=raw_bins[idx,j] if j<x.shape[1] else np.searchsorted(e,memory[:,j-x.shape[1]],side='left')
                    count=np.bincount(b,minlength=len(e)+1)
                    GL=np.cumsum(np.bincount(b,weights=g[idx],minlength=len(e)+1))[:-1]
                    HL=np.cumsum(np.bincount(b,weights=h[idx],minlength=len(e)+1))[:-1]
                    NL=np.cumsum(count)[:-1]
                    gain=split_gain(GL,HL,G-GL,H-HL,self.config.l2,self.config.split_penalty)
                    valid=(NL>=self.config.min_leaf)&(n-NL>=self.config.min_leaf)&(HL>=self.config.min_hessian)&(H-HL>=self.config.min_hessian)
                    gain=np.where(valid,gain,-np.inf); k=int(np.argmax(gain))
                    if gain[k]>best_gain:
                        best_gain=float(gain[k]); best=(j,k,b<=k)
                if best is None: return leaf
                j,k,left_mask=best; threshold=float(edges[j][k]); raw_pred=j<x.shape[1]
                vals=x[idx,j] if raw_pred else memory[:,j-x.shape[1]]
                node={'feature':j,'threshold':threshold,'gain':best_gain,'rows':n,'hessian':H,
                      'path':[list(v) for v in path],'soft_scale':max(float(np.std(vals)),.01)}
                left_path=path+((j,threshold,True),) if raw_pred else path
                right_path=path+((j,threshold,False),) if raw_pred else path
                node['left']=grow(idx[left_mask],left_path,depth+1)
                node['right']=grow(idx[~left_mask],right_path,depth+1)
                return node
            tree=grow(np.arange(len(y)),(),0); self.trees.append(tree)
            logits+=self.config.learning_rate*self.tree_values(tree,provider)
            if callback is not None: callback(self,iteration+1)
        self.fit_seconds=time.perf_counter()-start
        return self

    def tree_values(self,tree,provider,indices=None):
        idx=np.arange(len(provider.raw)) if indices is None else np.asarray(indices,dtype=np.int64)
        out=np.empty(len(idx),dtype=np.float64)
        def visit(node,positions):
            if not len(positions): return
            if 'leaf' in node: out[positions]=node['leaf']; return
            rows=idx[positions]; j=node['feature']
            values=provider.raw[rows,j] if j<len(self.raw_names) else provider.features(rows,tuple(tuple(v) for v in node['path']))[:,j-len(self.raw_names)]
            left=values<=node['threshold']
            visit(node['left'],positions[left]); visit(node['right'],positions[~left])
        visit(tree,np.arange(len(idx))); return out

    def decision_function(self,provider,trees=None):
        self._check(provider)
        n=len(self.trees) if trees is None else int(trees)
        if n<0 or n>len(self.trees): raise ValueError('Requested tree budget unavailable')
        out=np.full(len(provider.raw),self.intercept,dtype=np.float64)
        for tree in self.trees[:n]: out+=self.config.learning_rate*self.tree_values(tree,provider)
        return out

    def predict_proba(self,provider,trees=None): return expit(self.decision_function(provider,trees))

    def diagnostics(self):
        records=[]
        def visit(node,k,depth):
            r={k:v for k,v in node.items() if k not in ('left','right','path')}
            r.update(tree=k,depth=depth)
            if 'feature' in node:
                j=node['feature']; r['kind']='raw' if j<len(self.raw_names) else 'memory'
                r['feature_name']=(self.raw_names+self.memory_names)[j]
                r['comparable_predicate_count']=sum(int(v[0])<self.comparable_features for v in node['path'])
                r['context_available']=r['kind']=='memory' and r['comparable_predicate_count']>0
                r['path_conditioning_enabled']=r['context_available'] and self.path_strength>0
            else: r['kind']='leaf'
            records.append(r)
            if 'feature' in node: visit(node['left'],k,depth+1); visit(node['right'],k,depth+1)
        for k,t in enumerate(self.trees): visit(t,k,0)
        frame=pd.DataFrame(records); splits=frame[frame.kind!='leaf']
        summary={'trees':len(self.trees),'nodes':len(frame),'splits':len(splits),
                 'memory_splits':int((splits.kind=='memory').sum()),'raw_splits':int((splits.kind=='raw').sum()),
                 'memory_split_fraction':float((splits.kind=='memory').mean()) if len(splits) else 0.,
                 'memory_nodes_with_comparable_context':int(splits.get('context_available',pd.Series(dtype=bool)).eq(True).sum()),
                 'memory_nodes_path_conditioning_enabled':int(splits.get('path_conditioning_enabled',pd.Series(dtype=bool)).eq(True).sum()),
                 'path_strength':self.path_strength,'reader_hash':self.reader_hash,'fit_seconds':getattr(self,'fit_seconds',None),
                 'feature_gain':splits.groupby('feature_name').gain.sum().to_dict() if len(splits) else {},
                 'interpretation':'Enabled path conditioning counts context opportunities; intervention score changes measure actual predictive sensitivity.'}
        return summary,frame

    def to_dict(self):
        return {'version':1,'config':asdict(self.config),'trees':self.trees,'intercept':self.intercept,
                'reader_hash':self.reader_hash,'raw_names':self.raw_names,'memory_names':self.memory_names,
                'comparable_features':self.comparable_features,'path_strength':self.path_strength,'fit_seconds':getattr(self,'fit_seconds',None)}

    @classmethod
    def from_dict(cls,state):
        if state.get('version')!=1: raise ValueError('Unsupported forest version')
        obj=cls(BoostConfig(**state['config']))
        for key in ('trees','intercept','reader_hash','raw_names','memory_names','comparable_features','path_strength','fit_seconds'): setattr(obj,key,state[key])
        return obj
