# -*- coding: utf-8 -*-
"""Chronology-safe fixed probe matrix for Suite19 representations."""
from __future__ import annotations

from dataclasses import dataclass
import time
from typing import Any

import numpy as np
from sklearn.ensemble import HistGradientBoostingClassifier, HistGradientBoostingRegressor
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

from suite19_common import PrefixPreprocessor, import_suite17, logit, sigmoid
from suite19_encoders import faculty_class_effective_weights


@dataclass
class ProbeMatrixResult:
    hist_scores: dict[str,np.ndarray]
    target_scores: dict[str,np.ndarray]
    chronology_audit: list[dict]
    chronology_violations: int
    backend: dict[str,str]
    selection_rows: list[dict]


def _can_fit(y,min_rows,min_failures):
    y=np.asarray(y,int);return len(y)>=int(min_rows) and np.unique(y).size==2 and int(y.sum())>=int(min_failures) and int((y==0).sum())>=int(min_failures)


def _fit_linear(X,y,w,seed):
    model=Pipeline([('scale',StandardScaler()),('lr',LogisticRegression(C=.5,max_iter=3000,solver='liblinear',random_state=int(seed)))])
    model.fit(np.asarray(X,float),np.asarray(y,int),lr__sample_weight=np.asarray(w,float));return model


def _fit_hgb(X,y,w,seed,max_iter):
    m=HistGradientBoostingClassifier(learning_rate=.05,max_iter=int(max_iter),max_leaf_nodes=31,min_samples_leaf=20,l2_regularization=1.,early_stopping=False,random_state=int(seed));m.fit(np.asarray(X,np.float32),np.asarray(y,int),sample_weight=np.asarray(w,float));return m


def _predict_positive(model,X):
    p=np.asarray(model.predict_proba(np.asarray(X,np.float32)),float);cls=np.asarray(model.classes_);ix=np.where(cls==1)[0]
    if len(ix)!=1:raise RuntimeError('positive class unavailable')
    return p[:,int(ix[0])].astype(np.float32)


def _internal_newton_residual_predict(Xtr,ytr,qtr,w,Xq,seed,max_iter=60,bound=2.5,eta=.10):
    p=np.clip(np.asarray(qtr,float),1e-4,1-1e-4);h=p*(1-p);r=np.clip((np.asarray(ytr,float)-p)/h,-8,8);sw=np.asarray(w,float)*h
    m=HistGradientBoostingRegressor(learning_rate=.05,max_iter=int(max_iter),max_leaf_nodes=31,min_samples_leaf=20,l2_regularization=1.,early_stopping=False,random_state=int(seed)).fit(np.asarray(Xtr,np.float32),r,sample_weight=sw)
    d=np.clip(m.predict(np.asarray(Xq,np.float32)),-float(bound),float(bound));return sigmoid(logit(np.asarray(Xq[:, -1] if False else np.zeros(len(Xq))))),m,d  # first return unused


def _internal_residual_score(Xtr,ytr,qtr,w,Xq,qq,seed,max_iter=60,bound=2.5,eta=.10):
    p=np.clip(np.asarray(qtr,float),1e-4,1-1e-4);h=p*(1-p);r=np.clip((np.asarray(ytr,float)-p)/h,-8,8);sw=np.asarray(w,float)*h
    m=HistGradientBoostingRegressor(learning_rate=.05,max_iter=int(max_iter),max_leaf_nodes=31,min_samples_leaf=20,l2_regularization=1.,early_stopping=False,random_state=int(seed)).fit(np.asarray(Xtr,np.float32),r,sample_weight=sw)
    d=np.clip(m.predict(np.asarray(Xq,np.float32)),-float(bound),float(bound));return sigmoid(logit(qq)+float(eta)*d).astype(np.float32),m


def _exact_suite17_residual(Xtr,ytr,qtr,fac_tr,blocks_tr,faculty_names,Xq,qq,seed,*,eta_grid,iter_candidates,max_rows,min_prior_blocks,min_faculties,min_failures,min_rows):
    mods=import_suite17();training=mods['suite17_training'];hgb=mods['suite17_hgb']
    sel=training.select_hgb_stage(
        Xtr,ytr,qtr,fac_tr,faculty_names,blocks_tr,
        eta_grid=tuple(eta_grid),iter_candidates=tuple(iter_candidates),n_windows=3,
        min_prior_blocks=int(min_prior_blocks),min_faculties=int(min_faculties),min_failures=int(min_failures),min_rows=int(min_rows),
        max_leaf_nodes=31,learning_rate=.05,l2=1.,correction_bound=2.5,max_rows=int(max_rows),sampling_beta=.9999,seed=int(seed),
    )
    if sel.eta==0 or sel.complexity==0:
        return np.asarray(qq,np.float32).copy(),sel,None
    d,m=training.fit_hgb_refit_predict(
        Xtr,Xq,ytr,qtr,fac_tr,faculty_names,np.arange(len(ytr)),sel,
        max_leaf_nodes=31,learning_rate=.05,l2=1.,correction_bound=2.5,max_rows=int(max_rows),sampling_beta=.9999,seed=int(seed)+991,
    )
    score=hgb.sigmoid(hgb.apply_stage_delta(hgb.logit(qq),d,sel.eta)).astype(np.float32)
    return score,sel,m


