libs/benchmark/redocking_validation.py

from __future__ import annotations

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

import numpy as np
import pandas as pd
from rdkit import Chem
from rdkit.Chem import AllChem, Descriptors, rdMolAlign, rdMolDescriptors
from rdkit.Chem.MolStandardize import rdMolStandardize
from scipy.optimize import linear_sum_assignment
from scipy.spatial.distance import cdist

from libs.docking.backend_rdock import RDockBackend, RDockConfig
from libs.docking.backend_smina import SminaBackend, SminaConfig, parse_smina_score
from libs.docking.base import DockingError
from libs.docking.pocket import PocketSpec, resolve_pocket_spec, write_pocket_spec
from libs.docking.prep import prepare_ligand_sdf
from libs.utils.logging_utils import get_logger
from libs.utils.subprocess_utils import run_command


LOGGER = get_logger("redocking_validation")
ROOT_DIR = Path(__file__).resolve().parents[2]


@dataclass(frozen=True)
class RedockingTarget:
    dataset: str
    target_name: str
    target_path: Path
    reference_csv: Path


@dataclass(frozen=True)
class RedockingValidationConfig:
    attempts: int = 60
    base_seed: int = 20260422
    backend: str = "rdock"
    positive_score_threshold: float = 2.0
    rmsd_fail_threshold: float = 2.0
    near_top_rank_percentile_threshold: float = 20.0


@dataclass(frozen=True)
class CrystalLigandExtraction:
    pdb_block: str
    residue_name: str
    chain: str
    resseq: str
    atom_count: int



def strict_targets_catalog() -> list[RedockingTarget]:
    return [
        RedockingTarget(
            dataset="strict_dataset_1",
            target_name="EGFR",
            target_path=ROOT_DIR / "data/targets/prelim_set_egfr_4wkq/egfr_4wkq.pdb",
            reference_csv=ROOT_DIR / "data/ligands/prelim_set_egfr_4wkq/reference_ligands.csv",
        ),
        RedockingTarget(
            dataset="strict_dataset_2",
            target_name="ABL1",
            target_path=ROOT_DIR / "data/targets/prelim_set_abl1_1iep/abl1_1iep.pdb",
            reference_csv=ROOT_DIR / "data/ligands/prelim_set_abl1_1iep/reference_ligands.csv",
        ),
        RedockingTarget(
            dataset="strict_dataset_3",
            target_name="MDM2",
            target_path=ROOT_DIR / "data/targets/prelim_set_mdm2_4hg7/mdm2_4hg7.pdb",
            reference_csv=ROOT_DIR / "data/ligands/prelim_set_mdm2_4hg7/reference_ligands.csv",
        ),
    ]


def _read_reference(reference_csv: Path) -> dict[str, str]:
    df = pd.read_csv(reference_csv)
    if df.empty:
        raise DockingError(f"Reference CSV is empty: {reference_csv}")
    row = df.iloc[0]
    return {
        "reference_id": str(row.get("reference_id", "")).strip(),
        "ligand_comp_id": str(row.get("ligand_comp_id", "")).strip(),
        "reference_smiles": str(row.get("reference_smiles", "")).strip(),
        "pdb_id": str(row.get("pdb_id", "")).strip(),
    }


def _extract_reference_ligand_block(target_path: Path, ligand_comp_id: str) -> CrystalLigandExtraction:
    lines = target_path.read_text(encoding="utf-8", errors="ignore").splitlines()
    grouped: dict[tuple[str, str, str, str], list[str]] = {}
    serials_by_group: dict[tuple[str, str, str, str], set[int]] = {}
    ligand_filter = ligand_comp_id.strip().upper()

    for ln in lines:
        if not ln.startswith("HETATM"):
            continue
        resn = ln[17:20].strip().upper()
        if not resn or resn in {"HOH", "WAT", "DOD", "SO4"}:
            continue
        if ligand_filter and resn != ligand_filter:
            continue
        chain = ln[21:22].strip()
        resseq = ln[22:26].strip()
        ins = ln[26:27].strip()
        key = (resn, chain, resseq, ins)
        grouped.setdefault(key, []).append(ln)
        try:
            serial = int(ln[6:11].strip())
        except Exception:
            continue
        serials_by_group.setdefault(key, set()).add(serial)

    if not grouped:
        raise DockingError(
            f"Cannot extract crystallographic ligand `{ligand_comp_id}` from target `{target_path}`"
        )

    selected = max(grouped.keys(), key=lambda k: len(grouped[k]))
    selected_serials = serials_by_group.get(selected, set())
    out_lines: list[str] = list(grouped[selected])

    for ln in lines:
        if not ln.startswith("CONECT"):
            continue
        cols = ln.split()
        if len(cols) < 3:
            continue
        try:
            src = int(cols[1])
            dst = [int(x) for x in cols[2:] if x.isdigit()]
        except Exception:
            continue
        if src in selected_serials and any(x in selected_serials for x in dst):
            out_lines.append(ln)

    out_lines.append("END")
    pdb_block = "\n".join(out_lines) + "\n"
    return CrystalLigandExtraction(
        pdb_block=pdb_block,
        residue_name=selected[0],
        chain=selected[1],
        resseq=selected[2],
        atom_count=len(grouped[selected]),
    )


