from __future__ import annotations

import json
from pathlib import Path
from typing import Dict, List, Mapping, MutableMapping, Sequence, Tuple

import numpy as np
import pandas as pd

from .config import SuiteConfig
from .data import baseline_feature_columns, load_fold
from .experiments import EXPERIMENTS
from .features import build_feature_frames
from .metrics import (
    average_precision,
    best_f1_threshold,
    confusion_metrics,
    equal_budget_metrics,
    roc_auc,
    warn_by_rate,
)
from .model import train_predict
from .preprocessing import fit_transform_preprocessor


SIGNALS = ("blended", "classification")
EQUAL_BUDGET_RATES = (0.05, 0.10, 0.15, 0.20)


def _grade_band(grades: np.ndarray) -> np.ndarray:
    g = np.asarray(grades, dtype=float)
    labels = np.full(len(g), "7-10", dtype=object)
    labels[g < 7] = "5-7"
    labels[g < 5] = "4-5"
    labels[g < 4] = "3-4"
    labels[g < 3] = "0-3"
    labels[g == 0] = "grade=0"
    return labels


def _metadata(frame: pd.DataFrame, config: SuiteConfig) -> pd.DataFrame:
    columns = [
        config.student_col,
        config.course_col,
        config.registration_col,
        config.semester_code_col,
        config.semester_col,
        "target_status",
        "hist_semester_count",
        "hist_course_grade10_count",
        "recent3_course_grade10_count",
        "hist_same_course_attempts",
        "hist_target_course_count",
        "student_gpa_history_missing_flag",
        "course_history_missing_flag",
    ]
    return frame[[c for c in columns if c in frame.columns]].reset_index(drop=True).copy()


def _generate_record(
    faculty: str,
    experiment_name: str,
    fold: int,
    splits_dir: Path,
    config: SuiteConfig,
) -> Tuple[MutableMapping[str, object], Dict[str, object], Dict[str, float], Dict[str, object]]:
    spec = EXPERIMENTS[experiment_name]
    fold_data = load_fold(
        faculty, fold, splits_dir, config, target_filter_mode=spec.target_filter_mode
    )
    feature_cols = [
        c for c in baseline_feature_columns(fold_data.train, config) if c in fold_data.test.columns
    ]
    train_base = fold_data.train[feature_cols]
    test_base = fold_data.test[feature_cols]
    train_features, test_features, feature_manifest = build_feature_frames(
        train_base, test_base, spec, config
    )
    processed = fit_transform_preprocessor(
        train_features,
        test_features,
        mode=spec.preprocessing_mode,
        lower_quantile=config.robust_lower_quantile,
        upper_quantile=config.robust_upper_quantile,
    )
    y_train = pd.to_numeric(fold_data.train[config.target_col], errors="raise").to_numpy(float)
    y_test = pd.to_numeric(fold_data.test[config.target_col], errors="raise").to_numpy(float)
    prediction = train_predict(
        processed.X_train,
        y_train,
        processed.X_test,
        config,
        desc=f"{experiment_name}/fold{fold}",
    )
    frame = _metadata(fold_data.test, config)
    frame.insert(0, "fold", fold)
    frame["true_grade"] = y_test
    frame["true_failure"] = (y_test < config.event).astype(int)
    frame["grade_band"] = _grade_band(y_test)
    frame["predicted_blended_grade"] = prediction.blended_grade
    frame["blended_risk"] = config.event - prediction.blended_grade
    frame["classification_score"] = prediction.classification_score

    record: MutableMapping[str, object] = {
        "fold": fold,
        "y_bin": frame["true_failure"].to_numpy(bool),
        "blended": frame["blended_risk"].to_numpy(float),
        "classification": frame["classification_score"].to_numpy(float),
        "frame": frame,
    }
    manifest = {
        "fold": fold,
        "experiment": experiment_name,
        "target_filter_mode": spec.target_filter_mode,
        "preprocessing_mode": spec.preprocessing_mode,
        "feature_count": len(processed.X_train.columns),
        "features": list(processed.X_train.columns),
        "feature_engineering": feature_manifest,
        "preprocessing": processed.manifest,
    }
    diagnostics = {
        "fold": float(fold),
        **prediction.diagnostics,
        "train_rows": float(len(fold_data.train)),
        "test_rows": float(len(fold_data.test)),
        "train_rows_recovered": float(fold_data.train_audit["recovered_by_grade10_only"]),
        "test_rows_recovered": float(fold_data.test_audit["recovered_by_grade10_only"]),
    }
    audit = {
        "fold": fold,
        "experiment": experiment_name,
        "target_filter_mode": spec.target_filter_mode,
        **{f"train_{k}": v for k, v in fold_data.train_audit.items()},
        **{f"test_{k}": v for k, v in fold_data.test_audit.items()},
    }
    return record, manifest, diagnostics, audit


