from __future__ import annotations

from dataclasses import dataclass
from typing import Iterable, List

import numpy as np
import pandas as pd

from libs.adaptive.policies import PrioritizationPolicy


def clamp_time_importance(value: float) -> float:
    return float(max(0.0, min(1.0, float(value))))


@dataclass(frozen=True)
class TimeImportanceControls:
    utility_weight: float
    uncertainty_weight: float
    diversity_weight: float
    cluster_bonus_weight: float
    threshold_stop_shift: float
    exploration_additive: float


def controls_from_time_importance(
    base_policy: PrioritizationPolicy,
    *,
    exploration_boost: float,
    time_importance: float,
) -> TimeImportanceControls:
    ti = clamp_time_importance(time_importance)
    exp = float(max(0.0, exploration_boost))

    adjusted_exp = float(max(0.0, exp + (1.0 - ti) * 0.22))
    utility = max(0.15, float(base_policy.utility_weight) - 0.40 * adjusted_exp + 0.22 * ti)
    uncertainty = max(0.05, float(base_policy.uncertainty_weight) + 0.22 * adjusted_exp - 0.10 * ti)
    diversity = max(0.05, float(base_policy.diversity_weight) + 0.14 * adjusted_exp - 0.08 * ti)
    cluster_bonus = float(base_policy.cluster_bonus_weight) + 0.04 * adjusted_exp
    # Negative means easier stopping (more time-sensitive).
    threshold_stop_shift = float(-0.20 * ti)
    return TimeImportanceControls(
        utility_weight=float(utility),
        uncertainty_weight=float(uncertainty),
        diversity_weight=float(diversity),
        cluster_bonus_weight=float(cluster_bonus),
        threshold_stop_shift=threshold_stop_shift,
        exploration_additive=adjusted_exp,
    )


def required_budget_metric_columns() -> List[str]:
    return [
        "dataset",
        "strategy",
        "strategy_group",
        "budget",
        "time_importance",
        "top10_recovery_fraction",
        "top50_recovery_fraction",
        "top100_recovery_fraction",
        "best_docking_score",
        "best_final_score",
        "dockings_performed",
        "wall_time_seconds",
        "quality_per_time",
        "quality_per_docking",
        "auc_best_score_so_far",
    ]


def validate_budget_metric_schema(df: pd.DataFrame) -> List[str]:
    missing = [c for c in required_budget_metric_columns() if c not in df.columns]
    return missing


def select_best_policy_budget(metrics_df: pd.DataFrame) -> pd.Series:
    if metrics_df.empty:
        raise ValueError("metrics_df is empty")
    missing = validate_budget_metric_schema(metrics_df)
    if missing:
        raise ValueError(f"metrics_df missing required columns: {missing}")

    d = metrics_df.copy()
    if "strategy_group" in d.columns:
        d = d[d["strategy_group"].astype(str) == "adaptive"].copy()
    if d.empty:
        raise ValueError("No adaptive rows found for selection")

    for c in ["top10_recovery_fraction", "top50_recovery_fraction", "top100_recovery_fraction", "quality_per_time", "quality_per_docking"]:
        d[f"rank_{c}"] = pd.to_numeric(d[c], errors="coerce").rank(method="average", ascending=False)
    d["rank_budget"] = pd.to_numeric(d["budget"], errors="coerce").rank(method="average", ascending=True)
    d["rank_best_final"] = pd.to_numeric(d["best_final_score"], errors="coerce").rank(method="average", ascending=True)

    d["selection_score"] = (
        0.24 * d["rank_top50_recovery_fraction"]
        + 0.24 * d["rank_top100_recovery_fraction"]
        + 0.20 * d["rank_top10_recovery_fraction"]
        + 0.12 * d["rank_quality_per_docking"]
        + 0.10 * d["rank_quality_per_time"]
        + 0.06 * d["rank_best_final"]
        + 0.04 * d["rank_budget"]
    )
    chosen = d.sort_values(["selection_score", "budget"], ascending=[True, True]).iloc[0]
    return chosen


def summarize_diversity(df: pd.DataFrame, *, similarity_col: str = "reference_similarity", scaffold_col: str = "scaffold_core") -> pd.DataFrame:
    vals = pd.to_numeric(df.get(similarity_col, pd.Series(dtype=float)), errors="coerce").dropna()
    bins = np.linspace(0.0, 1.0, 11)
    hist, edges = np.histogram(vals.to_numpy(dtype=float), bins=bins)
    out = pd.DataFrame(
        {
            "bin_left": edges[:-1],
            "bin_right": edges[1:],
            "count": hist,
            "fraction": hist / max(1, int(hist.sum())),
        }
    )
    out["unique_scaffold_count"] = int(df.get(scaffold_col, pd.Series(dtype=str)).astype(str).replace({"": np.nan}).dropna().nunique())
    out["total_ligands"] = int(df.shape[0])
    return out