from __future__ import annotations

from typing import Dict

import numpy as np
import pandas as pd

from .cleaning import (
    drop_cluster_identifier,
    drop_course_status,
    drop_time_features,
    structural_clean,
)
from .config import SuiteConfig
from .data import baseline_feature_columns
from .experiments import ExperimentSpec
from .redundancy import prune_correlated_features
from .representation import add_sparse_history_masks, compress_course_status
from .risk_bins import build_cross_fitted_risk_bins
from .stability import score_temporal_stability, select_temporally_stable_features
from .types import FeatureBuildResult


def _base_frames(train_raw: pd.DataFrame, test_raw: pd.DataFrame, config: SuiteConfig) -> tuple[pd.DataFrame, pd.DataFrame]:
    columns = baseline_feature_columns(train_raw, config)
    train = train_raw[columns].apply(pd.to_numeric, errors="coerce").replace([np.inf, -np.inf], np.nan)
    test = test_raw.reindex(columns=columns).apply(pd.to_numeric, errors="coerce").replace([np.inf, -np.inf], np.nan)
    return train.reset_index(drop=True), test.reset_index(drop=True)


def _stable_core(
    base_train: pd.DataFrame,
    base_test: pd.DataFrame,
    train_raw: pd.DataFrame,
    config: SuiteConfig,
    correlation_threshold: float | None,
) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame, Dict[str, object]]:
    y = (pd.to_numeric(train_raw[config.target_col], errors="coerce").to_numpy(dtype=float) < config.event).astype(int)
    semesters = pd.to_numeric(train_raw[config.semester_col], errors="coerce").to_numpy()
    selected, report = select_temporally_stable_features(base_train, y, semesters, config)
    pruning: Dict[str, object] = {}
    if correlation_threshold is not None:
        selected, pruning = prune_correlated_features(
            base_train,
            selected,
            report,
            correlation_threshold,
        )
    return base_train[selected].copy(), base_test[selected].copy(), report, pruning


def _append(base_train: pd.DataFrame, base_test: pd.DataFrame, extra_train: pd.DataFrame, extra_test: pd.DataFrame) -> tuple[pd.DataFrame, pd.DataFrame]:
    tr = pd.concat([base_train.reset_index(drop=True), extra_train.reset_index(drop=True)], axis=1)
    te = pd.concat([base_test.reset_index(drop=True), extra_test.reset_index(drop=True)], axis=1)
    tr = tr.loc[:, ~tr.columns.duplicated(keep="first")]
    te = te.loc[:, ~te.columns.duplicated(keep="first")].reindex(columns=tr.columns)
    return tr, te


def build_experiment_features(
    train_raw: pd.DataFrame,
    test_raw: pd.DataFrame,
    spec: ExperimentSpec,
    config: SuiteConfig,
) -> FeatureBuildResult:
    base_train, base_test = _base_frames(train_raw, test_raw, config)
    manifest: Dict[str, object] = {
        "experiment": spec.code,
        "pipeline": spec.pipeline,
        "baseline_feature_count": len(base_train.columns),
        "baseline_features": list(base_train.columns),
    }
    artifacts: Dict[str, object] = {}

    if spec.pipeline == "baseline":
        train, test = base_train, base_test
    elif spec.pipeline == "structural_clean":
        result = structural_clean(base_train, base_test, config)
        train, test = result.train, result.test
        manifest["transform"] = result.manifest
    elif spec.pipeline == "drop_course_status":
        result = drop_course_status(base_train, base_test)
        train, test = result.train, result.test
        manifest["transform"] = result.manifest
    elif spec.pipeline == "drop_time":
        result = drop_time_features(base_train, base_test, config)
        train, test = result.train, result.test
        manifest["transform"] = result.manifest
    elif spec.pipeline == "drop_cluster":
        result = drop_cluster_identifier(base_train, base_test)
        train, test = result.train, result.test
        manifest["transform"] = result.manifest
    elif spec.pipeline == "isolated_redundancy":
        y = (pd.to_numeric(train_raw[config.target_col], errors="coerce").to_numpy(dtype=float) < config.event).astype(int)
        semesters = pd.to_numeric(train_raw[config.semester_col], errors="coerce").to_numpy()
        report = score_temporal_stability(base_train, y, semesters, config)
        selected, pruning = prune_correlated_features(
            base_train,
            list(base_train.columns),
            report,
            config.isolated_redundancy_threshold,
        )
        train, test = base_train[selected], base_test[selected]
        artifacts["temporal_stability"] = report
        artifacts["correlation_pruning"] = pruning
    elif spec.pipeline == "stability":
        train, test, report, pruning = _stable_core(base_train, base_test, train_raw, config, None)
        artifacts["temporal_stability"] = report
    elif spec.pipeline in {"stable_core", "sparse_masks", "course_status_compression", "risk_bins"}:
        train, test, report, pruning = _stable_core(
            base_train,
            base_test,
            train_raw,
            config,
            config.correlation_threshold,
        )
        artifacts["temporal_stability"] = report
        artifacts["correlation_pruning"] = pruning
        if spec.pipeline == "sparse_masks":
            masks = add_sparse_history_masks(base_train, base_test)
            mask_cols = masks.manifest["added_masks"]
            train, test = _append(train, test, masks.train[mask_cols], masks.test[mask_cols])
            manifest["sparse_masks"] = masks.manifest
        elif spec.pipeline == "course_status_compression":
            compressed = compress_course_status(base_train, base_test)
            summary_cols = compressed.manifest["added_summary_columns"]
            # Remove any original course-status columns that survived the stable core.
            status_in_core = [c for c in train.columns if c.startswith("course_status_")]
            train = train.drop(columns=status_in_core)
            test = test.drop(columns=status_in_core, errors="ignore")
            train, test = _append(train, test, compressed.train[summary_cols], compressed.test[summary_cols])
            manifest["course_status_compression"] = compressed.manifest
        elif spec.pipeline == "risk_bins":
            risk = build_cross_fitted_risk_bins(train_raw, test_raw, config.risk_bin_candidates, config)
            train, test = _append(train, test, risk.train, risk.test)
            manifest["risk_bins"] = risk.manifest
    else:
        raise ValueError(f"Unknown Experiment B pipeline: {spec.pipeline}")

    train = train.loc[:, ~train.columns.duplicated(keep="first")]
    test = test.reindex(columns=train.columns)
    manifest.update(
        {
            "feature_count": len(train.columns),
            "features": list(train.columns),
            "removed_from_baseline": [c for c in base_train.columns if c not in train.columns],
            "added_to_baseline": [c for c in train.columns if c not in base_train.columns],
            "preprocessing_mode": spec.preprocessing_mode,
        }
    )
    return FeatureBuildResult(train, test, spec.preprocessing_mode, manifest, artifacts)
