#!/usr/bin/env python3
from __future__ import annotations

import argparse
import json
from pathlib import Path
from typing import Iterable

import numpy as np
import pandas as pd

from experiment_b_suite.experiments import EXPERIMENTS
from experiment_b_suite.runner import EQUAL_BUDGET_RATES, SIGNALS, experiment_directory


def aggregate_experiment_outputs(
    output_root: Path,
    faculty: str,
    phase: str,
    experiment_names: Iterable[str],
) -> pd.DataFrame:
    rows: list[dict[str, object]] = []
    for name in experiment_names:
        spec = EXPERIMENTS[name]
        exp_dir = experiment_directory(Path(output_root), faculty, spec.code, spec.slug)
        summary_path = exp_dir / f"summary_{phase}.json"
        fold_path = exp_dir / f"fold_metrics_{phase}.csv"
        budget_path = exp_dir / f"equal_budget_metrics_{phase}.csv"
        if not summary_path.exists() or not fold_path.exists() or not budget_path.exists():
            raise FileNotFoundError(
                f"Missing result files for {name}: {summary_path}, {fold_path}, {budget_path}"
            )
        summary = json.loads(summary_path.read_text(encoding="utf-8"))
        folds = pd.read_csv(fold_path)
        budgets = pd.read_csv(budget_path)
        row: dict[str, object] = {
            "experiment": name,
            "slug": summary["slug"],
            "selected_signal": summary["selected_signal"],
            "feature_count_min": summary["feature_count_min"],
            "feature_count_max": summary["feature_count_max"],
        }
        for signal in SIGNALS:
            pooled = summary["pooled"][signal]
            sfolds = folds[folds["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(sfolds["ap"].mean())
            row[f"{signal}_worst_fold_ap"] = float(sfolds["ap"].min())
            sbudgets = budgets[budgets["signal"] == signal]
            for rate in EQUAL_BUDGET_RATES:
                match = sbudgets[np.isclose(sbudgets["budget"], rate)]
                if match.empty:
                    continue
                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,
    ).reset_index(drop=True)
    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


def parse_experiments(value: str) -> list[str]:
    if value.strip().lower() == "all":
        return list(EXPERIMENTS)
    names = [x.strip().upper() for x in value.split(",") if x.strip()]
    unknown = [name for name in names if name not in EXPERIMENTS]
    if unknown:
        raise argparse.ArgumentTypeError(f"Unknown experiments: {unknown}")
    return names


def main() -> None:
    parser = argparse.ArgumentParser(description="Aggregate separately executed Experiment B runs.")
    parser.add_argument("--output_dir", default="./experiment_B_outputs")
    parser.add_argument("--faculty", default="khoa_cong_nghe_thong_tin")
    parser.add_argument("--phase", default="dev", choices=["dev", "holdout", "all"])
    parser.add_argument("--experiments", default="all")
    args = parser.parse_args()
    result = aggregate_experiment_outputs(
        Path(args.output_dir), args.faculty, args.phase, parse_experiments(args.experiments)
    )
    print(result.to_string(index=False))


if __name__ == "__main__":
    main()