def _safe_mol_from_pdb_block(block: str) -> Chem.Mol:
    mol = Chem.MolFromPDBBlock(block, removeHs=False, sanitize=False, proximityBonding=True)
    if mol is None:
        raise DockingError("Failed to parse crystal ligand PDB block with RDKit")
    try:
        Chem.SanitizeMol(mol)
    except Exception:
        pass
    return mol


def _assign_template_bond_orders(crystal_mol: Chem.Mol, reference_smiles: str) -> Chem.Mol:
    template = Chem.MolFromSmiles(reference_smiles)
    if template is None:
        return crystal_mol
    try:
        assigned = AllChem.AssignBondOrdersFromTemplate(Chem.RemoveHs(template), Chem.RemoveHs(crystal_mol))
        return assigned
    except Exception:
        return crystal_mol


def _convert_with_obabel(src: Path, dst: Path, extra_args: list[str] | None = None, timeout: int = 120) -> None:
    extra = extra_args or []
    cmd = ["obabel", str(src), "-O", str(dst), *extra]
    result = run_command(cmd, cwd=dst.parent, timeout=timeout)
    if result.returncode != 0 or (not dst.exists()) or dst.stat().st_size == 0:
        raise DockingError(f"obabel conversion failed: {' '.join(cmd)} | rc={result.returncode} | stderr={result.stderr.strip()}")


def _tripos_atom_types_summary(mol2_path: Path) -> dict[str, int]:
    text = mol2_path.read_text(encoding="utf-8", errors="ignore").splitlines()
    in_atoms = False
    counts: dict[str, int] = {}
    for ln in text:
        if ln.startswith("@<TRIPOS>ATOM"):
            in_atoms = True
            continue
        if ln.startswith("@<TRIPOS>") and in_atoms:
            break
        if not in_atoms:
            continue
        cols = ln.split()
        if len(cols) < 6:
            continue
        atom_type = str(cols[5]).strip()
        counts[atom_type] = counts.get(atom_type, 0) + 1
    return dict(sorted(counts.items(), key=lambda kv: kv[0]))


def _tautomer_identifier(mol: Chem.Mol) -> str:
    try:
        te = rdMolStandardize.TautomerEnumerator()
        t = te.Canonicalize(Chem.Mol(mol))
        return Chem.MolToSmiles(t, canonical=True)
    except Exception:
        return ""


def _ligand_prep_audit(mol: Chem.Mol, mol2_path: Path) -> dict[str, Any]:
    atom_count = int(mol.GetNumAtoms())
    h_count = int(sum(1 for a in mol.GetAtoms() if a.GetAtomicNum() == 1))
    aromatic_count = int(sum(1 for a in mol.GetAtoms() if a.GetIsAromatic()))
    formal_charge = int(sum(a.GetFormalCharge() for a in mol.GetAtoms()))
    rot_bonds = np.nan
    canonical = ""
    tautomer_id = ""
    try:
        no_h = Chem.RemoveHs(Chem.Mol(mol))
        rot_bonds = int(rdMolDescriptors.CalcNumRotatableBonds(no_h))
        canonical = Chem.MolToSmiles(no_h, canonical=True)
        tautomer_id = _tautomer_identifier(no_h)
    except Exception:
        pass
    protonation_id = f"q={formal_charge}|smiles={canonical}"
    return {
        "atom_count": atom_count,
        "hydrogen_count": h_count,
        "formal_charge": formal_charge,
        "aromatic_atom_count": aromatic_count,
        "rotatable_bond_count": rot_bonds,
        "tautomer_identifier": tautomer_id,
        "protonation_identifier": protonation_id,
        "tripos_atom_types": _tripos_atom_types_summary(mol2_path),
    }


