from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
from typing import Any, Iterable

import numpy as np
import pandas as pd


REQUIRED_REFERENCE_DIAG_COLUMNS = [
    "dataset",
    "target_name",
    "reference_ligand_id",
    "reference_ligand_score",
    "reference_ligand_rank_percentile",
    "adaptive_best_score",
    "exhaustive_best_score",
]

REQUIRED_BACKEND_COMPARISON_COLUMNS = [
    "dataset",
    "backend",
    "analysis_scope",
    "available",
    "n_ligands",
    "runtime_seconds",
    "runtime_per_ligand",
    "reference_ligand_score",
    "reference_ligand_rank_percentile",
    "best_score",
    "score_gap_reference_vs_best",
    "reference_pose_centroid_distance_A",
    "reference_pose_in_expected_pocket",
]

REQUIRED_POCKET_PREP_COLUMNS = [
    "dataset",
    "backend",
    "pocket_variant",
    "prep_variant",
    "reference_ligand_score",
    "reference_pose_centroid_distance_A",
    "reference_pose_in_expected_pocket",
]


@dataclass(frozen=True)
class ManualAgentsCheck:
    exists: bool
    path: str
    manually_read: bool


def manual_agents_check(path: str | Path, manually_read: bool = True) -> ManualAgentsCheck:
    p = Path(path).expanduser().resolve()
    return ManualAgentsCheck(exists=p.exists(), path=str(p), manually_read=bool(manually_read and p.exists()))


def _safe_float(x: Any, default: float = np.nan) -> float:
    try:
        v = float(x)
        return float(v) if np.isfinite(v) else float(default)
    except Exception:
        return float(default)


def compute_rank_percentile(df: pd.DataFrame, ligand_id: str, score_col: str, lower_is_better: bool = True) -> float:
    if df.empty or score_col not in df.columns:
        return np.nan
    d = df[["ligand_id", score_col]].copy()
    d["ligand_id"] = d["ligand_id"].astype(str)
    d[score_col] = pd.to_numeric(d[score_col], errors="coerce")
    d = d.dropna(subset=[score_col]).copy()
    if d.empty:
        return np.nan
    d = d.sort_values(score_col, ascending=bool(lower_is_better)).reset_index(drop=True)
    hit = d.index[d["ligand_id"] == str(ligand_id)]
    if len(hit) == 0:
        return np.nan
    rank = int(hit[0]) + 1
    return float(100.0 * rank / max(1, d.shape[0]))


def select_suspicious_datasets(reference_diag_df: pd.DataFrame, threshold_pct: float = 25.0, max_deep: int = 2) -> list[str]:
    if reference_diag_df.empty:
        return []
    d = reference_diag_df.copy()
    d["reference_ligand_rank_percentile"] = pd.to_numeric(d["reference_ligand_rank_percentile"], errors="coerce")
    d = d.dropna(subset=["reference_ligand_rank_percentile"]).copy()
    d = d[d["reference_ligand_rank_percentile"] >= float(threshold_pct)].copy()
    if d.empty:
        return []
    d = d.sort_values("reference_ligand_rank_percentile", ascending=False)
    return d["dataset"].astype(str).head(int(max(1, max_deep))).tolist()


def validate_required_columns(df: pd.DataFrame, required_columns: Iterable[str]) -> list[str]:
    cols = set(df.columns)
    missing = [c for c in required_columns if c not in cols]
    return missing


def recommend_toolchain(
    backend_comparison_df: pd.DataFrame,
    pocket_prep_df: pd.DataFrame,
) -> dict[str, Any]:
    """
    Choose practical recommendation from diagnostic evidence.

    Policy:
    - Prefer backend with best median reference rank percentile under "subset_default" scope.
    - Penalize poor runtime-per-ligand if >2x best runtime.
    - Use pocket/prep gain to detect whether core issue is mostly preparation/pocket.
    """
    out: dict[str, Any] = {
        "recommended_main_backend": "rdock",
        "recommended_rescoring": "gnina_or_haddock_shortlist_optional",
        "keep_haddock": "optional_shortlist_only",
        "main_failure_source": "mixed",
        "evidence": [],
    }

    bdf = backend_comparison_df.copy()
    if not bdf.empty:
        bdf = bdf[bdf["analysis_scope"].astype(str) == "subset_default"].copy()
    if not bdf.empty:
        bdf["runtime_per_ligand"] = pd.to_numeric(bdf["runtime_per_ligand"], errors="coerce")
        bdf["reference_ligand_rank_percentile"] = pd.to_numeric(bdf["reference_ligand_rank_percentile"], errors="coerce")
        agg = (
            bdf.groupby("backend", as_index=False)
            .agg(
                median_ref_rank_pct=("reference_ligand_rank_percentile", "median"),
                median_runtime=("runtime_per_ligand", "median"),
                available_ratio=("available", "mean"),
            )
            .sort_values(["median_ref_rank_pct", "median_runtime"], ascending=[True, True])
        )
        if not agg.empty:
            best = agg.iloc[0]
            best_runtime = max(1e-9, _safe_float(best["median_runtime"], 1.0))
            candidate = str(best["backend"])
            if _safe_float(best["available_ratio"], 0.0) < 0.5:
                out["evidence"].append("best_rank_backend_not_reliably_available")
            else:
                out["recommended_main_backend"] = candidate

            rd = agg[agg["backend"].astype(str).str.lower() == "rdock"]
            if not rd.empty:
                rd_runtime = max(1e-9, _safe_float(rd.iloc[0]["median_runtime"], best_runtime))
                if best_runtime > 2.0 * rd_runtime and candidate != "rdock":
                    out["evidence"].append("candidate_backend_too_slow_vs_rdock")
                    out["recommended_main_backend"] = "rdock"

            out["evidence"].append(f"rank_runtime_table={agg.to_dict(orient='records')}")

    pdf = pocket_prep_df.copy()
    if not pdf.empty:
        pdf["reference_ligand_score"] = pd.to_numeric(pdf["reference_ligand_score"], errors="coerce")
        deltas: list[float] = []
        for (_, _), sub in pdf.groupby(["dataset", "backend"]):
            default = sub[(sub["pocket_variant"] == "default") & (sub["prep_variant"] == "default")]
            if default.empty:
                continue
            default_score = _safe_float(default.iloc[0]["reference_ligand_score"], np.nan)
            best_score = _safe_float(sub["reference_ligand_score"].min(), np.nan)
            if np.isfinite(default_score) and np.isfinite(best_score):
                deltas.append(default_score - best_score)
        mean_gain = float(np.mean(np.asarray(deltas, dtype=float))) if deltas else 0.0
        if mean_gain > 1.0:
            out["main_failure_source"] = "pocket_or_preparation"
        elif mean_gain > 0.2:
            out["main_failure_source"] = "mixed"
        else:
            out["main_failure_source"] = "backend_scoring_limitations"
        out["evidence"].append(f"mean_reference_gain_from_pocket_prep={mean_gain:.3f}")

    out["keep_haddock"] = "optional_shortlist_only"
    return out