from __future__ import annotations

import argparse
import csv
import json
import math
from pathlib import Path
from typing import Any


def _read_rows(path: Path) -> list[dict[str, str]]:
    with path.open("r", encoding="utf-8", newline="") as handle:
        return list(csv.DictReader(handle))


def _float(value: object, default: float | None = None) -> float | None:
    try:
        text = str(value).strip()
        if not text:
            return default
        value_f = float(text)
        return value_f if math.isfinite(value_f) else default
    except Exception:
        return default


def _mean(values: list[float]) -> float:
    return sum(values) / len(values) if values else 0.0


def _spearman(xs: list[float], ys: list[float]) -> float | None:
    if len(xs) < 2 or len(xs) != len(ys):
        return None

    def _ranks(values: list[float]) -> list[float]:
        order = sorted(range(len(values)), key=lambda idx: values[idx])
        ranks = [0.0] * len(values)
        for rank, idx in enumerate(order, start=1):
            ranks[idx] = float(rank)
        return ranks

    rx = _ranks(xs)
    ry = _ranks(ys)
    mx = _mean(rx)
    my = _mean(ry)
    num = sum((a - mx) * (b - my) for a, b in zip(rx, ry))
    denx = math.sqrt(sum((a - mx) ** 2 for a in rx))
    deny = math.sqrt(sum((b - my) ** 2 for b in ry))
    if denx == 0.0 or deny == 0.0:
        return None
    return num / (denx * deny)


def _ensure_matplotlib():
    try:
        import matplotlib

        matplotlib.use("Agg")
        import matplotlib.pyplot as plt
    except Exception:
        return None
    return plt


def _plot(run_dir: Path, name: str, fn) -> str | None:  # type: ignore[no-untyped-def]
    plt = _ensure_matplotlib()
    if plt is None:
        return None
    plot_dir = run_dir / "plots"
    plot_dir.mkdir(parents=True, exist_ok=True)
    fig = fn(plt)
    fig.tight_layout()
    path = plot_dir / name
    fig.savefig(path, dpi=160)
    plt.close(fig)
    return str(path)