def _kabsch(P: np.ndarray, Q: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
    cp = P.mean(axis=0)
    cq = Q.mean(axis=0)
    P0 = P - cp
    Q0 = Q - cq
    C = P0.T @ Q0
    V, _S, Wt = np.linalg.svd(C)
    d = np.linalg.det(V @ Wt)
    D = np.eye(3)
    D[2, 2] = np.sign(d) if d != 0 else 1.0
    R = V @ D @ Wt
    t = cq - (cp @ R)
    return R, t


def _coords_by_element(mol: Chem.Mol) -> dict[int, np.ndarray]:
    if mol.GetNumConformers() == 0:
        return {}
    conf = mol.GetConformer()
    groups: dict[int, list[list[float]]] = {}
    for i, atom in enumerate(mol.GetAtoms()):
        z = int(atom.GetAtomicNum())
        if z == 1:
            continue
        p = conf.GetAtomPosition(i)
        groups.setdefault(z, []).append([p.x, p.y, p.z])
    return {z: np.asarray(v, dtype=float) for z, v in groups.items() if v}


def _rmsd_assignment_fallback(probe: Chem.Mol, ref: Chem.Mol, max_iter: int = 8) -> float:
    p_groups = _coords_by_element(probe)
    r_groups = _coords_by_element(ref)
    if not p_groups or not r_groups:
        return float("nan")
    if set(p_groups.keys()) != set(r_groups.keys()):
        return float("nan")
    for z in p_groups:
        if p_groups[z].shape[0] != r_groups[z].shape[0]:
            return float("nan")

    z_order = sorted(p_groups.keys())
    R = np.eye(3)
    t = np.zeros(3, dtype=float)

    P_match = None
    Q_match = None
    for _ in range(max_iter):
        P_parts: list[np.ndarray] = []
        Q_parts: list[np.ndarray] = []
        for z in z_order:
            Pz = p_groups[z]
            Qz = r_groups[z]
            Pzt = (Pz @ R) + t
            D = cdist(Pzt, Qz)
            ridx, cidx = linear_sum_assignment(D)
            P_parts.append(Pz[ridx])
            Q_parts.append(Qz[cidx])
        P_match = np.vstack(P_parts)
        Q_match = np.vstack(Q_parts)
        R, t = _kabsch(P_match, Q_match)

    if P_match is None or Q_match is None:
        return float("nan")
    P_final = (P_match @ R) + t
    diff = P_final - Q_match
    return float(np.sqrt(np.mean(np.sum(diff * diff, axis=1))))


def heavy_atom_rmsd(probe: Chem.Mol, ref: Chem.Mol) -> float:
    try:
        probe_h = Chem.RemoveHs(Chem.Mol(probe))
        ref_h = Chem.RemoveHs(Chem.Mol(ref))
    except Exception:
        return float("nan")

    try:
        if probe_h.GetNumAtoms() == ref_h.GetNumAtoms() and probe_h.GetNumConformers() > 0 and ref_h.GetNumConformers() > 0:
            val = float(rdMolAlign.GetBestRMS(probe_h, ref_h))
            if np.isfinite(val):
                return val
    except Exception:
        pass

    return _rmsd_assignment_fallback(probe_h, ref_h)


def _safe_remove_hs(mol: Chem.Mol) -> Chem.Mol | None:
    try:
        return Chem.RemoveHs(Chem.Mol(mol))
    except Exception:
        return None


def _safe_smiles(mol: Chem.Mol | None) -> str:
    if mol is None:
        return ""
    try:
        return Chem.MolToSmiles(mol, canonical=True)
    except Exception:
        return ""


def _pose_entries_from_rdock_sdf(sd_path: Path) -> list[dict[str, Any]]:
    entries: list[dict[str, Any]] = []
    suppl = Chem.SDMolSupplier(str(sd_path), removeHs=False, sanitize=False)
    for idx, mol in enumerate(suppl):
        if mol is None:
            continue
        score = float("nan")
        for key in ["SCORE", "score", "SCORE.INTER"]:
            if mol.HasProp(key):
                try:
                    score = float(mol.GetProp(key))
                    break
                except Exception:
                    continue
        if not np.isfinite(score):
            continue
        entries.append({"pose_idx": idx, "score": float(score), "mol": mol})
    entries.sort(key=lambda x: x["score"])
    return entries


def _score_only_smina(
    smina_executable: str,
    receptor_pdbqt: Path,
    ligand_pdbqt: Path,
    pocket: PocketSpec,
    out_dir: Path,
    seed: int,
) -> float:
    out_dir.mkdir(parents=True, exist_ok=True)
    cmd = [
        str(smina_executable),
        "--receptor",
        str(receptor_pdbqt),
        "--ligand",
        str(ligand_pdbqt),
        "--center_x",
        f"{pocket.center[0]:.4f}",
        "--center_y",
        f"{pocket.center[1]:.4f}",
        "--center_z",
        f"{pocket.center[2]:.4f}",
        "--size_x",
        f"{pocket.box_size[0]:.4f}",
        "--size_y",
        f"{pocket.box_size[1]:.4f}",
        "--size_z",
        f"{pocket.box_size[2]:.4f}",
        "--score_only",
        "--seed",
        str(seed),
    ]
    result = run_command(cmd, cwd=out_dir, timeout=120)
    (out_dir / "score_only.stdout.log").write_text(result.stdout, encoding="utf-8")
    (out_dir / "score_only.stderr.log").write_text(result.stderr, encoding="utf-8")
    score = parse_smina_score("\n".join([result.stdout or "", result.stderr or ""]))
    if result.returncode != 0 or not np.isfinite(score):
        raise DockingError(
            f"smina --score_only failed: rc={result.returncode} score={score} stderr={result.stderr.strip()}"
        )
    return float(score)


def _format_target_report(target_row: dict[str, Any], fail_reasons: list[str]) -> str:
    verdict = "GO" if not fail_reasons else "NO-GO"
    lines = [
        f"# Redocking Validation: {target_row['dataset']} ({target_row['target_name']})",
        "",
        f"- backend: `{target_row['backend']}`",
        f"- attempts: `{target_row['attempts']}`",
        f"- reference ligand: `{target_row['reference_ligand_id']}`",
        f"- crystal ligand component: `{target_row['ligand_comp_id']}`",
        f"- top-pose heavy-atom RMSD [A]: `{target_row['top_pose_rmsd_A']:.4f}`",
        f"- best-of-run heavy-atom RMSD [A]: `{target_row['best_of_run_rmsd_A']:.4f}`",
        f"- crystallographic in-place score: `{target_row['crystal_inplace_score']:.4f}`",
        f"- in-place score source: `{target_row.get('crystal_inplace_score_source', '')}`",
        f"- best docked score: `{target_row['best_docked_score']:.4f}`",
        f"- reference rank (in-place score among attempts): `{target_row['reference_rank']}` / `{target_row['attempts'] + 1}`",
        f"- reference rank percentile: `{target_row['reference_rank_percentile']:.3f}`",
        "",
        f"## Verdict: **{verdict}**",
        "",
        "## Fail Criteria",
        "- top-pose RMSD > 2.0 A and best-of-run RMSD > 2.0 A",
        "- crystallographic pose score strongly positive",
        "- reference ligand not near top in own redocking test",
        "",
        "## Triggered Fail Reasons",
    ]
    if fail_reasons:
        lines.extend([f"- {r}" for r in fail_reasons])
    else:
        lines.append("- none")
    lines.append("")
    return "\n".join(lines)


def run_redocking_validation(
    output_dir: str | Path = "results/redocking_validation",
    *,
    config: RedockingValidationConfig | None = None,
    datasets: Iterable[RedockingTarget] | None = None,
) -> dict[str, Any]:
    cfg = config or RedockingValidationConfig()
    if int(cfg.attempts) < 50 or int(cfg.attempts) > 100:
        raise DockingError(f"Redocking attempts must be in [50,100], got {cfg.attempts}")

    out_dir = Path(output_dir)
    out_dir.mkdir(parents=True, exist_ok=True)
    target_reports_dir = out_dir / "target_reports"
    target_reports_dir.mkdir(parents=True, exist_ok=True)

    targets = list(datasets or strict_targets_catalog())
    if not targets:
        raise DockingError("No targets defined for redocking validation")

    if cfg.backend != "rdock":
        raise DockingError("Current strict redocking validation supports backend='rdock' only")

    per_attempt_rows: list[dict[str, Any]] = []
    per_target_rows: list[dict[str, Any]] = []
    prep_rows: list[dict[str, Any]] = []
    compare_rows: list[dict[str, Any]] = []

    for t in targets:
        target_root = out_dir / t.dataset
        target_root.mkdir(parents=True, exist_ok=True)

        ref = _read_reference(t.reference_csv)
        reference_id = str(ref["reference_id"])
        ligand_comp_id = str(ref["ligand_comp_id"])
        reference_smiles = str(ref["reference_smiles"])

        extraction = _extract_reference_ligand_block(t.target_path, ligand_comp_id)
        crystal_pdb = target_root / "crystal_ligand.pdb"
        crystal_pdb.write_text(extraction.pdb_block, encoding="utf-8")

        crystal_sdf = target_root / "crystal_ligand.sdf"
        crystal_mol2 = target_root / "crystal_ligand.mol2"
        crystal_pdbqt = target_root / "crystal_ligand.pdbqt"
        _convert_with_obabel(crystal_pdb, crystal_sdf)
        _convert_with_obabel(crystal_pdb, crystal_mol2)
        _convert_with_obabel(crystal_pdb, crystal_pdbqt)

        crystal_raw = Chem.SDMolSupplier(str(crystal_sdf), removeHs=False, sanitize=False)
        crystal_mol = crystal_raw[0] if crystal_raw and len(crystal_raw) > 0 else None
        if crystal_mol is None:
            crystal_mol = _safe_mol_from_pdb_block(extraction.pdb_block)
        crystal_mol = _assign_template_bond_orders(crystal_mol, reference_smiles)

        prepared_sdf = prepare_ligand_sdf(reference_id, reference_smiles, target_root / "prepared_reference.sdf")
        prepared_mol2 = target_root / "prepared_reference.mol2"
        prepared_pdbqt = target_root / "prepared_reference.pdbqt"
        _convert_with_obabel(prepared_sdf, prepared_mol2)
        _convert_with_obabel(prepared_sdf, prepared_pdbqt)

        prepared_suppl = Chem.SDMolSupplier(str(prepared_sdf), removeHs=False, sanitize=False)
        prepared_mol = prepared_suppl[0] if prepared_suppl and len(prepared_suppl) > 0 else None
        if prepared_mol is None:
            raise DockingError(f"Cannot parse prepared reference SDF for {t.dataset}")

        crystal_audit = _ligand_prep_audit(Chem.Mol(crystal_mol), crystal_mol2)
        prepared_audit = _ligand_prep_audit(Chem.Mol(prepared_mol), prepared_mol2)

        prep_rows.append(
            {
                "dataset": t.dataset,
                "target_name": t.target_name,
                "reference_ligand_id": reference_id,
                "variant": "crystal",
                **{k: (json.dumps(v) if isinstance(v, dict) else v) for k, v in crystal_audit.items()},
            }
        )
        prep_rows.append(
            {
                "dataset": t.dataset,
                "target_name": t.target_name,
                "reference_ligand_id": reference_id,
                "variant": "prepared",
                **{k: (json.dumps(v) if isinstance(v, dict) else v) for k, v in prepared_audit.items()},
            }
        )

        crystal_heavy = _safe_remove_hs(crystal_mol)
        prepared_heavy = _safe_remove_hs(prepared_mol)
        compare_rows.append(
            {
                "dataset": t.dataset,
                "target_name": t.target_name,
                "reference_ligand_id": reference_id,
                "crystal_atom_count": int(crystal_mol.GetNumAtoms()),
                "prepared_atom_count": int(prepared_mol.GetNumAtoms()),
                "crystal_heavy_atom_count": int(crystal_heavy.GetNumAtoms()) if crystal_heavy is not None else np.nan,
                "prepared_heavy_atom_count": int(prepared_heavy.GetNumAtoms()) if prepared_heavy is not None else np.nan,
                "crystal_formal_charge": int(sum(a.GetFormalCharge() for a in crystal_mol.GetAtoms())),
                "prepared_formal_charge": int(sum(a.GetFormalCharge() for a in prepared_mol.GetAtoms())),
                "crystal_canonical_smiles": _safe_smiles(crystal_heavy),
                "prepared_canonical_smiles": _safe_smiles(prepared_heavy),
                "heavy_atom_rmsd_crystal_vs_prepared_A": (
                    heavy_atom_rmsd(prepared_heavy, crystal_heavy)
                    if (prepared_heavy is not None and crystal_heavy is not None)
                    else np.nan
                ),
            }
        )

        rdock_backend = RDockBackend(
            RDockConfig(
                n_runs=1,
                command_timeout_seconds=240,
                parallel_jobs=1,
                command_log_path=str(target_root / "rdock_commands.log"),
                pocket_mode="reference_complex_pocket",
                pocket_reference_ligand_id=ligand_comp_id,
                pocket_relaxation_margin=0.0,
            )
        )
        cap = rdock_backend.check_capability()
        if not cap.available:
            raise DockingError(f"rDock not available for redocking validation: {cap.details}")

        rdock_target_ctx = rdock_backend.prepare_target(t.target_path, target_root / "rdock_target")
        rdock_ligand = rdock_backend.prepare_ligand(reference_id, reference_smiles, target_root / "rdock_ligand")

        smina_backend = SminaBackend(
            SminaConfig(
                command_timeout_seconds=120,
                exhaustiveness=8,
                num_modes=1,
                cpu=1,
                parallel_jobs=1,
                seed=cfg.base_seed,
                pocket_mode="reference_complex_pocket",
                pocket_reference_ligand_id=ligand_comp_id,
                pocket_relaxation_margin=0.0,
            )
        )
        smina_cap = smina_backend.check_capability()
        if not smina_cap.available:
            raise DockingError(
                f"smina is required for crystallographic in-place score in redocking validation: {smina_cap.details}"
            )
        smina_exe = str(smina_cap.details.get("smina", "") or "")
        if not smina_exe:
            raise DockingError("smina executable path missing in capability details")
        smina_target_ctx = smina_backend.prepare_target(t.target_path, target_root / "smina_score_only_target")
        pocket = PocketSpec.from_dict(json.loads(Path(smina_target_ctx["pocket_json"]).read_text(encoding="utf-8")))

        crystal_inplace_score = _score_only_smina(
            smina_executable=smina_exe,
            receptor_pdbqt=Path(smina_target_ctx["receptor_pdbqt"]),
            ligand_pdbqt=crystal_pdbqt,
            pocket=pocket,
            out_dir=target_root / "score_only",
            seed=cfg.base_seed,
        )

        all_pose_rmsd: list[float] = []
        all_pose_scores: list[float] = []
        top_pose_scores: list[float] = []
        top_pose_rmsd_list: list[float] = []

        for attempt_idx in range(int(cfg.attempts)):
            rdock_backend.config.n_runs = 1
            rdock_backend.config.allow_partial_failures = False
            rdock_backend.config.seed = int(cfg.base_seed + attempt_idx)

            attempt_dir = target_root / "attempts" / f"attempt_{attempt_idx:04d}"
            attempt_dir.mkdir(parents=True, exist_ok=True)
            results = rdock_backend.dock(
                target_context=rdock_target_ctx,
                ligand_files=[rdock_ligand],
                work_dir=attempt_dir,
                allow_mock=False,
                require_real_backend=True,
            )
            parsed = rdock_backend.parse_results(results)
            if not parsed:
                per_attempt_rows.append(
                    {
                        "dataset": t.dataset,
                        "target_name": t.target_name,
                        "backend": cfg.backend,
                        "attempt_idx": attempt_idx,
                        "reference_ligand_id": reference_id,
                        "success": False,
                        "best_docked_score": np.nan,
                        "top_pose_score": np.nan,
                        "top_pose_rmsd_A": np.nan,
                        "best_rmsd_in_attempt_A": np.nan,
                        "n_poses": 0,
                        "raw_output_file": "",
                    }
                )
                continue

            row = parsed[0]
            raw = Path(str(row.get("raw_output_file", "")))
            success = bool(row.get("success", False)) and raw.exists()
            top_pose_score = float(row.get("docking_score", np.nan))
            best_docked_score = float(top_pose_score)
            top_pose_rmsd = float("nan")
            best_rmsd_attempt = float("nan")
            n_poses = 0

            if success and raw.exists():
                poses = _pose_entries_from_rdock_sdf(raw)
                n_poses = int(len(poses))
                if poses:
                    top = poses[0]
                    top_pose_score = float(top["score"])
                    top_pose_rmsd = heavy_atom_rmsd(top["mol"], crystal_mol)
                    best_docked_score = float(min(float(p["score"]) for p in poses))
                    rmsd_values = [
                        heavy_atom_rmsd(p["mol"], crystal_mol)
                        for p in poses
                    ]
                    rmsd_values = [float(x) for x in rmsd_values if np.isfinite(x)]
                    if rmsd_values:
                        best_rmsd_attempt = float(np.min(np.asarray(rmsd_values, dtype=float)))
                        all_pose_rmsd.extend(rmsd_values)
                    all_pose_scores.extend([float(p["score"]) for p in poses if np.isfinite(float(p["score"]))])

            if np.isfinite(top_pose_score):
                top_pose_scores.append(float(top_pose_score))
            if np.isfinite(top_pose_rmsd):
                top_pose_rmsd_list.append(float(top_pose_rmsd))

            per_attempt_rows.append(
                {
                    "dataset": t.dataset,
                    "target_name": t.target_name,
                    "backend": cfg.backend,
                    "attempt_idx": attempt_idx,
                    "reference_ligand_id": reference_id,
                    "success": bool(success),
                    "best_docked_score": float(best_docked_score) if np.isfinite(best_docked_score) else np.nan,
                    "top_pose_score": float(top_pose_score) if np.isfinite(top_pose_score) else np.nan,
                    "top_pose_rmsd_A": float(top_pose_rmsd) if np.isfinite(top_pose_rmsd) else np.nan,
                    "best_rmsd_in_attempt_A": float(best_rmsd_attempt) if np.isfinite(best_rmsd_attempt) else np.nan,
                    "n_poses": int(n_poses),
                    "raw_output_file": str(raw),
                }
            )

        attempts_df = pd.DataFrame([r for r in per_attempt_rows if r["dataset"] == t.dataset])
        valid_attempts = attempts_df.dropna(subset=["top_pose_score"]).copy()
        if valid_attempts.empty:
            raise DockingError(f"No successful redocking attempts for {t.dataset}")

        valid_attempts = valid_attempts.sort_values("top_pose_score", ascending=True).reset_index(drop=True)
        top_pose_rmsd_global = float(valid_attempts["top_pose_rmsd_A"].iloc[0]) if not valid_attempts.empty else float("nan")
        best_of_run_rmsd = float(pd.to_numeric(valid_attempts["best_rmsd_in_attempt_A"], errors="coerce").min())
        best_docked_score = float(pd.to_numeric(valid_attempts["best_docked_score"], errors="coerce").min())

        attempt_scores = pd.to_numeric(valid_attempts["top_pose_score"], errors="coerce").dropna().to_numpy(dtype=float)
        ref_rank = int(1 + int(np.sum(attempt_scores < float(crystal_inplace_score))))
        ref_rank_pct = float(100.0 * ref_rank / max(1, attempt_scores.shape[0] + 1))

        fail_reasons: list[str] = []
        if np.isfinite(top_pose_rmsd_global) and np.isfinite(best_of_run_rmsd):
            if top_pose_rmsd_global > cfg.rmsd_fail_threshold and best_of_run_rmsd > cfg.rmsd_fail_threshold:
                fail_reasons.append(
                    f"RMSD failure: top_pose_rmsd={top_pose_rmsd_global:.3f}A and best_of_run_rmsd={best_of_run_rmsd:.3f}A exceed {cfg.rmsd_fail_threshold:.3f}A"
                )
        else:
            fail_reasons.append("RMSD failure: non-finite RMSD value")

        if not np.isfinite(crystal_inplace_score) or crystal_inplace_score > cfg.positive_score_threshold:
            fail_reasons.append(
                f"Crystallographic in-place score is strongly positive or invalid: {crystal_inplace_score}"
            )

        if (not np.isfinite(ref_rank_pct)) or ref_rank_pct > cfg.near_top_rank_percentile_threshold:
            fail_reasons.append(
                f"Reference ligand not near top: rank_percentile={ref_rank_pct:.3f} > {cfg.near_top_rank_percentile_threshold:.3f}"
            )

        target_row = {
            "dataset": t.dataset,
            "target_name": t.target_name,
            "backend": cfg.backend,
            "attempts": int(cfg.attempts),
            "reference_ligand_id": reference_id,
            "ligand_comp_id": ligand_comp_id,
            "top_pose_rmsd_A": float(top_pose_rmsd_global),
            "best_of_run_rmsd_A": float(best_of_run_rmsd),
            "crystal_inplace_score": float(crystal_inplace_score),
            "crystal_inplace_score_source": "smina_score_only",
            "best_docked_score": float(best_docked_score),
            "reference_rank": int(ref_rank),
            "reference_rank_percentile": float(ref_rank_pct),
            "success_attempt_count": int(valid_attempts.shape[0]),
            "go": bool(len(fail_reasons) == 0),
            "fail_reasons": " | ".join(fail_reasons),
        }
        per_target_rows.append(target_row)

        report_md = _format_target_report(target_row, fail_reasons)
        (target_reports_dir / f"{t.dataset}.md").write_text(report_md, encoding="utf-8")

    per_attempt_df = pd.DataFrame(per_attempt_rows)
    per_target_df = pd.DataFrame(per_target_rows)
    prep_df = pd.DataFrame(prep_rows)
    compare_df = pd.DataFrame(compare_rows)

    per_attempt_df.to_csv(out_dir / "per_attempt_poses.csv", index=False)
    per_target_df.to_csv(out_dir / "per_target_metrics.csv", index=False)
    prep_df.to_csv(out_dir / "preparation_audit.csv", index=False)
    compare_df.to_csv(out_dir / "crystal_vs_prepared_comparison.csv", index=False)

    compare_md = [
        "# Crystal vs Prepared Ligand Comparison",
        "",
        "This report captures changes introduced by conversion/preparation.",
        "",
    ]
    if compare_df.empty:
        compare_md.append("- no rows")
    else:
        for r in compare_df.itertuples(index=False):
            compare_md.extend(
                [
                    f"## {r.dataset} ({r.target_name})",
                    f"- reference_ligand_id: `{r.reference_ligand_id}`",
                    f"- crystal_atoms / prepared_atoms: `{r.crystal_atom_count}` / `{r.prepared_atom_count}`",
                    f"- crystal_heavy / prepared_heavy: `{r.crystal_heavy_atom_count}` / `{r.prepared_heavy_atom_count}`",
                    f"- crystal_charge / prepared_charge: `{r.crystal_formal_charge}` / `{r.prepared_formal_charge}`",
                    f"- heavy_atom_rmsd_crystal_vs_prepared_A: `{float(r.heavy_atom_rmsd_crystal_vs_prepared_A):.4f}`",
                    f"- crystal_canonical_smiles: `{r.crystal_canonical_smiles}`",
                    f"- prepared_canonical_smiles: `{r.prepared_canonical_smiles}`",
                    "",
                ]
            )
    (out_dir / "crystal_vs_prepared_report.md").write_text("\n".join(compare_md) + "\n", encoding="utf-8")

    all_go = bool((per_target_df["go"].astype(bool)).all()) if not per_target_df.empty else False

    summary = {
        "run_name": "redocking_validation",
        "backend": cfg.backend,
        "attempts": int(cfg.attempts),
        "datasets": per_target_df["dataset"].astype(str).tolist(),
        "all_targets_go": all_go,
        "n_targets": int(per_target_df.shape[0]),
        "outputs": {
            "per_attempt_poses_csv": str(out_dir / "per_attempt_poses.csv"),
            "per_target_metrics_csv": str(out_dir / "per_target_metrics.csv"),
            "preparation_audit_csv": str(out_dir / "preparation_audit.csv"),
            "crystal_vs_prepared_comparison_csv": str(out_dir / "crystal_vs_prepared_comparison.csv"),
            "crystal_vs_prepared_report_md": str(out_dir / "crystal_vs_prepared_report.md"),
            "target_reports_dir": str(target_reports_dir),
        },
    }
    (out_dir / "summary.json").write_text(json.dumps(summary, indent=2), encoding="utf-8")

    gate_lines = [
        "# Redocking Validation Gate",
        "",
        f"- all_targets_go: `{all_go}`",
        f"- backend: `{cfg.backend}`",
        f"- attempts: `{cfg.attempts}`",
        "",
        "## Per-target verdict",
    ]
    for r in per_target_rows:
        gate_lines.append(f"- {r['dataset']}: {'GO' if r['go'] else 'NO-GO'}")
    (out_dir / "self_audit_report.md").write_text("\n".join(gate_lines) + "\n", encoding="utf-8")

    return summary