def tune_policies(records: Sequence[Mapping[str, object]]) -> Dict[str, Dict[str, float]]:
    if not records:
        raise ValueError("At least one tuning record is required")
    y = np.concatenate([np.asarray(r["y_bin"], dtype=bool) for r in records])
    prevalence = float(y.mean())
    policies: Dict[str, Dict[str, float]] = {}
    for signal in SIGNALS:
        score = np.concatenate([np.asarray(r[signal], dtype=float) for r in records])
        threshold, fixed = best_f1_threshold(y, score)
        policies[signal] = {
            "ap": average_precision(y, score),
            "auc": roc_auc(y, score),
            "threshold": float(threshold),
            "flag_rate": float(fixed["flag_rate"]),
            "ratio": float(fixed["flag_rate"] / max(prevalence, 1e-12)),
            "precision": float(fixed["precision"]),
            "recall": float(fixed["recall"]),
            "f1": float(fixed["f1"]),
            "f2": float(fixed["f2"]),
            "prevalence": prevalence,
        }
    return policies


def _evaluate_records(
    records: Sequence[MutableMapping[str, object]],
    policies: Mapping[str, Mapping[str, float]],
    tuning_records: Sequence[Mapping[str, object]],
) -> Tuple[List[Dict[str, float]], Dict[str, Dict[str, float]], List[Dict[str, float]]]:
    previous_prevalence = {
        int(r["fold"]): float(np.asarray(r["y_bin"], dtype=bool).mean()) for r in tuning_records
    }
    fallback_prevalence = float(
        np.concatenate([np.asarray(r["y_bin"], bool) for r in tuning_records]).mean()
    )
    fold_rows: List[Dict[str, float]] = []
    pooled_data = {
        signal: {"y": [], "score": [], "fixed": [], "drift": []} for signal in SIGNALS
    }
    for record in sorted(records, key=lambda item: int(item["fold"])):
        fold = int(record["fold"])
        y = np.asarray(record["y_bin"], bool)
        for signal in SIGNALS:
            score = np.asarray(record[signal], float)
            policy = policies[signal]
            fixed_warn = score >= float(policy["threshold"])
            reference_prev = previous_prevalence.get(fold - 1, fallback_prevalence)
            drift_rate = float(np.clip(float(policy["ratio"]) * reference_prev, 1e-4, 0.99))
            drift_warn = warn_by_rate(score, drift_rate)
            fixed = confusion_metrics(y, fixed_warn)
            drift = confusion_metrics(y, drift_warn)
            row = {
                "fold": fold,
                "signal": signal,
                "n": len(y),
                "prevalence": float(y.mean()),
                "ap": average_precision(y, score),
                "auc": roc_auc(y, score),
                "threshold": float(policy["threshold"]),
                "drift_rate": drift_rate,
            }
            row.update({f"fixed_{k}": float(v) for k, v in fixed.items()})
            row.update({f"drift_{k}": float(v) for k, v in drift.items()})
            fold_rows.append(row)
            pooled_data[signal]["y"].append(y)
            pooled_data[signal]["score"].append(score)
            pooled_data[signal]["fixed"].append(fixed_warn)
            pooled_data[signal]["drift"].append(drift_warn)
            if signal == "classification":
                frame = record["frame"]
                assert isinstance(frame, pd.DataFrame)
                frame["warn_fixed"] = fixed_warn.astype(int)
                frame["warn_drift"] = drift_warn.astype(int)
                frame["drift_warning_rate"] = drift_rate
        previous_prevalence[fold] = float(y.mean())

    pooled: Dict[str, Dict[str, float]] = {}
    budget_rows: List[Dict[str, float]] = []
    for signal in SIGNALS:
        y = np.concatenate(pooled_data[signal]["y"])
        score = np.concatenate(pooled_data[signal]["score"])
        fixed = confusion_metrics(y, np.concatenate(pooled_data[signal]["fixed"]))
        drift = confusion_metrics(y, np.concatenate(pooled_data[signal]["drift"]))
        pooled[signal] = {
            "ap": average_precision(y, score),
            "auc": roc_auc(y, score),
            **{f"fixed_{k}": float(v) for k, v in fixed.items()},
            **{f"drift_{k}": float(v) for k, v in drift.items()},
        }
        budget_records = [
            {"fold": int(r["fold"]), "y_bin": np.asarray(r["y_bin"], bool), "score": np.asarray(r[signal], float)}
            for r in records
        ]
        for rate in EQUAL_BUDGET_RATES:
            metrics = equal_budget_metrics(budget_records, rate)
            budget_rows.append({"signal": signal, "budget": rate, **metrics})
            if signal == "classification":
                for record in records:
                    frame = record["frame"]
                    assert isinstance(frame, pd.DataFrame)
                    frame[f"warn_at_{int(rate * 100)}pct"] = warn_by_rate(
                        np.asarray(record[signal], float), rate
                    ).astype(int)
    return fold_rows, pooled, budget_rows


