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 load_fold
from .experiments import EXPERIMENTS
from .features import build_experiment_features
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 experiment_directory(output_root: Path, faculty: str, code: str, slug: str) -> Path:
    return Path(output_root) / faculty / f"{code}_{slug}"


def resolve_phase(phase: str, dev_folds: Sequence[int], holdout_folds: Sequence[int]) -> tuple[list[int], list[int] | None]:
    if phase == "dev":
        return list(dev_folds), None
    if phase == "holdout":
        return list(holdout_folds), list(dev_folds)
    if phase == "all":
        combined = list(dev_folds) + [f for f in holdout_folds if f not in dev_folds]
        return combined, list(dev_folds)
    raise ValueError(f"Unknown phase: {phase}")


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 _history_depth_band(frame: pd.DataFrame) -> pd.Series:
    count = pd.to_numeric(frame.get("hist_semester_count", 0), errors="coerce").fillna(0)
    return pd.cut(
        count,
        bins=[-np.inf, 0, 1, 2, 5, np.inf],
        labels=["0", "1", "2", "3-5", "6+"],
        right=True,
    ).astype(str)


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",
    ]
    out = frame[[c for c in columns if c in frame.columns]].reset_index(drop=True).copy()
    out["history_depth_band"] = _history_depth_band(frame.reset_index(drop=True))
    return out


def _json_ready(value: object) -> object:
    if isinstance(value, pd.DataFrame):
        return value.to_dict(orient="records")
    if isinstance(value, np.ndarray):
        return value.tolist()
    if isinstance(value, (np.integer, np.floating)):
        return value.item()
    if isinstance(value, dict):
        return {str(k): _json_ready(v) for k, v in value.items()}
    if isinstance(value, (list, tuple)):
        return [_json_ready(v) for v in value]
    return value


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],
    Dict[str, object],
]:
    spec = EXPERIMENTS[experiment_name]
    fold_data = load_fold(faculty, fold, splits_dir, config)
    built = build_experiment_features(fold_data.train, fold_data.test, spec, config)
    processed = fit_transform_preprocessor(
        built.train,
        built.test,
        mode=built.preprocessing_mode,
        lower_quantile=config.winsor_lower_quantile,
        upper_quantile=config.winsor_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,
        "pipeline": spec.pipeline,
        "preprocessing_mode": built.preprocessing_mode,
        "feature_count": len(processed.X_train.columns),
        "features": list(processed.X_train.columns),
        "feature_engineering": built.manifest,
        "preprocessing": processed.manifest,
    }
    diagnostics = {
        "fold": float(fold),
        **prediction.diagnostics,
        "train_rows": float(len(fold_data.train)),
        "test_rows": float(len(fold_data.test)),
        "feature_count": float(len(processed.X_train.columns)),
    }
    audit = {
        "fold": fold,
        "experiment": experiment_name,
        **{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, built.artifacts


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 _save_artifacts(experiment_dir: Path, fold: int, artifacts: Mapping[str, object]) -> Dict[str, str]:
    saved: Dict[str, str] = {}
    for name, value in artifacts.items():
        if isinstance(value, pd.DataFrame):
            path = experiment_dir / f"{name}_fold_{fold}.csv"
            value.to_csv(path, index=False)
        else:
            path = experiment_dir / f"{name}_fold_{fold}.json"
            path.write_text(
                json.dumps(_json_ready(value), ensure_ascii=False, indent=2, allow_nan=True),
                encoding="utf-8",
            )
        saved[name] = path.name
    return saved


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 = experiment_directory(output_root, faculty, 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, artifacts = _generate_record(
            faculty, experiment_name, fold, Path(splits_dir), config
        )
        manifest["saved_artifacts"] = _save_artifacts(experiment_dir, fold, artifacts)
        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(_json_ready(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(_json_ready(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 = experiment_directory(output_root, faculty, name, str(result["slug"]))
        fold_metrics = pd.read_csv(experiment_dir / f"fold_metrics_{phase}.csv")
        budgets = pd.read_csv(experiment_dir / f"equal_budget_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())
            signal_budgets = budgets[budgets["signal"] == signal]
            for rate in EQUAL_BUDGET_RATES:
                match = signal_budgets[np.isclose(signal_budgets["budget"], rate)]
                if not match.empty:
                    pct = int(rate * 100)
                    row[f"{signal}_recall_at_{pct}pct"] = float(match.iloc[0]["recall"])
                    row[f"{signal}_f2_at_{pct}pct"] = float(match.iloc[0]["f2"])
        rows.append(row)
    comparison = pd.DataFrame(rows).sort_values(
        ["classification_ap", "classification_mean_fold_ap", "classification_f2_at_15pct"],
        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
