
from __future__ import annotations

import copy
import inspect
import math
import pickle
from pathlib import Path
from typing import Dict

import numpy as np
from sklearn.base import clone
from sklearn.ensemble import (
    ExtraTreesRegressor,
    GradientBoostingRegressor,
    HistGradientBoostingRegressor,
    RandomForestRegressor,
)


def _x(a):
    if hasattr(a, "to_numpy"):
        a = a.to_numpy()
    a = np.asarray(a, dtype=np.float64)
    if a.ndim != 2:
        raise ValueError(f"X must be 2D, got {a.shape}")
    return np.nan_to_num(a, nan=0.0, posinf=0.0, neginf=0.0)


def _y(a):
    if hasattr(a, "to_numpy"):
        a = a.to_numpy()
    a = np.asarray(a, dtype=np.float64).reshape(-1)
    if not np.isfinite(a).all():
        raise ValueError("y contains NaN/inf")
    return a


def _clone(model):
    try:
        return clone(model)
    except Exception:
        return copy.deepcopy(model)


def _fit(model, X, y, X_val=None, y_val=None):
    params = inspect.signature(model.fit).parameters
    kw = {}
    if X_val is not None and "X_val" in params:
        kw["X_val"] = X_val
    if y_val is not None and "y_val" in params:
        kw["y_val"] = y_val
    model.fit(X, y, **kw)
    return model


def build_grade_regressors(
    rl_regressor=None,
    random_state=42,
    include_lightgbm=True,
    include_catboost=True,
):
    models = {}

    if rl_regressor is not None:
        models["rlgb"] = rl_regressor

    models["random_forest"] = RandomForestRegressor(
        n_estimators=500,
        min_samples_leaf=3,
        max_features="sqrt",
        n_jobs=-1,
        random_state=random_state,
    )

    models["extra_trees"] = ExtraTreesRegressor(
        n_estimators=500,
        min_samples_leaf=2,
        max_features=0.8,
        n_jobs=-1,
        random_state=random_state + 1,
    )

    models["hist_gb"] = HistGradientBoostingRegressor(
        loss="absolute_error",
        learning_rate=0.04,
        max_iter=300,
        max_leaf_nodes=31,
        min_samples_leaf=20,
        l2_regularization=1.0,
        random_state=random_state + 2,
    )

    if include_lightgbm:
        try:
            from lightgbm import LGBMRegressor
            models["lightgbm"] = LGBMRegressor(
                objective="regression_l1",
                n_estimators=700,
                learning_rate=0.025,
                num_leaves=31,
                min_child_samples=20,
                subsample=0.85,
                colsample_bytree=0.8,
                reg_alpha=0.1,
                reg_lambda=1.0,
                n_jobs=-1,
                verbosity=-1,
                random_state=random_state + 3,
            )
        except ImportError:
            pass

    if include_catboost:
        try:
            from catboost import CatBoostRegressor
            models["catboost"] = CatBoostRegressor(
                loss_function="MAE",
                iterations=700,
                learning_rate=0.03,
                depth=7,
                l2_leaf_reg=5.0,
                verbose=False,
                allow_writing_files=False,
                random_seed=random_state + 4,
            )
        except ImportError:
            pass

    return models


