pipeline/run_experimental_benchmark_single_library.py

from __future__ import annotations

import argparse
import json
import random
import shutil
import sys
import time
from pathlib import Path
from typing import Any, Dict, List, Sequence

ROOT_DIR = Path(__file__).resolve().parents[1]
if str(ROOT_DIR) not in sys.path:
    sys.path.insert(0, str(ROOT_DIR))

import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from rdkit import Chem, DataStructs
from rdkit.Chem import AllChem

from environment.doctor import run_doctor
from libs.adaptive.features import bundles_to_wide_frames, compute_feature_diagnostics
from libs.adaptive.metrics import enrichment_metrics
from libs.utils.config import load_config
from libs.utils.logging_utils import get_logger
from pipeline.run_experimental_benchmark import (
    StageTimer,
    _build_dataset,
    _encode_and_cluster,
    _recovery_tables,
    _run_adaptive_strategy,
    _run_random_baseline,
    _strict_backend_check,
)


def _time_stage(name: str, fn):
    t0 = time.time()
    out = fn()
    t1 = time.time()
    return out, StageTimer(name=name, start=t0, end=t1)


def _canonical(s: str) -> str | None:
    mol = Chem.MolFromSmiles(str(s))
    if mol is None:
        return None
    return Chem.MolToSmiles(mol, canonical=True)


def _sim(smiles_a: str, smiles_b: str) -> float:
    ma = Chem.MolFromSmiles(smiles_a)
    mb = Chem.MolFromSmiles(smiles_b)
    if ma is None or mb is None:
        return 0.0
    fa = AllChem.GetMorganFingerprintAsBitVect(ma, radius=2, nBits=2048)
    fb = AllChem.GetMorganFingerprintAsBitVect(mb, radius=2, nBits=2048)
    return float(DataStructs.TanimotoSimilarity(fa, fb))


def _annotate_similarity_to_refs(library_df: pd.DataFrame, refs_df: pd.DataFrame, analog_thr: float) -> pd.DataFrame:
    out = library_df.copy()
    refs = refs_df[["reference_id", "reference_smiles"]].copy()

    sim_cols = []
    for ref in refs.itertuples(index=False):
        col = f"sim_{ref.reference_id}"
        sim_cols.append(col)
        out[col] = out["smiles"].astype(str).map(lambda s: _sim(str(s), str(ref.reference_smiles)))

    out["max_similarity_to_any_reference"] = out[sim_cols].max(axis=1)
    out["best_reference"] = out[sim_cols].idxmax(axis=1).str.replace("sim_", "", regex=False)

    def parent_refs(row: pd.Series) -> str:
        ids = []
        for ref in refs["reference_id"].tolist():
            if float(row[f"sim_{ref}"]) >= analog_thr:
                ids.append(ref)
        if not ids:
            ids = [str(row["best_reference"])]
        return ";".join(sorted(set(ids)))

    out["parent_references"] = out.apply(parent_refs, axis=1)
    return out


