from __future__ import annotations

from typing import Dict, List, Sequence

import numpy as np
import pandas as pd

from .config import SuiteConfig
from .types import FeatureTransformResult


def _numeric_pair(train: pd.DataFrame, test: pd.DataFrame) -> tuple[pd.DataFrame, pd.DataFrame]:
    tr = train.apply(pd.to_numeric, errors="coerce").replace([np.inf, -np.inf], np.nan)
    te = (
        test.reindex(columns=tr.columns)
        .apply(pd.to_numeric, errors="coerce")
        .replace([np.inf, -np.inf], np.nan)
    )
    return tr, te


def _drop(train: pd.DataFrame, test: pd.DataFrame, columns: Sequence[str], reason: str) -> FeatureTransformResult:
    existing = [c for c in columns if c in train.columns]
    return FeatureTransformResult(
        train.drop(columns=existing),
        test.drop(columns=existing, errors="ignore").reindex(columns=[c for c in train.columns if c not in existing]),
        {reason: existing},
    )


def drop_course_status(train: pd.DataFrame, test: pd.DataFrame) -> FeatureTransformResult:
    columns = [c for c in train.columns if c.startswith("course_status_")]
    return _drop(train, test, columns, "removed_course_status")


def drop_time_features(train: pd.DataFrame, test: pd.DataFrame, config: SuiteConfig) -> FeatureTransformResult:
    columns = list(config.unstable_timing_cols) + list(config.absolute_time_cols)
    return _drop(train, test, columns, "removed_time")


def drop_cluster_identifier(train: pd.DataFrame, test: pd.DataFrame) -> FeatureTransformResult:
    return _drop(train, test, ["course_cluster_id"], "removed_cluster_identifier")


def _exact_duplicate_columns(frame: pd.DataFrame, protected_from_duplicate: Sequence[str] = ()) -> Dict[str, str]:
    protected = set(protected_from_duplicate)
    representatives: Dict[int, List[str]] = {}
    duplicates: Dict[str, str] = {}
    # hash_pandas_object is deterministic and handles NaNs consistently.
    for column in frame.columns:
        series = frame[column]
        signature = int(pd.util.hash_pandas_object(series, index=False).sum())
        candidates = representatives.setdefault(signature, [])
        matched = None
        for candidate in candidates:
            if series.equals(frame[candidate]):
                matched = candidate
                break
        if matched is None:
            candidates.append(column)
        elif column not in protected:
            duplicates[column] = matched
    return duplicates


def structural_clean(train: pd.DataFrame, test: pd.DataFrame, config: SuiteConfig) -> FeatureTransformResult:
    tr, te = _numeric_pair(train, test)
    removed_all_null = [c for c in tr.columns if tr[c].notna().sum() == 0]
    tr = tr.drop(columns=removed_all_null)
    te = te.drop(columns=removed_all_null, errors="ignore")

    removed_constant = [c for c in tr.columns if tr[c].nunique(dropna=True) <= 1]
    tr = tr.drop(columns=removed_constant)
    te = te.drop(columns=removed_constant, errors="ignore")

    removed_time = [
        c for c in list(config.unstable_timing_cols) + list(config.absolute_time_cols) if c in tr.columns
    ]
    tr = tr.drop(columns=removed_time)
    te = te.drop(columns=removed_time, errors="ignore")

    duplicate_map = _exact_duplicate_columns(tr)
    removed_duplicates = list(duplicate_map)
    tr = tr.drop(columns=removed_duplicates)
    te = te.drop(columns=removed_duplicates, errors="ignore")
    te = te.reindex(columns=tr.columns)
    return FeatureTransformResult(
        tr,
        te,
        {
            "removed_all_null": removed_all_null,
            "removed_constant": removed_constant,
            "removed_time": removed_time,
            "removed_exact_duplicate": removed_duplicates,
            "exact_duplicate_representative": duplicate_map,
        },
    )
