from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
from typing import List

import pandas as pd

from .config import SuiteConfig


@dataclass
class FoldData:
    fold: int
    train: pd.DataFrame
    test: pd.DataFrame
    train_path: Path
    test_path: Path


def baseline_feature_columns(train_df: pd.DataFrame, config: SuiteConfig) -> List[str]:
    """Return the exact original baseline input columns, preserving CSV order."""
    return [c for c in train_df.columns if c not in config.exclude_cols]


def _coerce_and_filter_targets(df: pd.DataFrame, config: SuiteConfig) -> pd.DataFrame:
    out = df.copy()
    if config.target_col not in out.columns:
        raise ValueError(f"Missing target column: {config.target_col}")
    out[config.target_col] = pd.to_numeric(out[config.target_col], errors="coerce")
    needed = [config.target_col]
    if config.target_grade4_col in out.columns:
        out[config.target_grade4_col] = pd.to_numeric(
            out[config.target_grade4_col], errors="coerce"
        )
        needed.append(config.target_grade4_col)
    return out.dropna(subset=needed).reset_index(drop=True)


def load_raw_fold(
    faculty: str,
    fold: int,
    splits_dir: Path,
    config: SuiteConfig,
) -> FoldData:
    train_path = Path(splits_dir) / f"fold_{fold}" / f"{faculty}_train.csv"
    test_path = Path(splits_dir) / f"fold_{fold}" / f"{faculty}_test.csv"
    if not train_path.exists() or not test_path.exists():
        raise FileNotFoundError(
            f"Missing fold {fold} files: {train_path} / {test_path}"
        )
    train = pd.read_csv(train_path, low_memory=False)
    test = pd.read_csv(test_path, low_memory=False)
    train = _coerce_and_filter_targets(train, config)
    test = _coerce_and_filter_targets(test, config)
    if len(train) < 2:
        raise ValueError(f"Fold {fold} contains fewer than two training rows")
    required_meta = [
        config.student_col,
        config.course_col,
        config.semester_col,
        config.semester_code_col,
    ]
    missing = [c for c in required_meta if c not in train.columns or c not in test.columns]
    if missing:
        raise ValueError(f"Missing required metadata columns: {missing}")
    return FoldData(
        fold=fold,
        train=train,
        test=test,
        train_path=train_path,
        test_path=test_path,
    )


def list_faculties(splits_dir: Path) -> List[str]:
    fold_dirs = sorted(Path(splits_dir).glob("fold_*"))
    if not fold_dirs:
        return []
    names = set()
    for p in fold_dirs[0].glob("*_train.csv"):
        names.add(p.name[: -len("_train.csv")])
    return sorted(names)
