from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
from typing import Dict, 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
    train_audit: Dict[str, int]
    test_audit: Dict[str, int]


def 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 target_filter_audit(df: pd.DataFrame, config: SuiteConfig) -> Dict[str, int]:
    grade10 = pd.to_numeric(df.get(config.target_col), errors="coerce")
    grade4 = (
        pd.to_numeric(df[config.target_grade4_col], errors="coerce")
        if config.target_grade4_col in df.columns
        else pd.Series(True, index=df.index)
    )
    eligible = grade10.notna() & grade4.notna()
    return {
        "raw_rows": int(len(df)),
        "baseline_eligible": int(eligible.sum()),
        "missing_grade10": int(grade10.isna().sum()),
    }


def baseline_feature_columns(train_df: pd.DataFrame, config: SuiteConfig) -> List[str]:
    return [c for c in train_df.columns if c not in config.exclude_cols]


def load_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 files: {train_path} / {test_path}")
    raw_train = pd.read_csv(train_path, low_memory=False)
    raw_test = pd.read_csv(test_path, low_memory=False)
    train_audit = target_filter_audit(raw_train, config)
    test_audit = target_filter_audit(raw_test, config)
    train = filter_targets(raw_train, config)
    test = filter_targets(raw_test, config)
    required = [config.student_col, config.course_col, config.semester_col, config.semester_code_col]
    missing = [c for c in required 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, train, test, train_path, test_path, train_audit, test_audit)


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