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, mode: str) -> pd.DataFrame:
    if mode not in {"baseline", "grade10_only"}:
        raise ValueError(f"Unknown target filter mode: {mode}")
    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")
    if config.target_grade4_col in out.columns:
        out[config.target_grade4_col] = pd.to_numeric(
            out[config.target_grade4_col], errors="coerce"
        )
    needed = [config.target_col]
    if mode == "baseline" and config.target_grade4_col in out.columns:
        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")
    if config.target_grade4_col in df.columns:
        grade4 = pd.to_numeric(df[config.target_grade4_col], errors="coerce")
        baseline = grade10.notna() & grade4.notna()
    else:
        baseline = grade10.notna()
    grade10_only = grade10.notna()
    return {
        "raw_rows": int(len(df)),
        "valid_grade10": int(grade10_only.sum()),
        "baseline_eligible": int(baseline.sum()),
        "grade10_only_eligible": int(grade10_only.sum()),
        "recovered_by_grade10_only": int((grade10_only & ~baseline).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,
    target_filter_mode: str,
) -> 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, target_filter_mode)
    test = filter_targets(raw_test, config, target_filter_mode)
    if len(train) < 2:
        raise ValueError(f"Fold {fold} contains fewer than two training rows")
    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=fold,
        train=train,
        test=test,
        train_path=train_path,
        test_path=test_path,
        train_audit=train_audit,
        test_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)
