from __future__ import annotations

from dataclasses import dataclass
from typing import Dict, List

import numpy as np
import pandas as pd


@dataclass
class PreprocessingResult:
    X_train: pd.DataFrame
    X_test: pd.DataFrame
    manifest: Dict[str, object]


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(pd.to_numeric(series, errors="coerce").dropna().unique().tolist())
    return bool(values) and values.issubset({0.0, 1.0})


def _looks_like_count(name: str, series: pd.Series) -> bool:
    lower = name.lower()
    tokens = ("count", "credits", "attempts", "semester_count", "courses", "workload")
    if not any(token in lower for token in tokens):
        return False
    numeric = pd.to_numeric(series, errors="coerce").dropna()
    return len(numeric) == 0 or bool((numeric >= 0).all())


def _standardize(
    train: pd.DataFrame,
    test: pd.DataFrame,
    leave_binary: bool,
) -> PreprocessingResult:
    train = _numeric(train)
    test = _numeric(test).reindex(columns=train.columns)
    means = train.mean(axis=0)
    train = train.fillna(means).fillna(0.0)
    test = test.fillna(means).fillna(0.0)
    binary_cols: List[str] = [c for c in train.columns if _is_binary(train[c])] if leave_binary else []
    scale_cols = [c for c in train.columns if c not in binary_cols]

    train_out = train.astype(np.float32).copy()
    test_out = test.astype(np.float32).copy()
    if scale_cols:
        train_values = train_out[scale_cols].to_numpy(dtype=np.float32, copy=True)
        test_values = test_out[scale_cols].to_numpy(dtype=np.float32, copy=True)
        mu = train_values.mean(axis=0)
        sd = train_values.std(axis=0)
        sd[~np.isfinite(sd) | (sd == 0)] = 1.0
        train_out.loc[:, scale_cols] = (train_values - mu) / sd
        test_out.loc[:, scale_cols] = (test_values - mu) / sd

    return PreprocessingResult(
        train_out.astype(np.float32),
        test_out.astype(np.float32),
        {
            "mode": "baseline" if not leave_binary else "semantic",
            "binary_columns": binary_cols,
            "scaled_columns": scale_cols,
            "feature_count": len(train_out.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 _standardize(train_frame, test_frame, leave_binary=False)
    if mode != "semantic":
        raise ValueError(f"Unknown preprocessing mode: {mode}")

    train = _numeric(train_frame)
    test = _numeric(test_frame).reindex(columns=train.columns)
    log_train: Dict[str, pd.Series] = {}
    log_test: Dict[str, pd.Series] = {}
    for column in list(train.columns):
        if _looks_like_count(column, train[column]):
            name = f"ta_log1p__{column}"
            log_train[name] = np.log1p(train[column].clip(lower=0))
            log_test[name] = np.log1p(test[column].clip(lower=0))
    added_log_cols = list(log_train)
    if log_train:
        train = pd.concat([train, pd.DataFrame(log_train, index=train.index)], axis=1)
        test = pd.concat([test, pd.DataFrame(log_test, index=test.index)], axis=1)

    cluster_categories: List[str] = []
    if "course_cluster_id" in train.columns:
        raw_train = train.pop("course_cluster_id")
        raw_test = test.pop("course_cluster_id")
        categories = sorted(raw_train.dropna().unique().tolist())
        cluster_train: Dict[str, pd.Series] = {}
        cluster_test: Dict[str, pd.Series] = {}
        for value in categories:
            label = str(value).replace("-", "neg").replace(".", "p")
            name = f"ta_cluster__{label}"
            cluster_train[name] = (raw_train == value).astype(float)
            cluster_test[name] = (raw_test == value).astype(float)
            cluster_categories.append(name)
        cluster_train["ta_cluster_oov"] = (~raw_train.isin(categories) | raw_train.isna()).astype(float)
        cluster_test["ta_cluster_oov"] = (~raw_test.isin(categories) | raw_test.isna()).astype(float)
        train = pd.concat([train, pd.DataFrame(cluster_train, index=train.index)], axis=1)
        test = pd.concat([test, pd.DataFrame(cluster_test, index=test.index)], axis=1)

    binary_cols = [c for c in train.columns if _is_binary(train[c])]
    continuous_cols = [c for c in train.columns if c not in binary_cols]
    clip_bounds: Dict[str, List[float]] = {}
    for column in continuous_cols:
        valid = train[column].dropna()
        if valid.empty:
            lo = hi = 0.0
        else:
            lo = float(valid.quantile(lower_quantile))
            hi = float(valid.quantile(upper_quantile))
            if not np.isfinite(lo):
                lo = float(valid.min())
            if not np.isfinite(hi):
                hi = float(valid.max())
            if hi < lo:
                lo, hi = hi, lo
        train[column] = train[column].clip(lower=lo, upper=hi)
        test[column] = test[column].clip(lower=lo, upper=hi)
        clip_bounds[column] = [lo, hi]

    result = _standardize(train, test, leave_binary=True)
    result.manifest.update(
        {
            "added_log_columns": added_log_cols,
            "cluster_one_hot_columns": cluster_categories,
            "clip_quantiles": [lower_quantile, upper_quantile],
            "clip_bounds": clip_bounds,
        }
    )
    return result