def run_experiment(
    faculty: str,
    experiment_name: str,
    folds: Sequence[int],
    splits_dir: Path,
    output_root: Path,
    config: SuiteConfig,
    phase: str,
    save_predictions: bool = True,
    tuning_folds: Sequence[int] | None = None,
) -> Dict[str, object]:
    spec = EXPERIMENTS[experiment_name]
    experiment_dir = Path(output_root) / faculty / f"{spec.code}_{spec.slug}"
    experiment_dir.mkdir(parents=True, exist_ok=True)
    tuning_folds = list(tuning_folds) if tuning_folds is not None else list(folds)
    all_folds = sorted(set(folds) | set(tuning_folds))
    record_map: Dict[int, MutableMapping[str, object]] = {}
    manifests = []
    diagnostics = []
    audits = []
    for fold in all_folds:
        record, manifest, diagnostic, audit = _generate_record(
            faculty, experiment_name, fold, Path(splits_dir), config
        )
        record_map[fold] = record
        manifests.append(manifest)
        diagnostics.append(diagnostic)
        audits.append(audit)
    tuning_records = [record_map[f] for f in tuning_folds]
    evaluation_records = [record_map[f] for f in folds]
    policies = tune_policies(tuning_records)
    fold_rows, pooled, budget_rows = _evaluate_records(
        evaluation_records, policies, tuning_records
    )
    if save_predictions:
        for record in evaluation_records:
            frame = record["frame"]
            assert isinstance(frame, pd.DataFrame)
            frame.to_csv(experiment_dir / f"predictions_fold_{int(record['fold'])}.csv", index=False)
    pd.DataFrame(fold_rows).to_csv(experiment_dir / f"fold_metrics_{phase}.csv", index=False)
    pd.DataFrame(budget_rows).to_csv(experiment_dir / f"equal_budget_metrics_{phase}.csv", index=False)
    pd.DataFrame(diagnostics).to_csv(experiment_dir / f"training_diagnostics_{phase}.csv", index=False)
    pd.DataFrame(audits).to_csv(experiment_dir / f"target_filter_audit_{phase}.csv", index=False)
    (experiment_dir / f"feature_manifest_{phase}.json").write_text(
        json.dumps(manifests, ensure_ascii=False, indent=2, allow_nan=True), encoding="utf-8"
    )
    selected = max(
        SIGNALS,
        key=lambda signal: policies[signal]["ap"] if np.isfinite(policies[signal]["ap"]) else -np.inf,
    )
    summary = {
        "experiment": experiment_name,
        "slug": spec.slug,
        "description": spec.description,
        "phase": phase,
        "evaluation_folds": list(folds),
        "tuning_folds": list(tuning_folds),
        "selected_signal": selected,
        "tuning_policies": policies,
        "pooled": pooled,
        "feature_count_min": min(int(m["feature_count"]) for m in manifests),
        "feature_count_max": max(int(m["feature_count"]) for m in manifests),
    }
    (experiment_dir / f"summary_{phase}.json").write_text(
        json.dumps(summary, ensure_ascii=False, indent=2, allow_nan=True), encoding="utf-8"
    )
    return summary


def run_many_experiments(
    faculty: str,
    experiment_names: Sequence[str],
    folds: Sequence[int],
    splits_dir: Path,
    output_root: Path,
    config: SuiteConfig,
    phase: str,
    save_predictions: bool = True,
    tuning_folds: Sequence[int] | None = None,
) -> pd.DataFrame:
    rows = []
    for name in experiment_names:
        result = run_experiment(
            faculty, name, folds, splits_dir, output_root, config, phase,
            save_predictions=save_predictions, tuning_folds=tuning_folds,
        )
        row: Dict[str, object] = {
            "experiment": name,
            "slug": result["slug"],
            "selected_signal": result["selected_signal"],
            "feature_count_min": result["feature_count_min"],
            "feature_count_max": result["feature_count_max"],
        }
        experiment_dir = Path(output_root) / faculty / f"{name}_{result['slug']}"
        fold_metrics = pd.read_csv(experiment_dir / f"fold_metrics_{phase}.csv")
        for signal in SIGNALS:
            pooled = result["pooled"][signal]
            signal_folds = fold_metrics[fold_metrics["signal"] == signal]
            for key in ["ap", "auc", "fixed_f1", "fixed_recall", "fixed_precision", "drift_f1", "drift_recall"]:
                row[f"{signal}_{key}"] = pooled[key]
            row[f"{signal}_mean_fold_ap"] = float(signal_folds["ap"].mean())
            row[f"{signal}_worst_fold_ap"] = float(signal_folds["ap"].min())
        rows.append(row)
    comparison = pd.DataFrame(rows).sort_values(
        ["classification_ap", "classification_mean_fold_ap", "classification_fixed_f1"],
        ascending=False,
    )
    faculty_dir = Path(output_root) / faculty
    faculty_dir.mkdir(parents=True, exist_ok=True)
    comparison.to_csv(faculty_dir / f"experiment_comparison_{phase}.csv", index=False)
    return comparison
