from __future__ import annotations

from dataclasses import dataclass
from typing import Dict, Iterable

import numpy as np
import pandas as pd

from .config import SuiteConfig
from .types import FeatureTransformResult


@dataclass
class _BinModel:
    edges: np.ndarray
    risks: np.ndarray
    missing_risk: float
    prior: float
    history_rows: int


def _fit_model(values: pd.Series, y: np.ndarray, config: SuiteConfig, fallback_prior: float) -> _BinModel:
    numeric = pd.to_numeric(values, errors="coerce")
    prior = float(np.mean(y)) if len(y) else float(fallback_prior)
    if not np.isfinite(prior):
        prior = float(fallback_prior)
    valid = numeric.notna().to_numpy()
    observed = numeric.to_numpy(dtype=float)[valid]
    observed_y = y[valid]
    if len(observed) == 0:
        return _BinModel(np.array([], dtype=float), np.array([prior]), prior, prior, len(y))
    quantiles = np.linspace(0.0, 1.0, config.risk_bin_count + 1)
    raw_edges = np.quantile(observed, quantiles)
    edges = np.unique(raw_edges)
    internal = edges[1:-1] if len(edges) > 2 else np.array([], dtype=float)
    bin_ids = np.searchsorted(internal, observed, side="right")
    n_bins = max(len(internal) + 1, 1)
    risks = np.empty(n_bins, dtype=float)
    for b in range(n_bins):
        mask = bin_ids == b
        count = int(mask.sum())
        failures = float(observed_y[mask].sum()) if count else 0.0
        risks[b] = (failures + config.risk_bin_alpha * prior) / (count + config.risk_bin_alpha)
    missing = ~valid
    missing_count = int(missing.sum())
    missing_failures = float(y[missing].sum()) if missing_count else 0.0
    missing_risk = (missing_failures + config.risk_bin_alpha * prior) / (
        missing_count + config.risk_bin_alpha
    )
    return _BinModel(internal.astype(float), risks, float(missing_risk), prior, len(y))


def _map(values: pd.Series, model: _BinModel) -> np.ndarray:
    numeric = pd.to_numeric(values, errors="coerce").to_numpy(dtype=float)
    out = np.full(len(numeric), model.missing_risk, dtype=float)
    valid = np.isfinite(numeric)
    if valid.any():
        ids = np.searchsorted(model.edges, numeric[valid], side="right")
        ids = np.clip(ids, 0, len(model.risks) - 1)
        out[valid] = model.risks[ids]
    return out


def build_cross_fitted_risk_bins(
    train_raw: pd.DataFrame,
    test_raw: pd.DataFrame,
    candidates: Iterable[str],
    config: SuiteConfig,
) -> FeatureTransformResult:
    if config.semester_col not in train_raw or config.target_col not in train_raw:
        raise ValueError("Risk bins require training semester and target columns")
    semesters = pd.to_numeric(train_raw[config.semester_col], errors="coerce")
    y = (pd.to_numeric(train_raw[config.target_col], errors="coerce").to_numpy(dtype=float) < config.event).astype(float)
    unique_semesters = sorted(semesters.dropna().unique().tolist())
    train_features = pd.DataFrame(index=train_raw.index)
    test_features = pd.DataFrame(index=test_raw.index)
    manifest: Dict[str, object] = {"features": {}, "initial_prior": config.risk_bin_initial_prior}
    for feature in candidates:
        if feature not in train_raw.columns:
            continue
        output_name = f"eb_riskbin__{feature}"
        cross = np.full(len(train_raw), config.risk_bin_initial_prior, dtype=float)
        semester_details = []
        for semester in unique_semesters:
            current = semesters.to_numpy() == semester
            history = semesters.to_numpy() < semester
            history_count = int(history.sum())
            if history_count < config.risk_bin_min_history_rows:
                cross[current] = config.risk_bin_initial_prior
                semester_details.append({"semester": float(semester), "history_rows": history_count, "used_fixed_prior": True})
                continue
            history_y = y[history]
            history_prior = float(history_y.mean()) if len(history_y) else config.risk_bin_initial_prior
            model = _fit_model(train_raw.loc[history, feature], history_y, config, history_prior)
            cross[current] = _map(train_raw.loc[current, feature], model)
            semester_details.append({"semester": float(semester), "history_rows": history_count, "used_fixed_prior": False, "prior": model.prior})
        train_features[output_name] = cross
        full_prior = float(y.mean()) if len(y) else config.risk_bin_initial_prior
        full_model = _fit_model(train_raw[feature], y, config, full_prior)
        test_features[output_name] = _map(test_raw[feature] if feature in test_raw else pd.Series(np.nan, index=test_raw.index), full_model)
        manifest["features"][feature] = {
            "output_name": output_name,
            "test_history_rows": len(train_raw),
            "test_prior": full_model.prior,
            "test_edges": full_model.edges.tolist(),
            "test_risks": full_model.risks.tolist(),
            "test_missing_risk": full_model.missing_risk,
            "semester_details": semester_details,
        }
    return FeatureTransformResult(train_features, test_features, manifest)