def validate_fidelity(run_dir: str | Path) -> dict[str, Any]:
    root = Path(run_dir)
    trace_path = root / "tables" / "multifidelity_trace.csv"
    rows = _read_rows(trace_path) if trace_path.exists() else []
    per_ligand: dict[str, dict[int, dict[str, Any]]] = {}
    for row in rows:
        ligand_id = str(row.get("ligand_id", ""))
        level = int(_float(row.get("selected_fidelity_runs"), 0.0) or 0)
        score = _float(row.get("SCORE"), None)
        if not ligand_id or level <= 0 or score is None:
            continue
        per_ligand.setdefault(ligand_id, {})[level] = dict(row)
    levels = sorted({level for values in per_ligand.values() for level in values})
    final_level = levels[-1] if levels else 0
    final_rows = {ligand_id: values for ligand_id, values in per_ligand.items() if final_level in values}
    correlations: dict[str, float | None] = {}
    recovery: dict[str, float] = {}
    false_negative: dict[str, float] = {}
    final_scores = {ligand_id: _float(values[final_level].get("SCORE"), 0.0) or 0.0 for ligand_id, values in final_rows.items()}
    ranked_final = sorted(final_scores.items(), key=lambda item: item[1])
    top_5_final = {ligand_id for ligand_id, _ in ranked_final[: max(1, int(math.ceil(len(ranked_final) * 0.05)))]}
    top_10_final = {ligand_id for ligand_id, _ in ranked_final[: max(1, int(math.ceil(len(ranked_final) * 0.10)))]}
    for level in levels:
        if level == final_level:
            continue
        xs: list[float] = []
        ys: list[float] = []
        low_scores: dict[str, float] = {}
        for ligand_id, values in final_rows.items():
            if level not in values:
                continue
            low = _float(values[level].get("SCORE"), None)
            final = _float(values[final_level].get("SCORE"), None)
            if low is None or final is None:
                continue
            xs.append(low)
            ys.append(final)
            low_scores[ligand_id] = low
        correlations[f"spearman_{level}_vs_{final_level}"] = _spearman(xs, ys)
        ranked_low = sorted(low_scores.items(), key=lambda item: item[1])
        top_5_low = {ligand_id for ligand_id, _ in ranked_low[: max(1, int(math.ceil(len(ranked_low) * 0.05)))]}
        top_10_low = {ligand_id for ligand_id, _ in ranked_low[: max(1, int(math.ceil(len(ranked_low) * 0.10)))]}
        recovery[f"top5pct_recovery_{level}_vs_{final_level}"] = len(top_5_low & top_5_final) / max(1, len(top_5_final))
        recovery[f"top10pct_recovery_{level}_vs_{final_level}"] = len(top_10_low & top_10_final) / max(1, len(top_10_final))
        false_negative[f"false_negative_rate_{level}_vs_{final_level}"] = 1.0 - recovery[f"top10pct_recovery_{level}_vs_{final_level}"]

    payload = {
        "run_dir": str(root),
        "levels": levels,
        "final_level": final_level,
        "n_multilevel_ligands": len(final_rows),
        "correlations": correlations,
        "rank_recovery": recovery,
        "promotion_false_negative_rate": false_negative,
        "low_fidelity_reliable": all((value or -1.0) >= 0.35 for key, value in correlations.items() if key.startswith("spearman_5") or key.startswith("spearman_10")),
    }
    metrics_path = root / "metrics" / "fidelity_reliability.json"
    metrics_path.parent.mkdir(parents=True, exist_ok=True)
    metrics_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")

    plots: list[str] = []
    if final_level:
        for level in levels:
            if level == final_level:
                continue
            points = []
            for ligand_id, values in final_rows.items():
                if level not in values:
                    continue
                low = _float(values[level].get("SCORE"), None)
                final = _float(values[final_level].get("SCORE"), None)
                if low is not None and final is not None:
                    points.append((low, final))
            if points:
                plot_name = f"fidelity_score_correlation_{level}_vs_{final_level}.png"
                result = _plot(
                    root,
                    plot_name,
                    lambda plt, pts=points, lvl=level: _scatter_plot(plt, pts, lvl, final_level),
                )
                if result:
                    plots.append(result)
        if correlations:
            result = _plot(root, "fidelity_rank_recovery.png", lambda plt: _recovery_plot(plt, recovery))
            if result:
                plots.append(result)
            result = _plot(root, "promotion_false_negative_rate.png", lambda plt: _recovery_plot(plt, false_negative, ylabel="False negative rate"))
            if result:
                plots.append(result)
    payload["plots"] = plots
    metrics_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
    return payload


def _scatter_plot(plt, points: list[tuple[float, float]], level: int, final_level: int):  # type: ignore[no-untyped-def]
    fig, ax = plt.subplots(figsize=(5, 5))
    xs = [item[0] for item in points]
    ys = [item[1] for item in points]
    ax.scatter(xs, ys, alpha=0.7, color="#3b6ea8")
    ax.set_title(f"Fidelity score correlation: {level} vs {final_level} runs")
    ax.set_xlabel(f"SCORE at {level} runs")
    ax.set_ylabel(f"SCORE at {final_level} runs")
    return fig


def _recovery_plot(plt, values: dict[str, float], ylabel: str = "Recovery fraction"):  # type: ignore[no-untyped-def]
    fig, ax = plt.subplots(figsize=(8, 4))
    labels = list(values.keys())
    scores = [float(values[key]) for key in labels]
    ax.bar(range(len(labels)), scores, color="#7a9d54")
    ax.set_xticks(range(len(labels)))
    ax.set_xticklabels(labels, rotation=35, ha="right")
    ax.set_ylabel(ylabel)
    ax.set_title(f"{ylabel} across fidelity comparisons")
    return fig


def run_from_args(args: argparse.Namespace) -> dict[str, Any]:
    return validate_fidelity(args.run_dir)


def build_arg_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="Validate how reliable low-fidelity rDock scores are relative to final fidelity.")
    parser.add_argument("--run-dir", required=True)
    return parser


def main() -> int:
    args = build_arg_parser().parse_args()
    print(json.dumps(run_from_args(args), indent=2))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())