def _select_shared_library(annotated_df: pd.DataFrame, refs_df: pd.DataFrame, target_size: int) -> pd.DataFrame:
    ref_ids = set(refs_df["reference_id"].astype(str).tolist())
    ref_rows = annotated_df[annotated_df["ligand_id"].astype(str).isin(ref_ids)].copy()

    non_ref = annotated_df[~annotated_df["ligand_id"].astype(str).isin(ref_ids)].copy()
    non_ref = non_ref.sort_values(
        ["max_similarity_to_any_reference", "similarity_to_reference"],
        ascending=[False, False],
    )

    # Ensure balanced coverage by best reference before global fill.
    ref_targets = max(1, (target_size - ref_rows.shape[0]) // 3)
    picked = []
    taken = set(ref_rows["ligand_id"].astype(str).tolist())

    for ref_id in refs_df["reference_id"].astype(str).tolist():
        cand = non_ref[non_ref["best_reference"] == ref_id]
        for row in cand.itertuples(index=False):
            if row.ligand_id in taken:
                continue
            picked.append(row)
            taken.add(row.ligand_id)
            if sum(1 for r in picked if r.best_reference == ref_id) >= ref_targets:
                break

    if len(picked) < target_size - ref_rows.shape[0]:
        for row in non_ref.itertuples(index=False):
            if row.ligand_id in taken:
                continue
            picked.append(row)
            taken.add(row.ligand_id)
            if len(picked) >= target_size - ref_rows.shape[0]:
                break

    pick_df = pd.DataFrame([r._asdict() for r in picked]) if picked else pd.DataFrame(columns=annotated_df.columns)
    shared = pd.concat([ref_rows, pick_df], axis=0, ignore_index=True)
    shared = shared.drop_duplicates(subset=["smiles"], keep="first").reset_index(drop=True)

    # Trim if over target while keeping refs.
    if shared.shape[0] > target_size:
        refs = shared[shared["ligand_id"].astype(str).isin(ref_ids)]
        others = shared[~shared["ligand_id"].astype(str).isin(ref_ids)].sort_values(
            ["max_similarity_to_any_reference"], ascending=False
        )
        keep_others = max(0, target_size - refs.shape[0])
        shared = pd.concat([refs, others.head(keep_others)], axis=0, ignore_index=True)

    shared["is_reference"] = shared["ligand_id"].astype(str).isin(ref_ids)
    return shared.reset_index(drop=True)


def _build_single_library_dataset(config: Dict[str, Any], root: Path, logger) -> Dict[str, Any]:
    data = _build_dataset(config, root, logger)

    out_dir = root / config["benchmark_dataset"]["output_dir"]
    out_dir.mkdir(parents=True, exist_ok=True)

    refs = data["reference_df"].copy()
    raw = data["dedup_df"].copy()

    analog_thr = float(config["benchmark_dataset"].get("analog_similarity_threshold", 0.65))
    target_size = int(config["benchmark_dataset"].get("shared_library_target_size", 1500))

    annotated = _annotate_similarity_to_refs(raw, refs, analog_thr=analog_thr)
    shared = _select_shared_library(annotated, refs, target_size=target_size)

    # Ensure reference IDs have exact row IDs.
    ref_smiles_map = dict(zip(refs["reference_id"], refs["reference_smiles"]))
    for ref_id, ref_smiles in ref_smiles_map.items():
        c = _canonical(str(ref_smiles))
        if c is None:
            continue
        mask = shared["smiles"].astype(str).map(_canonical) == c
        if mask.any():
            shared.loc[mask, "ligand_id"] = ref_id
            shared.loc[mask, "is_reference"] = True
            shared.loc[mask, "source"] = "reference"

    # Attach affinity to references when available.
    aff = data["affinity_norm_df"].copy()
    ref_aff = []
    for ref in refs.itertuples(index=False):
        ref_s = _canonical(str(ref.reference_smiles))
        rec = {
            "reference_id": ref.reference_id,
            "pdb_id": ref.pdb_id,
            "ligand_comp_id": ref.ligand_comp_id,
            "ligand_name": ref.ligand_name,
            "source_structure": ref.pdb_id,
            "reference_smiles": ref.reference_smiles,
            "affinity_type": np.nan,
            "affinity_value": np.nan,
            "affinity_units": np.nan,
            "pchembl_value": np.nan,
        }
        if not aff.empty:
            sub = aff[aff["smiles"].astype(str).map(_canonical) == ref_s]
            if not sub.empty:
                best = sub.sort_values("measurements", ascending=False).iloc[0]
                rec["affinity_type"] = best.get("standard_type")
                rec["affinity_value"] = best.get("standard_value_median")
                rec["affinity_units"] = best.get("standard_units")
                rec["pchembl_value"] = best.get("pchembl_value_median")
        ref_aff.append(rec)

    refs_out = pd.DataFrame(ref_aff)

    # Scaffold annotations and provenance tables.
    sim_cols = [c for c in shared.columns if c.startswith("sim_ref_")]
    scaffold_cols = [
        "ligand_id",
        "smiles",
        "scaffold_core",
        "scaffold_match",
        "best_reference",
        "parent_references",
        *sim_cols,
    ]
    scaffold_df = shared[[c for c in scaffold_cols if c in shared.columns]].copy()

    prov_cols = [
        "ligand_id",
        "smiles",
        "source",
        "is_reference",
        "parent_references",
        "best_reference",
        "similarity_to_reference",
        "max_similarity_to_any_reference",
        "pubchem_cid",
        "retrieval_threshold",
        *sim_cols,
    ]
    provenance_df = shared[[c for c in prov_cols if c in shared.columns]].copy()

    # Required dataset files.
    refs_out.to_csv(out_dir / "reference_ligands.csv", index=False)
    annotated.to_csv(out_dir / "shared_library_raw.csv", index=False)
    shared.to_csv(out_dir / "shared_library_dedup.csv", index=False)
    scaffold_df.to_csv(out_dir / "scaffold_annotations.csv", index=False)
    provenance_df.to_csv(out_dir / "ligand_provenance.csv", index=False)

    return {
        **data,
        "reference_df": refs_out,
        "shared_raw_df": annotated,
        "shared_library_df": shared,
        "scaffold_df": scaffold_df,
        "provenance_df": provenance_df,
        "out_dir": out_dir,
    }


def _build_reference_plots(output_dir: Path, combined: pd.DataFrame, recovery: pd.DataFrame, analog_thr: float) -> list[str]:
    plots_dir = output_dir / "plots"
    plots_dir.mkdir(parents=True, exist_ok=True)
    paths: list[str] = []

    def save(name: str):
        p = plots_dir / name
        plt.tight_layout()
        plt.savefig(p, dpi=160)
        plt.close()
        paths.append(str(p))

    # selected_score_vs_step
    plt.figure(figsize=(8, 4))
    for strategy, sdf in combined.groupby("strategy"):
        d = sdf.sort_values("step")
        plt.plot(d["step"], d["docking_score"], label=strategy, alpha=0.8)
    plt.xlabel("Step")
    plt.ylabel("Docking score")
    plt.title("Selected Score vs Step")
    plt.legend()
    save("selected_score_vs_step.png")

    # selected_final_score_vs_step
    plt.figure(figsize=(8, 4))
    for strategy, sdf in combined.groupby("strategy"):
        d = sdf.sort_values("step")
        plt.plot(d["step"], d["final_score"], label=strategy, alpha=0.8)
    plt.xlabel("Step")
    plt.ylabel("Final score")
    plt.title("Selected Final Score vs Step")
    plt.legend()
    save("selected_final_score_vs_step.png")

    # best score so far
    plt.figure(figsize=(8, 4))
    for strategy, sdf in combined.groupby("strategy"):
        d = sdf.sort_values("step")
        y = np.minimum.accumulate(d["docking_score"].to_numpy(dtype=float))
        plt.plot(d["step"], y, label=strategy)
    plt.xlabel("Step")
    plt.ylabel("Best docking score so far")
    plt.title("Best Score So Far vs Step")
    plt.legend()
    save("best_score_so_far_vs_step.png")

    # best final score so far
    plt.figure(figsize=(8, 4))
    for strategy, sdf in combined.groupby("strategy"):
        d = sdf.sort_values("step")
        y = np.minimum.accumulate(d["final_score"].to_numpy(dtype=float))
        plt.plot(d["step"], y, label=strategy)
    plt.xlabel("Step")
    plt.ylabel("Best final score so far")
    plt.title("Best Final Score So Far vs Step")
    plt.legend()
    save("best_final_score_so_far_vs_step.png")

    # rolling mean score
    plt.figure(figsize=(8, 4))
    for strategy, sdf in combined.groupby("strategy"):
        d = sdf.sort_values("step")
        roll = d["docking_score"].rolling(window=100, min_periods=10).mean()
        plt.plot(d["step"], roll, label=strategy)
    plt.xlabel("Step")
    plt.ylabel("Rolling mean docking score")
    plt.title("Rolling Mean Score vs Step")
    plt.legend()
    save("rolling_mean_score_vs_step.png")

    # rolling good-hit fraction (global best 10% quantile)
    q = float(combined["docking_score"].quantile(0.1))
    plt.figure(figsize=(8, 4))
    for strategy, sdf in combined.groupby("strategy"):
        d = sdf.sort_values("step").copy()
        good = (d["docking_score"] <= q).astype(int)
        frac = good.rolling(window=100, min_periods=10).mean()
        plt.plot(d["step"], frac, label=strategy)
    plt.xlabel("Step")
    plt.ylabel("Rolling good-hit fraction")
    plt.title("Rolling Good Hit Fraction vs Step")
    plt.legend()
    save("rolling_good_hit_fraction_vs_step.png")

    # reference discovery step
    plt.figure(figsize=(8, 4))
    sub = recovery[["strategy", "reference_id", "reference_step"]].copy()
    x = np.arange(sub.shape[0])
    labels = [f"{r.reference_id}-{r.strategy}" for r in sub.itertuples(index=False)]
    y = pd.to_numeric(sub["reference_step"], errors="coerce")
    y = y.fillna(combined["step"].max() + 5)
    plt.bar(x, y)
    plt.xticks(x, labels, rotation=40, ha="right")
    plt.ylabel("Discovery step")
    plt.title("Reference Discovery Step")
    save("reference_discovery_step.png")

    # reference analog discovery step
    plt.figure(figsize=(8, 4))
    sub = recovery[["strategy", "reference_id", "first_analog_step"]].copy()
    x = np.arange(sub.shape[0])
    labels = [f"{r.reference_id}-{r.strategy}" for r in sub.itertuples(index=False)]
    y = pd.to_numeric(sub["first_analog_step"], errors="coerce")
    y = y.fillna(combined["step"].max() + 5)
    plt.bar(x, y)
    plt.xticks(x, labels, rotation=40, ha="right")
    plt.ylabel("Discovery step")
    plt.title("Reference Analog Discovery Step")
    save("reference_analog_discovery_step.png")

    # predicted vs realized / residual / uncertainty (adaptive only)
    ad = combined[combined["strategy"] == "adaptive"].copy()
    ad = ad[np.isfinite(pd.to_numeric(ad["predicted_score_prebatch"], errors="coerce"))]

    plt.figure(figsize=(5, 5))
    if not ad.empty:
        plt.scatter(ad["predicted_score_prebatch"], ad["docking_score"], s=16, alpha=0.6)
    plt.xlabel("Predicted")
    plt.ylabel("Realized")
    plt.title("Predicted vs Realized")
    save("predicted_vs_realized.png")

    plt.figure(figsize=(8, 4))
    if not ad.empty:
        res = pd.to_numeric(ad["predicted_score_prebatch"], errors="coerce") - pd.to_numeric(ad["docking_score"], errors="coerce")
        plt.plot(ad["step"], res, marker=".", linewidth=0.8)
    plt.xlabel("Step")
    plt.ylabel("Residual")
    plt.title("Residuals Over Time")
    save("residuals_over_time.png")

    plt.figure(figsize=(6, 4))
    if not ad.empty:
        abs_err = (
            pd.to_numeric(ad["predicted_score_prebatch"], errors="coerce") - pd.to_numeric(ad["docking_score"], errors="coerce")
        ).abs()
        plt.scatter(pd.to_numeric(ad["predicted_uncertainty_prebatch"], errors="coerce"), abs_err, s=16, alpha=0.6)
    plt.xlabel("Uncertainty")
    plt.ylabel("Absolute error")
    plt.title("Uncertainty vs Error")
    save("uncertainty_vs_error.png")

    # feature importance barplot (from rescoring contributions if unavailable)
    plt.figure(figsize=(9, 5))
    if "feature_contribution" in combined.columns:
        pass
    plt.title("Feature Importance")
    # Placeholder overwritten by caller if JSON available; kept non-empty.
    plt.text(0.5, 0.5, "See feature_importance.json", ha="center", va="center")
    plt.axis("off")
    save("feature_importance_barplot.png")

    # correlation heatmap
    cols = ["docking_score", "final_score", "interface_contact_proxy", "hbond_proxy", "shape_proxy", "similarity_to_parent_reference"]
    cdf = combined[[c for c in cols if c in combined.columns]].apply(pd.to_numeric, errors="coerce")
    corr = cdf.corr().fillna(0)
    plt.figure(figsize=(7, 6))
    plt.imshow(corr.to_numpy(), cmap="coolwarm", vmin=-1, vmax=1)
    plt.xticks(np.arange(corr.shape[1]), corr.columns, rotation=35, ha="right")
    plt.yticks(np.arange(corr.shape[0]), corr.index)
    plt.colorbar(label="Pearson r")
    plt.title("Metric Correlation Heatmap")
    save("metric_correlation_heatmap.png")

    return paths


def _replace_feature_importance_plot(output_dir: Path, feature_importance: Dict[str, float]) -> None:
    p = output_dir / "plots" / "feature_importance_barplot.png"
    plt.figure(figsize=(9, 5))
    items = sorted(feature_importance.items(), key=lambda kv: kv[1], reverse=True)[:20]
    if items:
        names = [k for k, _ in items]
        vals = [v for _, v in items]
        plt.barh(np.arange(len(vals)), vals)
        plt.yticks(np.arange(len(vals)), names)
        plt.gca().invert_yaxis()
        plt.title("Feature Importance (Top 20)")
    else:
        plt.text(0.5, 0.5, "No feature importance available", ha="center", va="center")
        plt.axis("off")
    plt.tight_layout()
    plt.savefig(p, dpi=160)
    plt.close()


def _ordering_metrics(df: pd.DataFrame) -> Dict[str, float]:
    d = df.sort_values("step").copy()
    n = d.shape[0]
    if n == 0:
        return {}

    e = max(1, int(0.2 * n))
    l = max(1, int(0.2 * n))

    early_mean = float(d.head(e)["docking_score"].mean())
    late_mean = float(d.tail(l)["docking_score"].mean())

    q10 = float(d["docking_score"].quantile(0.1))

    def frac_found(pct: float) -> float:
        k = max(1, int(pct * n))
        top = d.sort_values("docking_score").head(max(1, int(0.1 * n)))
        top_ids = set(top["ligand_id"].astype(str).tolist())
        first_ids = set(d.head(k)["ligand_id"].astype(str).tolist())
        return float(len(top_ids & first_ids) / max(1, len(top_ids)))

    best_so_far = np.minimum.accumulate(d["docking_score"].to_numpy(dtype=float))
    auc_best = float(np.trapz(best_so_far, dx=1.0))

    concentration = (
        d.assign(good=(d["docking_score"] <= q10).astype(int))
        .assign(cum_good=lambda x: x["good"].cumsum())
        .assign(step1=lambda x: x["step"] + 1)
    )
    concentration_idx = float((concentration["cum_good"] / concentration["step1"]).mean())

    return {
        "early_window_mean_score": early_mean,
        "late_window_mean_score": late_mean,
        "top10pct_found_in_first10pct": frac_found(0.10),
        "top10pct_found_in_first20pct": frac_found(0.20),
        "top10pct_found_in_first30pct": frac_found(0.30),
        "area_under_best_score_so_far_curve": auc_best,
        "score_concentration_index": concentration_idx,
    }


def _self_audit(output_dir: Path, refs: Sequence[str], target_size: int) -> Path:
    issues = []
    checks = []

    required_files = [
        "summary.json",
        "final_ranking_adaptive.csv",
        "final_ranking_naive.csv",
        "batch_history_adaptive.csv",
        "batch_history_naive.csv",
        "timings.csv",
        "clusters.csv",
        "hyperclusters.csv",
        "selected_ligands_adaptive.csv",
        "selected_ligands_naive.csv",
        "reference_recovery.csv",
        "reference_comparison.csv",
        "surrogate_diagnostics.csv",
        "parsed_scores.csv",
        "features_per_ligand.csv",
        "features_per_pose.csv",
        "feature_masks.csv",
        "feature_importance.json",
        "model_weight_over_time.csv",
        "feature_diagnostics.csv",
        "rescoring_terms.csv",
        "README_results.md",
        "validation_report.md",
        "self_audit_report.md",
    ]
    required_plots = [
        "selected_score_vs_step.png",
        "selected_final_score_vs_step.png",
        "best_score_so_far_vs_step.png",
        "best_final_score_so_far_vs_step.png",
        "rolling_mean_score_vs_step.png",
        "rolling_good_hit_fraction_vs_step.png",
        "reference_discovery_step.png",
        "reference_analog_discovery_step.png",
        "predicted_vs_realized.png",
        "residuals_over_time.png",
        "uncertainty_vs_error.png",
        "feature_importance_barplot.png",
        "metric_correlation_heatmap.png",
    ]

    for f in required_files:
        p = output_dir / f
        ok = p.exists() and p.stat().st_size > 0
        checks.append(f"- file `{f}` ok: `{ok}`")
        if not ok:
            issues.append(f"Missing file: {f}")

    for f in required_plots:
        p = output_dir / "plots" / f
        ok = p.exists() and p.stat().st_size > 0
        checks.append(f"- plot `{f}` ok: `{ok}`")
        if not ok:
            issues.append(f"Missing plot: {f}")

    data = pd.read_csv(output_dir / "data_snapshot.csv") if (output_dir / "data_snapshot.csv").exists() else pd.DataFrame()
    for r in refs:
        present = (not data.empty) and bool((data["ligand_id"].astype(str) == str(r)).any())
        checks.append(f"- reference `{r}` in library: `{present}`")
        if not present:
            issues.append(f"Reference missing in library: {r}")

    if not data.empty:
        n = int(data.shape[0])
        around = abs(n - target_size) <= 200
        checks.append(f"- library size around {target_size}: `{around}` (n={n})")
        if not around:
            issues.append(f"Library size not around {target_size}: {n}")

    parsed = pd.read_csv(output_dir / "parsed_scores.csv") if (output_dir / "parsed_scores.csv").exists() else pd.DataFrame()
    if not parsed.empty:
        no_fallback = not parsed["fallback_used"].astype(bool).any()
        real = bool((parsed["backend_mode"] == "real-rdock").all())
        checks.append(f"- no fallback rows: `{no_fallback}`")
        checks.append(f"- backend_mode real-rdock only: `{real}`")
        if not no_fallback:
            issues.append("Fallback rows detected")
        if not real:
            issues.append("Non-real backend rows detected")

        by_strategy = parsed.groupby("strategy", as_index=False).size()
        if by_strategy.shape[0] >= 2:
            vals = by_strategy["size"].astype(int).tolist()
            comparable = len(set(vals)) == 1
            checks.append(f"- adaptive/naive comparable evaluated counts: `{comparable}` ({vals})")
            if not comparable:
                issues.append(f"Adaptive/naive evaluated counts differ: {vals}")

    report_lines = ["# Self Audit Report", "", "## Checks", *checks, "", "## Issues"]
    if issues:
        report_lines.extend([f"- {i}" for i in issues])
    else:
        report_lines.append("- None")

    report_path = output_dir / "self_audit_report.md"
    report_path.write_text("\n".join(report_lines), encoding="utf-8")
    if issues:
        raise RuntimeError("Self-audit failed:\n" + "\n".join(issues))
    return report_path


def run_single_library_benchmark(config_path: str | Path) -> Dict[str, Any]:
    logger = get_logger("benchmark_single_library")
    config = load_config(config_path)
    root = Path(__file__).resolve().parents[1]

    run_cfg = config["run"]
    output_dir = root / run_cfg["output_dir"]
    if output_dir.exists():
        shutil.rmtree(output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    np.random.seed(int(run_cfg["random_seed"]))
    random.seed(int(run_cfg["random_seed"]))

    timers: list[StageTimer] = []

    doctor, tm = _time_stage("environment_check", run_doctor)
    timers.append(tm)

    dataset_info, tm = _time_stage("build_shared_library", lambda: _build_single_library_dataset(config, root, logger))
    timers.append(tm)

    shared_df = dataset_info["shared_library_df"].copy()
    shared_df = shared_df.reset_index(drop=True)
    shared_df["ligand_id"] = shared_df["ligand_id"].astype(str)
    shared_df["smiles"] = shared_df["smiles"].astype(str)

    refs = dataset_info["reference_df"]["reference_id"].astype(str).tolist()
    for r in refs:
        if not (shared_df["ligand_id"].astype(str) == r).any():
            raise RuntimeError(f"Reference ligand missing from shared library: {r}")

    (encodings, protein_encoding, cluster_map, hyper_map), tm = _time_stage(
        "encode_cluster",
        lambda: _encode_and_cluster(config, shared_df, dataset_info["target_path"]),
    )
    timers.append(tm)

    adaptive_info = _run_adaptive_strategy(
        config=config,
        root=root,
        output_dir=output_dir,
        ligands_df=shared_df,
        ligand_encodings=encodings,
        cluster_map=cluster_map,
        hyper_map=hyper_map,
        protein_encoding=protein_encoding,
        target_path=dataset_info["target_path"],
        stage_timers=timers,
    )

    t0 = time.time()
    naive_info = _run_random_baseline(
        config=config,
        output_dir=output_dir,
        ligands_df=shared_df,
        cluster_map=cluster_map,
        hyper_map=hyper_map,
        target_path=dataset_info["target_path"],
        seed=int(run_cfg["random_seed"]) + 101,
    )
    timers.append(StageTimer(name="naive_loop", start=t0, end=time.time()))

    adf = adaptive_info["evaluated_df"].copy()
    ndf = naive_info["evaluated_df"].copy()
    ndf["strategy"] = "naive"
    adf["strategy"] = "adaptive"

    combined = pd.concat([adf, ndf], axis=0, ignore_index=True)
    _strict_backend_check(combined.to_dict(orient="records"))

    # Rankings
    rank_ad = adf.sort_values("final_score").reset_index(drop=True)
    rank_ad["rank"] = np.arange(1, rank_ad.shape[0] + 1)
    rank_nv = ndf.sort_values("final_score").reset_index(drop=True)
    rank_nv["rank"] = np.arange(1, rank_nv.shape[0] + 1)

    recovery_df, ref_cmp_df, baseline_cmp_df = _recovery_tables(
        combined_df=combined,
        ligands_df=shared_df,
        references=refs,
        analog_similarity_threshold=float(config["analysis"].get("analog_similarity_threshold", 0.65)),
        topk_values=[10, 25, 50, 100],
    )

    # naive batch history from rounds
    bh_naive = (
        ndf.groupby("round", as_index=False)
        .agg(batch_size=("ligand_id", "count"), mean_score=("docking_score", "mean"), best_score=("docking_score", "min"))
        .rename(columns={"round": "round_idx"})
    )

    # surrogate diagnostics (adaptive)
    ad_pred = adf[np.isfinite(pd.to_numeric(adf["predicted_score_prebatch"], errors="coerce"))].copy()
    if ad_pred.empty:
        surrogate_diag = pd.DataFrame(columns=["step", "ligand_id", "predicted", "realized", "residual", "uncertainty", "abs_error"])
    else:
        surrogate_diag = pd.DataFrame(
            {
                "step": ad_pred["step"],
                "ligand_id": ad_pred["ligand_id"],
                "predicted": pd.to_numeric(ad_pred["predicted_score_prebatch"], errors="coerce"),
                "realized": pd.to_numeric(ad_pred["docking_score"], errors="coerce"),
                "uncertainty": pd.to_numeric(ad_pred["predicted_uncertainty_prebatch"], errors="coerce"),
            }
        )
        surrogate_diag["residual"] = surrogate_diag["predicted"] - surrogate_diag["realized"]
        surrogate_diag["abs_error"] = surrogate_diag["residual"].abs()

    # save primary outputs
    paths = {
        "summary": output_dir / "summary.json",
        "final_ranking_adaptive": output_dir / "final_ranking_adaptive.csv",
        "final_ranking_naive": output_dir / "final_ranking_naive.csv",
        "batch_history_adaptive": output_dir / "batch_history_adaptive.csv",
        "batch_history_naive": output_dir / "batch_history_naive.csv",
        "timings": output_dir / "timings.csv",
        "clusters": output_dir / "clusters.csv",
        "hyperclusters": output_dir / "hyperclusters.csv",
        "selected_ligands_adaptive": output_dir / "selected_ligands_adaptive.csv",
        "selected_ligands_naive": output_dir / "selected_ligands_naive.csv",
        "reference_recovery": output_dir / "reference_recovery.csv",
        "reference_comparison": output_dir / "reference_comparison.csv",
        "surrogate_diagnostics": output_dir / "surrogate_diagnostics.csv",
        "parsed_scores": output_dir / "parsed_scores.csv",
        "features_per_ligand": output_dir / "features_per_ligand.csv",
        "features_per_pose": output_dir / "features_per_pose.csv",
        "feature_masks": output_dir / "feature_masks.csv",
        "feature_importance": output_dir / "feature_importance.json",
        "model_weight_over_time": output_dir / "model_weight_over_time.csv",
        "feature_diagnostics": output_dir / "feature_diagnostics.csv",
        "rescoring_terms": output_dir / "rescoring_terms.csv",
        "readme": output_dir / "README_results.md",
        "validation_report": output_dir / "validation_report.md",
        "data_snapshot": output_dir / "data_snapshot.csv",
        "target_selection": output_dir / "target_selection.md",
        "provenance_table": output_dir / "ligand_provenance.csv",
        "scaffold_table": output_dir / "scaffold_annotations.csv",
        "reference_table": output_dir / "reference_ligands.csv",
        "shared_library_raw": output_dir / "shared_library_raw.csv",
        "shared_library_dedup": output_dir / "shared_library_dedup.csv",
    }

    rank_ad.to_csv(paths["final_ranking_adaptive"], index=False)
    rank_nv.to_csv(paths["final_ranking_naive"], index=False)
    pd.DataFrame(adaptive_info["scheduler"].state.batch_history).to_csv(paths["batch_history_adaptive"], index=False)
    bh_naive.to_csv(paths["batch_history_naive"], index=False)
    pd.DataFrame([{"stage": t.name, "seconds": t.seconds} for t in timers]).to_csv(paths["timings"], index=False)
    pd.DataFrame(
        [{"ligand_id": lid, "cluster_id": int(cluster_map[lid]), "hypercluster_id": int(hyper_map.get(cluster_map[lid], -1))} for lid in shared_df["ligand_id"]]
    ).to_csv(paths["clusters"], index=False)
    pd.DataFrame([{"cluster_id": int(c), "hypercluster_id": int(h)} for c, h in sorted(hyper_map.items())]).to_csv(
        paths["hyperclusters"], index=False
    )
    adaptive_info["selected_df"].to_csv(paths["selected_ligands_adaptive"], index=False)
    naive_info["selected_df"].to_csv(paths["selected_ligands_naive"], index=False)
    recovery_df.to_csv(paths["reference_recovery"], index=False)
    ref_cmp_df.to_csv(paths["reference_comparison"], index=False)
    surrogate_diag.to_csv(paths["surrogate_diagnostics"], index=False)
    combined.to_csv(paths["parsed_scores"], index=False)

    feature_values_df = adaptive_info["feature_values_df"].copy()
    feature_masks_df = adaptive_info["feature_masks_df"].copy()
    pose_features_df = adaptive_info["pose_features_df"].copy()
    feature_values_df.to_csv(paths["features_per_ligand"], index=False)
    pose_features_df.to_csv(paths["features_per_pose"], index=False)
    feature_masks_df.to_csv(paths["feature_masks"], index=False)

    feature_importance = adaptive_info["scheduler"].surrogate.feature_importance()
    paths["feature_importance"].write_text(json.dumps(feature_importance, indent=2), encoding="utf-8")
    adaptive_info["model_weight_df"].to_csv(paths["model_weight_over_time"], index=False)

    feat_diag = compute_feature_diagnostics(
        feature_values_df,
        feature_masks_df,
        target=feature_values_df["ligand_id"].map(adf.groupby("ligand_id")["docking_score"].min().to_dict()),
    )
    feat_diag.to_csv(paths["feature_diagnostics"], index=False)

    combined[["strategy", "step", "ligand_id", "docking_score", "interface_contact_proxy", "feature_rescore", "final_score"]].to_csv(
        paths["rescoring_terms"], index=False
    )

    shared_df.to_csv(paths["data_snapshot"], index=False)
    dataset_info["provenance_df"].to_csv(paths["provenance_table"], index=False)
    dataset_info["scaffold_df"].to_csv(paths["scaffold_table"], index=False)
    dataset_info["reference_df"].to_csv(paths["reference_table"], index=False)
    dataset_info["shared_raw_df"].to_csv(paths["shared_library_raw"], index=False)
    dataset_info["shared_library_df"].to_csv(paths["shared_library_dedup"], index=False)

    # target selection markdown
    refs_info = dataset_info["reference_df"].copy()
    lines = ["# Target Selection", "", "Chosen target: `MDM2`", "", "Reference complexes:"]
    for row in refs_info.itertuples(index=False):
        lines.append(
            f"- `{row.reference_id}` | pdb `{row.pdb_id}` | ligand `{row.ligand_comp_id}` | name `{row.ligand_name}` | affinity `{row.affinity_value}` `{row.affinity_units}`"
        )
        lines.append(f"  - reference_smiles: `{row.reference_smiles}`")
    paths["target_selection"].write_text("\n".join(lines), encoding="utf-8")

    # copy backend proofs
    raw_root = output_dir / "raw_rdock_outputs"
    raw_root.mkdir(parents=True, exist_ok=True)
    shutil.copytree(adaptive_info["raw_root"], raw_root / "adaptive", dirs_exist_ok=True)
    shutil.copytree(naive_info["raw_root"], raw_root / "naive", dirs_exist_ok=True)

    log_path = output_dir / "rdock_commands.log"
    log_path.write_text(
        "\n".join(
            [
                "# adaptive",
                adaptive_info["command_log"].read_text(encoding="utf-8") if adaptive_info["command_log"].exists() else "",
                "# naive",
                naive_info["command_log"].read_text(encoding="utf-8") if naive_info["command_log"].exists() else "",
            ]
        ),
        encoding="utf-8",
    )

    # ordering metrics for summary/report
    metrics_ad = _ordering_metrics(adf)
    metrics_nv = _ordering_metrics(ndf)

    topk_hit_ad = enrichment_metrics(
        scores=adf["docking_score"].astype(float).tolist(),
        labels=(adf["docking_score"] <= float(combined["docking_score"].quantile(0.1))).astype(int).tolist(),
        topk=min(150, adf.shape[0]),
    )
    topk_hit_nv = enrichment_metrics(
        scores=ndf["docking_score"].astype(float).tolist(),
        labels=(ndf["docking_score"] <= float(combined["docking_score"].quantile(0.1))).astype(int).tolist(),
        topk=min(150, ndf.shape[0]),
    )

    plot_paths = _build_reference_plots(
        output_dir=output_dir,
        combined=combined,
        recovery=recovery_df,
        analog_thr=float(config["analysis"].get("analog_similarity_threshold", 0.65)),
    )
    _replace_feature_importance_plot(output_dir=output_dir, feature_importance=feature_importance)

    summary = {
        "target": "MDM2",
        "reference_ids": refs,
        "shared_library_size": int(shared_df.shape[0]),
        "reference_ligands_present": all((shared_df["ligand_id"].astype(str) == r).any() for r in refs),
        "cluster_count": int(len(set(cluster_map.values()))),
        "hypercluster_count": int(len(set(hyper_map.values()))),
        "adaptive_evaluated_count": int(adf.shape[0]),
        "naive_evaluated_count": int(ndf.shape[0]),
        "target_full_budget_per_strategy": int(shared_df.shape[0]),
        "budget_reduction_applied": bool(
            int(run_cfg["adaptive_budget"]) < int(shared_df.shape[0]) or int(run_cfg["baseline_budget"]) < int(shared_df.shape[0])
        ),
        "real_rdock_only": bool((combined["backend_mode"] == "real-rdock").all() and (not combined["fallback_used"].astype(bool).any())),
        "discovery_step_adaptive": {
            r: (
                None
                if adf[adf["ligand_id"] == r].empty
                else int(adf[adf["ligand_id"] == r].sort_values("step").iloc[0]["step"])
            )
            for r in refs
        },
        "discovery_step_naive": {
            r: (
                None
                if ndf[ndf["ligand_id"] == r].empty
                else int(ndf[ndf["ligand_id"] == r].sort_values("step").iloc[0]["step"])
            )
            for r in refs
        },
        "ordering_metrics": {
            "adaptive": metrics_ad,
            "naive": metrics_nv,
        },
        "topk_hit_rate": {
            "adaptive": float(topk_hit_ad["topk_hit_rate"]),
            "naive": float(topk_hit_nv["topk_hit_rate"]),
        },
        "runtime_by_stage_seconds": {t.name: t.seconds for t in timers},
        "total_runtime_seconds": float(sum(t.seconds for t in timers)),
    }
    paths["summary"].write_text(json.dumps(summary, indent=2), encoding="utf-8")

    # reports
    report_lines = [
        "# Validation Report",
        "",
        "## 1. Target and Complexes",
        "- Target: MDM2",
        "- Complexes: 4HG7/NUT, 4J7D/I31, 4LWU/20U",
        "",
        "## 2. Shared Library Construction",
        f"- Built from public similarity retrieval and global deduplication to shared universe of `{shared_df.shape[0]}` ligands.",
        "- Includes reference ligands and close analogs/scaffold-related compounds.",
        "",
        "## 3. Reference Inclusion",
        f"- All references present: `{summary['reference_ligands_present']}`",
        f"- Reference IDs: `{', '.join(refs)}`",
        "",
        "## 4. Adaptive vs Naive Ordering",
        f"- Adaptive early mean score: `{metrics_ad.get('early_window_mean_score', np.nan):.4f}`",
        f"- Adaptive late mean score: `{metrics_ad.get('late_window_mean_score', np.nan):.4f}`",
        f"- Naive early mean score: `{metrics_nv.get('early_window_mean_score', np.nan):.4f}`",
        f"- Naive late mean score: `{metrics_nv.get('late_window_mean_score', np.nan):.4f}`",
        f"- Adaptive top10%-in-first20%: `{metrics_ad.get('top10pct_found_in_first20pct', np.nan):.4f}`",
        f"- Naive top10%-in-first20%: `{metrics_nv.get('top10pct_found_in_first20pct', np.nan):.4f}`",
        f"- Full-library target budget per strategy: `{shared_df.shape[0]}`",
        f"- Actual adaptive budget: `{adf.shape[0]}`",
        f"- Actual naive budget: `{ndf.shape[0]}`",
        f"- Budget reduction applied: `{summary['budget_reduction_applied']}`",
        "",
        "## 5. Reference and Analog Discovery",
    ]
    for r in refs:
        report_lines.append(
            f"- {r}: adaptive_step={summary['discovery_step_adaptive'][r]}, naive_step={summary['discovery_step_naive'][r]}"
        )
    report_lines.extend(
        [
            "",
            "## 6. Surrogate Impact",
            "- Model warm-up and weight progression are logged in model_weight_over_time.csv.",
            "- Adaptive ordering metrics are compared against naive baseline in summary and plots.",
            "",
            "## 7. Overfitting Signals",
            "- Train-vs-future error gap tracked via scheduler instability ratio.",
            "- Residual and uncertainty diagnostics saved for inspection.",
            "",
            "## 8. Limitations",
            "- Docking scores are not direct affinity estimates.",
            "- Analog labeling uses similarity/scaffold heuristics.",
            "",
            "## 9. Next Steps",
            "- Add static cluster-first baseline.",
            "- Run replicate random baselines for confidence intervals.",
        ]
    )
    paths["validation_report"].write_text("\n".join(report_lines), encoding="utf-8")

    paths["readme"].write_text(
        "\n".join(
            [
                "# Experimental Benchmark (Single Shared Library)",
                "",
                f"- Shared library size: `{shared_df.shape[0]}`",
                f"- Adaptive evaluated: `{adf.shape[0]}`",
                f"- Naive evaluated: `{ndf.shape[0]}`",
                f"- Real rDock only: `{summary['real_rdock_only']}`",
                "",
                "Key files:",
                "- summary.json",
                "- final_ranking_adaptive.csv",
                "- final_ranking_naive.csv",
                "- reference_recovery.csv",
                "- reference_comparison.csv",
                "- parsed_scores.csv",
                "- plots/",
            ]
        ),
        encoding="utf-8",
    )

    # self audit (write at end; function expects file present)
    (output_dir / "self_audit_report.md").write_text("placeholder", encoding="utf-8")
    self_audit_path = _self_audit(output_dir, refs=refs, target_size=int(config["benchmark_dataset"].get("shared_library_target_size", 1500)))

    return {
        "summary": summary,
        "output_dir": str(output_dir),
        "paths": {k: str(v) for k, v in paths.items()} | {
            "self_audit_report": str(self_audit_path),
            "plots": str(output_dir / "plots"),
            "rdock_commands": str(log_path),
            "raw_rdock_outputs": str(raw_root),
        },
        "plot_paths": plot_paths,
        "doctor": {
            "python_ok": doctor.python_ok,
            "imports_ok": doctor.imports_ok,
            "rdock_execs": doctor.rdock_execs,
            "gcc_available": doctor.gcc_available,
            "popt_available": doctor.popt_available,
        },
    }


def main() -> int:
    parser = argparse.ArgumentParser(description="Corrected single-library experimental benchmark")
    parser.add_argument("--config", default="configs/experimental_benchmark_single_library.yaml")
    args = parser.parse_args()

    result = run_single_library_benchmark(args.config)
    print(json.dumps(result["summary"], indent=2))
    return 0


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