from __future__ import annotations

from typing import Dict, List

import numpy as np
import pandas as pd

from .types import PreprocessingResult


def _numeric(frame: pd.DataFrame) -> pd.DataFrame:
    return frame.apply(pd.to_numeric, errors="coerce").replace([np.inf, -np.inf], np.nan).astype(float)


def _is_binary(series: pd.Series) -> bool:
    values = set(series.dropna().unique().tolist())
    return bool(values) and values.issubset({0.0, 1.0})


def _baseline(train: pd.DataFrame, test: pd.DataFrame) -> PreprocessingResult:
    tr = _numeric(train)
    te = _numeric(test).reindex(columns=tr.columns)
    means = tr.mean(axis=0)
    tr = tr.fillna(means).fillna(0.0)
    te = te.fillna(means).fillna(0.0)
    mu = tr.to_numpy(dtype=np.float32).mean(axis=0)
    sd = tr.to_numpy(dtype=np.float32).std(axis=0)
    sd[~np.isfinite(sd) | (sd == 0)] = 1.0
    tr_out = pd.DataFrame((tr.to_numpy(dtype=np.float32) - mu) / sd, columns=tr.columns, index=tr.index)
    te_out = pd.DataFrame((te.to_numpy(dtype=np.float32) - mu) / sd, columns=tr.columns, index=te.index)
    return PreprocessingResult(tr_out.astype(np.float32), te_out.astype(np.float32), {"mode": "baseline", "feature_count": len(tr.columns)})


def _observed_standardize(
    train: pd.DataFrame,
    test: pd.DataFrame,
    leave_binary: bool,
    mode: str,
    extra_manifest: Dict[str, object] | None = None,
) -> PreprocessingResult:
    tr = _numeric(train)
    te = _numeric(test).reindex(columns=tr.columns)
    binary = [c for c in tr.columns if leave_binary and _is_binary(tr[c])]
    scaled = [c for c in tr.columns if c not in binary]
    tr_out = pd.DataFrame(index=tr.index)
    te_out = pd.DataFrame(index=te.index)
    stats: Dict[str, list[float]] = {}
    for c in tr.columns:
        if c in binary:
            tr_out[c] = tr[c].fillna(0.0)
            te_out[c] = te[c].fillna(0.0)
            continue
        observed = tr[c].dropna()
        mean = float(observed.mean()) if len(observed) else 0.0
        sd = float(observed.std(ddof=0)) if len(observed) else 1.0
        if not np.isfinite(sd) or sd == 0:
            sd = 1.0
        tr_out[c] = ((tr[c] - mean) / sd).fillna(0.0)
        te_out[c] = ((te[c] - mean) / sd).fillna(0.0)
        stats[c] = [mean, sd]
    manifest: Dict[str, object] = {
        "mode": mode,
        "binary_columns": binary,
        "scaled_columns": scaled,
        "observed_stats": stats,
        "feature_count": len(tr.columns),
    }
    if extra_manifest:
        manifest.update(extra_manifest)
    return PreprocessingResult(tr_out.astype(np.float32), te_out.astype(np.float32), manifest)


def _winsor(
    train: pd.DataFrame,
    test: pd.DataFrame,
    lower_quantile: float,
    upper_quantile: float,
) -> PreprocessingResult:
    tr = _numeric(train)
    te = _numeric(test).reindex(columns=tr.columns)
    binary = [c for c in tr.columns if _is_binary(tr[c])]
    bounds: Dict[str, list[float]] = {}
    for c in tr.columns:
        if c in binary:
            continue
        observed = tr[c].dropna()
        if observed.empty:
            lo = hi = 0.0
        else:
            lo = float(observed.quantile(lower_quantile))
            hi = float(observed.quantile(upper_quantile))
            if not np.isfinite(lo):
                lo = float(observed.min())
            if not np.isfinite(hi):
                hi = float(observed.max())
            if hi < lo:
                lo, hi = hi, lo
        tr[c] = tr[c].clip(lo, hi)
        te[c] = te[c].clip(lo, hi)
        bounds[c] = [lo, hi]
    return _observed_standardize(
        tr,
        te,
        leave_binary=True,
        mode="winsor",
        extra_manifest={"clip_bounds": bounds, "clip_quantiles": [lower_quantile, upper_quantile]},
    )


def _quantile_rank(train: pd.DataFrame, test: pd.DataFrame) -> PreprocessingResult:
    tr = _numeric(train)
    te = _numeric(test).reindex(columns=tr.columns)
    binary = [c for c in tr.columns if _is_binary(tr[c])]
    transformed_train = pd.DataFrame(index=tr.index)
    transformed_test = pd.DataFrame(index=te.index)
    support: Dict[str, int] = {}
    for c in tr.columns:
        if c in binary:
            transformed_train[c] = tr[c].fillna(0.0)
            transformed_test[c] = te[c].fillna(0.0)
            continue
        observed = tr[c].dropna()
        support[c] = int(len(observed))
        if observed.empty:
            transformed_train[c] = 0.0
            transformed_test[c] = 0.0
            continue
        train_rank = tr[c].rank(method="average", pct=True)
        transformed_train[c] = (2.0 * train_rank - 1.0).fillna(0.0)
        sorted_values = np.sort(observed.to_numpy(dtype=float))
        test_values = te[c].to_numpy(dtype=float)
        mapped = np.zeros(len(test_values), dtype=float)
        valid = np.isfinite(test_values)
        mapped[valid] = 2.0 * (
            np.searchsorted(sorted_values, test_values[valid], side="right") / len(sorted_values)
        ) - 1.0
        transformed_test[c] = mapped
    return PreprocessingResult(
        transformed_train.astype(np.float32),
        transformed_test.astype(np.float32),
        {"mode": "quantile_rank", "binary_columns": binary, "training_support": support, "feature_count": len(tr.columns)},
    )


def fit_transform_preprocessor(
    train_frame: pd.DataFrame,
    test_frame: pd.DataFrame,
    mode: str,
    lower_quantile: float = 0.005,
    upper_quantile: float = 0.995,
) -> PreprocessingResult:
    if mode == "baseline":
        return _baseline(train_frame, test_frame)
    if mode == "missing_aware":
        return _observed_standardize(train_frame, test_frame, leave_binary=True, mode="missing_aware")
    if mode == "winsor":
        return _winsor(train_frame, test_frame, lower_quantile, upper_quantile)
    if mode == "quantile_rank":
        return _quantile_rank(train_frame, test_frame)
    raise ValueError(f"Unknown preprocessing mode: {mode}")