class JointRLStackingGradeRegressor:
    """Stacking regression plus state-dependent RL blending.

    State:
        failure-probability bin x model-disagreement bin

    Actions:
        meta prediction alone, or meta blended with mean, median,
        failure anchor, or one base model.

    Reward:
        -abs(y - prediction)

    This directly optimizes validation MAE.
    """

    def __init__(
        self,
        estimators: Dict[str, object],
        grade_min=0.0,
        grade_max=4.0,
        blender_fraction=0.5,
        meta_estimator=None,
        failure_bins=(0.2, 0.5, 0.8),
        disagreement_bins=(0.1, 0.25, 0.5),
        rl_epochs=20,
        rl_alpha=0.2,
        rl_epsilon=0.2,
        rl_epsilon_decay=0.995,
        rl_min_epsilon=0.02,
        random_state=42,
        verbose=True,
    ):
        self.estimators = dict(estimators)
        self.grade_min = float(grade_min)
        self.grade_max = float(grade_max)
        self.blender_fraction = float(blender_fraction)
        self.meta_estimator = meta_estimator
        self.failure_bins = tuple(failure_bins)
        self.disagreement_bins = tuple(disagreement_bins)
        self.rl_epochs = int(rl_epochs)
        self.rl_alpha = float(rl_alpha)
        self.rl_epsilon = float(rl_epsilon)
        self.rl_epsilon_decay = float(rl_epsilon_decay)
        self.rl_min_epsilon = float(rl_min_epsilon)
        self.random_state = int(random_state)
        self.verbose = bool(verbose)

        self.models_ = {}
        self.model_report_ = {}
        self.meta_ = None
        self.q_ = None
        self.action_names_ = []
        self.validation_mae_meta_ = None
        self.validation_mae_joint_ = None
        self.rng_ = np.random.default_rng(self.random_state)
        self.fitted_ = False

    @staticmethod
    def _mae(y_true, pred):
        return float(np.mean(np.abs(y_true - pred)))

    def _meta_features(self, base, p_fail, threshold):
        mean = base.mean(axis=1)
        median = np.median(base, axis=1)
        std = base.std(axis=1)
        minimum = base.min(axis=1)
        maximum = base.max(axis=1)
        p_fail = np.asarray(p_fail).reshape(-1)

        return np.column_stack([
            base,
            mean,
            median,
            std,
            minimum,
            maximum,
            maximum - minimum,
            p_fail,
            p_fail - threshold,
            1.0 - np.abs(2.0 * p_fail - 1.0),
        ])

    def _states(self, p_fail, base):
        pf = np.digitize(p_fail, self.failure_bins)
        ds = np.digitize(base.std(axis=1), self.disagreement_bins)
        return pf * (len(self.disagreement_bins) + 1) + ds

    def _actions(self, base, meta, p_fail):
        mean = base.mean(axis=1)
        median = np.median(base, axis=1)

        # A high failure probability pulls this anchor toward grade_min.
        anchor = self.grade_max * (1.0 - p_fail)
        anchor = np.clip(anchor, self.grade_min, self.grade_max)

        values = [
            meta,
            0.85 * meta + 0.15 * mean,
            0.70 * meta + 0.30 * mean,
            0.85 * meta + 0.15 * median,
            0.70 * meta + 0.30 * median,
            0.90 * meta + 0.10 * anchor,
            0.75 * meta + 0.25 * anchor,
        ]
        names = [
            "meta",
            "meta85_mean15",
            "meta70_mean30",
            "meta85_median15",
            "meta70_median30",
            "meta90_failure10",
            "meta75_failure25",
        ]

        for j, name in enumerate(self.models_):
            values.append(0.8 * meta + 0.2 * base[:, j])
            names.append(f"meta80_{name}20")

        return np.clip(
            np.column_stack(values),
            self.grade_min,
            self.grade_max,
        ), names

    def _learn_policy(self, y_true, base, meta, p_fail):
        states = self._states(p_fail, base)
        actions, self.action_names_ = self._actions(base, meta, p_fail)

        n_states = (
            (len(self.failure_bins) + 1)
            * (len(self.disagreement_bins) + 1)
        )
        self.q_ = np.zeros((n_states, actions.shape[1]))
        visits = np.zeros_like(self.q_, dtype=np.int64)

        epsilon = self.rl_epsilon
        order = np.arange(len(y_true))

        for _ in range(self.rl_epochs):
            self.rng_.shuffle(order)

            for i in order:
                state = int(states[i])

                if self.rng_.random() < epsilon:
                    action = int(self.rng_.integers(actions.shape[1]))
                else:
                    action = int(np.argmax(self.q_[state]))

                reward = -abs(y_true[i] - actions[i, action])
                visits[state, action] += 1
                alpha = self.rl_alpha / math.sqrt(visits[state, action])
                self.q_[state, action] += alpha * (
                    reward - self.q_[state, action]
                )

            epsilon = max(
                self.rl_min_epsilon,
                epsilon * self.rl_epsilon_decay,
            )

    def _apply_policy(self, base, meta, p_fail):
        states = self._states(p_fail, base)
        actions, _ = self._actions(base, meta, p_fail)
        choice = np.argmax(self.q_[states], axis=1)
        return actions[np.arange(len(states)), choice]

    def fit(
        self,
        X,
        y,
        failure_probability,
        failure_threshold,
        X_val,
        y_val,
        failure_probability_val,
    ):
        X, y = _x(X), _y(y)
        X_val, y_val = _x(X_val), _y(y_val)
        p_val = np.asarray(failure_probability_val).reshape(-1)

        indices = np.arange(len(X_val))
        self.rng_.shuffle(indices)
        split = int(len(indices) * (1.0 - self.blender_fraction))
        split = int(np.clip(split, 1, len(indices) - 1))
        base_val_idx = indices[:split]
        blend_idx = indices[split:]

        X_base_val = X_val[base_val_idx]
        y_base_val = y_val[base_val_idx]
        X_blend = X_val[blend_idx]
        y_blend = y_val[blend_idx]
        p_blend = p_val[blend_idx]

        predictions = []

        for name, prototype in self.estimators.items():
            model = _clone(prototype)

            try:
                _fit(
                    model,
                    X,
                    y,
                    X_val=X_base_val,
                    y_val=y_base_val,
                )
                pred = np.asarray(model.predict(X_blend)).reshape(-1)
                pred = np.clip(pred, self.grade_min, self.grade_max)
            except Exception as exc:
                if self.verbose:
                    print(
                        f"Regressor {name} skipped: "
                        f"{type(exc).__name__}: {exc}"
                    )
                continue

            self.models_[name] = model
            self.model_report_[name] = {
                "validation_mae": self._mae(y_blend, pred)
            }
            predictions.append(pred)

            if self.verbose:
                print(
                    f"{name:20s} validation MAE="
                    f"{self.model_report_[name]['validation_mae']:.6f}"
                )

        if len(self.models_) < 2:
            raise RuntimeError("At least two regressors are required.")

        base = np.column_stack(predictions)
        Z = self._meta_features(base, p_blend, failure_threshold)

        self.meta_ = (
            GradientBoostingRegressor(
                loss="absolute_error",
                n_estimators=250,
                learning_rate=0.03,
                max_depth=2,
                min_samples_leaf=20,
                subsample=0.85,
                random_state=self.random_state,
            )
            if self.meta_estimator is None
            else _clone(self.meta_estimator)
        )

        self.meta_.fit(Z, y_blend)
        meta = np.clip(
            self.meta_.predict(Z),
            self.grade_min,
            self.grade_max,
        )

        self.validation_mae_meta_ = self._mae(y_blend, meta)
        self._learn_policy(y_blend, base, meta, p_blend)

        joint = self._apply_policy(base, meta, p_blend)
        self.validation_mae_joint_ = self._mae(y_blend, joint)
        self.fitted_ = True

        if self.verbose:
            print(
                f"Meta MAE:  {self.validation_mae_meta_:.6f}"
            )
            print(
                f"Joint MAE: {self.validation_mae_joint_:.6f}"
            )

        return self

    def _base_predictions(self, X):
        values = []
        for model in self.models_.values():
            pred = np.asarray(model.predict(X)).reshape(-1)
            values.append(
                np.clip(pred, self.grade_min, self.grade_max)
            )
        return np.column_stack(values)

    def predict(self, X, failure_probability, failure_threshold):
        if not self.fitted_:
            raise RuntimeError("Regressor is not fitted.")

        X = _x(X)
        p = np.asarray(failure_probability).reshape(-1)
        base = self._base_predictions(X)
        Z = self._meta_features(base, p, failure_threshold)
        meta = np.clip(
            self.meta_.predict(Z),
            self.grade_min,
            self.grade_max,
        )

        return self._apply_policy(base, meta, p)

    def get_base_model_report(self):
        return [
            {"model": name, **metrics}
            for name, metrics in self.model_report_.items()
        ]

    def get_policy_report(self):
        result = []
        n_d = len(self.disagreement_bins) + 1

        for state in range(self.q_.shape[0]):
            action = int(np.argmax(self.q_[state]))
            result.append({
                "state": state,
                "failure_state": state // n_d,
                "disagreement_state": state % n_d,
                "action": self.action_names_[action],
                "q_value": float(self.q_[state, action]),
            })

        return result