def _probe_features(z,q,meta):
    q=np.asarray(q,np.float32).reshape(-1,1);meta=np.asarray(meta,np.float32)
    return np.column_stack([np.asarray(z,np.float32),q,meta]).astype(np.float32)


def run_probe_matrix(
    X,y,blocks,faculty,committee,z,z_available,*,
    target_X=None,target_z=None,target_committee=None,target_z_available=None,
    committee_meta=None,target_committee_meta=None,faculty_names=None,
    min_prior_blocks=4,min_train_rows=5000,min_failures=50,hgb_iter=250,class_beta=.9999,
    seed=42,clip_z=12.,max_train_rows=180000,use_suite17_residual=True,require_suite17_residual=True,
    residual_eta_grid=(0.,.05,.1,.2,.3),residual_iter_candidates=(20,40,60,80),residual_max_rows=180000,
    residual_min_prior_blocks=4,
    residual_min_faculties=8,
    residual_min_failures=120,
    residual_min_rows=5000,

    # Runtime optimization.
    compute_historical=True,
    reuse_result=None,
    reuse_previous_blocks=None,
    reuse_previous_to_current=None,
    reuse_blocks=None,
) -> ProbeMatrixResult:
    X=np.asarray(X,np.float32);y=np.asarray(y,int);b=np.asarray(blocks,float);fac=np.asarray(faculty,int);q=np.asarray(committee,np.float32);z=np.asarray(z,np.float32);av=np.asarray(z_available,bool)
    if not(len(X)==len(y)==len(b)==len(fac)==len(q)==len(z)==len(av)):raise ValueError('probe historical alignment mismatch')
    if committee_meta is None:committee_meta=q[:,None]
    committee_meta=np.asarray(committee_meta,np.float32)
    names=list(faculty_names) if faculty_names is not None else [str(i) for i in range(int(fac.max())+1)]
    keys=['raw_hgb','linear_z','hgb_z','hgb_xz','committee_residual'];hist={k:np.full(len(y),np.nan,np.float32) for k in keys};hist['committee']=q.copy();aud=[];selection=[];viol=0
    blocks_sorted=np.array(sorted(v for v in np.unique(b) if np.isfinite(v)),float)
    historical_iterator = (
        enumerate(blocks_sorted)
        if compute_historical
        else []
    )

    for wi, qb in historical_iterator:
        qi=np.where((b==qb)&av)[0];tr=np.where((b<qb)&av)[0];prior=np.unique(b[tr][np.isfinite(b[tr])]);available=len(prior)>=int(min_prior_blocks) and len(qi)>0 and _can_fit(y[tr],min_train_rows,min_failures)
        row={'scope':'hist','window':wi,'query_block':float(qb),'query_rows':int(len(qi)),'train_rows':int(len(tr)),'train_failures':int(y[tr].sum()),'available':bool(available),'strict_train_before_query':True}
        
        # ----------------------------------------------------------
        # Exact historical probe reuse.
        # ----------------------------------------------------------
        if (
            available
            and reuse_result
                is not None
            and reuse_previous_blocks
                is not None
            and reuse_previous_to_current
                is not None
            and reuse_blocks
                is not None
            and float(qb)
                in set(reuse_blocks)
        ):
            pb = np.asarray(
                reuse_previous_blocks,
                float,
            )

            previous_qi = np.where(
                pb == qb
            )[0]

            mapped_qi = np.asarray(
                reuse_previous_to_current,
                int,
            )[previous_qi]

            current_qi = np.where(
                b == qb
            )[0]

            exact_population = (
                len(previous_qi)
                == len(current_qi)
                and np.all(
                    mapped_qi >= 0
                )
                and set(
                    mapped_qi.tolist()
                )
                == set(
                    current_qi.tolist()
                )
            )

            required_scores = (
                "raw_hgb",
                "linear_z",
                "hgb_z",
                "hgb_xz",
                "committee_residual",
            )

            reusable_scores = (
                exact_population
                and all(
                    key
                    in reuse_result
                    .hist_scores
                    for key
                    in required_scores
                )
            )

            if reusable_scores:
                for key in required_scores:
                    old_score = np.asarray(
                        reuse_result
                        .hist_scores[key]
                    )

                    hist[key][mapped_qi] = (
                        old_score[
                            previous_qi
                        ]
                    )

                old_audit = next(
                    (
                        dict(r)
                        for r in
                        reuse_result
                        .chronology_audit
                        if (
                            r.get("scope")
                            == "hist"
                            and float(
                                r.get(
                                    "query_block",
                                    np.nan,
                                )
                            )
                            == float(qb)
                        )
                    ),
                    None,
                )

                if old_audit is not None:
                    old_audit[
                        "window"
                    ] = wi

                    old_audit[
                        "incremental_reuse"
                    ] = True

                    aud.append(
                        old_audit
                    )

                for old_selection in (
                    reuse_result
                    .selection_rows
                ):
                    if (
                        old_selection.get(
                            "scope"
                        )
                        == "hist"
                        and float(
                            old_selection.get(
                                "query_block",
                                np.nan,
                            )
                        )
                        == float(qb)
                    ):
                        rr = dict(
                            old_selection
                        )

                        rr[
                            "incremental_reuse"
                        ] = True

                        selection.append(
                            rr
                        )

                print(
                    "  [INCREMENTAL PROBE HIT] "
                    f"block={qb:g} "
                    f"rows="
                    f"{len(mapped_qi):,}"
                )

                continue
        if not available:aud.append(row);continue
        strict=bool(np.max(b[tr])<np.min(b[qi]));row['strict_train_before_query']=strict;viol+=int(not strict);t0=time.perf_counter()
        if max_train_rows and len(tr)>int(max_train_rows):
            rng=np.random.default_rng(seed+wi*1009);ww=faculty_class_effective_weights(y[tr],fac[tr],class_beta);sel=rng.choice(len(tr),int(max_train_rows),replace=False,p=ww/ww.sum());fit_idx=tr[np.sort(sel)]
        else:fit_idx=tr
        w=faculty_class_effective_weights(y[fit_idx],fac[fit_idx],class_beta);prep=PrefixPreprocessor(clip_z).fit(X[fit_idx]);xr=prep.transform(X[fit_idx]);xq=prep.transform(X[qi]);zr=z[fit_idx];zq=z[qi]
        raw=_fit_hgb(xr,y[fit_idx],w,seed+wi*101+1,hgb_iter);lin=_fit_linear(zr,y[fit_idx],w,seed+wi*101+2);hz=_fit_hgb(zr,y[fit_idx],w,seed+wi*101+3,hgb_iter);xz=_fit_hgb(np.column_stack([xr,zr]),y[fit_idx],w,seed+wi*101+4,hgb_iter)
        hist['raw_hgb'][qi]=_predict_positive(raw,xq);hist['linear_z'][qi]=lin.predict_proba(zq)[:,1].astype(np.float32);hist['hgb_z'][qi]=_predict_positive(hz,zq);hist['hgb_xz'][qi]=_predict_positive(xz,np.column_stack([xq,zq]))
        Rtr=_probe_features(zr,q[fit_idx],committee_meta[fit_idx]);Rq=_probe_features(zq,q[qi],committee_meta[qi])
        if use_suite17_residual:
            try:
                rs,rs_sel,_=_exact_suite17_residual(Rtr,y[fit_idx],q[fit_idx],fac[fit_idx],b[fit_idx],names,Rq,q[qi],seed+wi*103+5,eta_grid=residual_eta_grid,iter_candidates=residual_iter_candidates,max_rows=residual_max_rows,min_prior_blocks=residual_min_prior_blocks,min_faculties=min(int(residual_min_faculties),max(1,len(np.unique(fac[fit_idx])))),min_failures=residual_min_failures,min_rows=residual_min_rows);backend='suite17_exact_newton_hgb';selection.append({'scope':'hist','window':wi,'query_block':float(qb),'eta':float(rs_sel.eta),'complexity':int(rs_sel.complexity),'meta_score':float(rs_sel.stats.get('score',np.nan)),'mean_delta_ap':float(rs_sel.stats.get('mean_delta_ap',np.nan)),'backend':backend})
            except Exception:
                if require_suite17_residual:raise
                rs,_=_internal_residual_score(Rtr,y[fit_idx],q[fit_idx],w,Rq,q[qi],seed+wi*103+5,max_iter=min(80,hgb_iter));backend='internal_newton_hgb_diagnostic'
        else:
            rs,_=_internal_residual_score(Rtr,y[fit_idx],q[fit_idx],w,Rq,q[qi],seed+wi*103+5,max_iter=min(80,hgb_iter));backend='internal_newton_hgb_diagnostic'
        hist['committee_residual'][qi]=rs;row['fit_seconds']=time.perf_counter()-t0;row['residual_backend']=backend;aud.append(row)

    target={}
    residual_backend='suite17_exact_newton_hgb' if use_suite17_residual else 'internal_newton_hgb_diagnostic'
    if target_X is not None:
        Xt=np.asarray(target_X,np.float32);zt=np.asarray(target_z,np.float32);qt=np.asarray(target_committee,np.float32);tav=np.ones(len(Xt),bool) if target_z_available is None else np.asarray(target_z_available,bool);tm=np.asarray(target_committee_meta,np.float32) if target_committee_meta is not None else qt[:,None]
        target['committee']=qt.copy();ti=np.where(tav)[0];tr=np.where(av&np.isfinite(b))[0];available=len(ti)>0 and len(np.unique(b[tr]))>=int(min_prior_blocks) and _can_fit(y[tr],min_train_rows,min_failures);row={'scope':'target','window':'production','query_rows':int(len(ti)),'train_rows':int(len(tr)),'train_failures':int(y[tr].sum()),'available':bool(available),'strict_train_before_query':True}
        for k in keys:target[k]=qt.copy() if k=='committee_residual' else np.full(len(Xt),np.nan,np.float32)
        if available:
            if max_train_rows and len(tr)>int(max_train_rows):
                rng=np.random.default_rng(seed+99001);ww=faculty_class_effective_weights(y[tr],fac[tr],class_beta);sel=rng.choice(len(tr),int(max_train_rows),replace=False,p=ww/ww.sum());fit_idx=tr[np.sort(sel)]
            else:fit_idx=tr
            w=faculty_class_effective_weights(y[fit_idx],fac[fit_idx],class_beta);prep=PrefixPreprocessor(clip_z).fit(X[fit_idx]);xr=prep.transform(X[fit_idx]);xq=prep.transform(Xt[ti]);zr=z[fit_idx];zq=zt[ti]
            raw=_fit_hgb(xr,y[fit_idx],w,seed+99011,hgb_iter);lin=_fit_linear(zr,y[fit_idx],w,seed+99012);hz=_fit_hgb(zr,y[fit_idx],w,seed+99013,hgb_iter);xz=_fit_hgb(np.column_stack([xr,zr]),y[fit_idx],w,seed+99014,hgb_iter)
            target['raw_hgb'][ti]=_predict_positive(raw,xq);target['linear_z'][ti]=lin.predict_proba(zq)[:,1].astype(np.float32);target['hgb_z'][ti]=_predict_positive(hz,zq);target['hgb_xz'][ti]=_predict_positive(xz,np.column_stack([xq,zq]))
            Rtr=_probe_features(zr,q[fit_idx],committee_meta[fit_idx]);Rq=_probe_features(zq,qt[ti],tm[ti])
            if use_suite17_residual:
                try:
                    rs,rs_sel,_=_exact_suite17_residual(Rtr,y[fit_idx],q[fit_idx],fac[fit_idx],b[fit_idx],names,Rq,qt[ti],seed+99015,eta_grid=residual_eta_grid,iter_candidates=residual_iter_candidates,max_rows=residual_max_rows,min_prior_blocks=residual_min_prior_blocks,min_faculties=min(int(residual_min_faculties),max(1,len(np.unique(fac[fit_idx])))),min_failures=residual_min_failures,min_rows=residual_min_rows);residual_backend='suite17_exact_newton_hgb';selection.append({'scope':'target_selection','window':'production','eta':float(rs_sel.eta),'complexity':int(rs_sel.complexity),'meta_score':float(rs_sel.stats.get('score',np.nan)),'mean_delta_ap':float(rs_sel.stats.get('mean_delta_ap',np.nan)),'backend':residual_backend})
                except Exception:
                    if require_suite17_residual:raise
                    rs,_=_internal_residual_score(Rtr,y[fit_idx],q[fit_idx],w,Rq,qt[ti],seed+99015,max_iter=min(80,hgb_iter));residual_backend='internal_newton_hgb_diagnostic'
            else:rs,_=_internal_residual_score(Rtr,y[fit_idx],q[fit_idx],w,Rq,qt[ti],seed+99015,max_iter=min(80,hgb_iter));residual_backend='internal_newton_hgb_diagnostic'
            target['committee_residual'][ti]=rs
        aud.append(row)
    return ProbeMatrixResult(hist,target,aud,int(viol),{'committee_residual':residual_backend,'raw_hgb':'sklearn_hgb_fixed','linear_z':'sklearn_logistic_fixed','hgb_z':'sklearn_hgb_fixed','hgb_xz':'sklearn_hgb_fixed'},selection)