class JointFailureAwareGradeModel:
    """Existing failure classifier + joint stacking grade regressor."""

    def __init__(
        self,
        failure_classifier,
        grade_regressor,
        failure_boundary=1.0,
        grade_min=0.0,
        grade_max=4.0,
        verbose=True,
    ):
        self.failure_classifier = failure_classifier
        self.grade_regressor = grade_regressor
        self.failure_boundary = float(failure_boundary)
        self.grade_min = float(grade_min)
        self.grade_max = float(grade_max)
        self.verbose = bool(verbose)

        self.failure_classifier_ = None
        self.grade_regressor_ = None
        self.failure_threshold_ = 0.5
        self.fitted_ = False

    def fit(self, X, y, X_val, y_val):
        X, y = _x(X), _y(y)
        X_val, y_val = _x(X_val), _y(y_val)

        y_fail = (y < self.failure_boundary).astype(np.int64)
        y_val_fail = (
            y_val < self.failure_boundary
        ).astype(np.int64)

        self.failure_classifier_ = copy.deepcopy(
            self.failure_classifier
        )
        self.failure_classifier_.fit(
            X,
            y_fail,
            X_val=X_val,
            y_val=y_val_fail,
        )

        self.failure_threshold_ = float(
            self.failure_classifier_.classification_threshold_
        )

        p_train = (
            self.failure_classifier_.predict_positive_proba(X)
        )
        p_val = (
            self.failure_classifier_.predict_positive_proba(X_val)
        )

        self.grade_regressor_ = copy.deepcopy(
            self.grade_regressor
        )
        self.grade_regressor_.fit(
            X,
            y,
            failure_probability=p_train,
            failure_threshold=self.failure_threshold_,
            X_val=X_val,
            y_val=y_val,
            failure_probability_val=p_val,
        )

        self.fitted_ = True

        if self.verbose:
            print(
                "\nJoint failure-aware model fitted"
            )
            print(
                f"Failure threshold: {self.failure_threshold_:.4f}"
            )
            print(
                "Validation MAE before joint RL: "
                f"{self.grade_regressor_.validation_mae_meta_:.6f}"
            )
            print(
                "Validation MAE after joint RL: "
                f"{self.grade_regressor_.validation_mae_joint_:.6f}"
            )

        return self

    def predict_failure_probability(self, X):
        if not self.fitted_:
            raise RuntimeError("Model is not fitted.")
        return (
            self.failure_classifier_
            .predict_positive_proba(_x(X))
        )

    def predict(self, X):
        if not self.fitted_:
            raise RuntimeError("Model is not fitted.")

        X = _x(X)
        p = self.predict_failure_probability(X)

        prediction = self.grade_regressor_.predict(
            X,
            failure_probability=p,
            failure_threshold=self.failure_threshold_,
        )

        return np.clip(
            prediction,
            self.grade_min,
            self.grade_max,
        )

    def save_model(self, path):
        path = Path(path)
        path.parent.mkdir(parents=True, exist_ok=True)
        with path.open("wb") as file:
            pickle.dump(self, file)

    @staticmethod
    def load_model(path):
        with Path(path).open("rb") as file:
            return pickle.load(file)
