libs/docking/backend_rdock.py

from __future__ import annotations

import json
import os
import re
import shutil
import subprocess
import threading
from concurrent.futures import ThreadPoolExecutor
from dataclasses import dataclass
from datetime import UTC, datetime
from pathlib import Path
from subprocess import TimeoutExpired
from typing import Dict, Sequence

import numpy as np

from libs.utils.logging_utils import get_logger
from libs.utils.subprocess_utils import CommandResult, run_command

from .base import BackendCapability, BackendUnavailableError, DockingBackend, DockingError, DockingResult
from .constraints import write_receptor_prm, write_receptor_prm_sphere
from .interface_features import extract_simple_interface_features
from .pocket import (
    POCKET_MODE_REFERENCE,
    POCKET_MODE_REFERENCE_RELAXED,
    POCKET_MODE_USER_FIXED,
    PocketSpec,
    centroid_from_sdf,
    is_pose_in_pocket,
    pose_distance_to_center,
    resolve_pocket_spec,
    write_pocket_spec,
)
from .pose_parsing import parse_rdock_sdf
from .prep import prepare_ligand_sdf
from .plip_interactions import analyze_pose_with_plip, plip_import_available


@dataclass
class RDockConfig:
    rbdock_bin: str = "rbdock"
    rbcavity_bin: str = "rbcavity"
    sdtether_bin: str = "sdtether"
    n_runs: int = 5
    seed: int | None = None
    protocol_prm: str | None = None
    rbt_root: str | None = None
    command_log_path: str | None = None
    mapper_radius: float = 6.0
    command_timeout_seconds: int = 180
    parallel_jobs: int = 1
    auto_batch_memory: bool = True
    memory_safety_fraction: float = 0.85
    min_memory_per_job_mb: int = 256
    memory_probe_ligands: int = 2
    enable_plip_interactions: bool = True
    plip_timeout_seconds: int = 120
    allow_partial_failures: bool = False
    pocket_mode: str = POCKET_MODE_REFERENCE
    pocket_center: tuple[float, float, float] | str | list[float] | None = None
    pocket_box_size: tuple[float, float, float] | str | list[float] | None = None
    pocket_radius: float | None = None
    pocket_reference_ligand_id: str | None = None
    pocket_relaxation_margin: float = 0.0
    allow_legacy_generated_pocket: bool = False


class RDockBackend(DockingBackend):
    """rDock adapter with strict backend validation and explicit provenance."""

    def __init__(self, config: RDockConfig | None = None) -> None:
        self.config = config or RDockConfig()
        self.logger = get_logger("rdock_backend")
        self.default_rbt_root = Path("/opt/homebrew/opt/rdock/share")
        self.command_history: list[dict[str, str | int]] = []
        self._log_lock = threading.Lock()

    def _ensure_runtime_env(self) -> None:
        if self.config.rbt_root:
            os.environ["RBT_ROOT"] = self.config.rbt_root
            return

        if "RBT_ROOT" not in os.environ and self.default_rbt_root.exists():
            os.environ["RBT_ROOT"] = str(self.default_rbt_root)

    def _resolve_protocol_prm(self) -> Path:
        if self.config.protocol_prm:
            prm = Path(self.config.protocol_prm).expanduser().resolve()
            if prm.exists():
                return prm
            raise DockingError(f"Configured protocol file does not exist: {prm}")

        rbt_root = os.environ.get("RBT_ROOT")
        if not rbt_root:
            raise DockingError("RBT_ROOT is not set and protocol_prm is not configured")

        prm = Path(rbt_root) / "data" / "scripts" / "dock.prm"
        if not prm.exists():
            raise DockingError(f"Default rDock protocol file not found: {prm}")
        return prm

    def _append_command_log(self, payload: dict[str, str | int]) -> None:
        with self._log_lock:
            self.command_history.append(payload)
            if self.config.command_log_path:
                log_path = Path(self.config.command_log_path)
                log_path.parent.mkdir(parents=True, exist_ok=True)
                line = (
                    f"[{payload['timestamp']}] stage={payload['stage']} rc={payload['returncode']} cwd={payload['cwd']}\n"
                    f"  command: {payload['command']}\n"
                    f"  stdout: {payload['stdout_log']}\n"
                    f"  stderr: {payload['stderr_log']}\n"
                )
                with log_path.open("a", encoding="utf-8") as handle:
                    handle.write(line)

    def _record_command(
        self,
        stage: str,
        result: CommandResult,
        cwd: Path,
        stdout_log: Path,
        stderr_log: Path,
    ) -> None:
        stdout_log.write_text(result.stdout, encoding="utf-8")
        stderr_log.write_text(result.stderr, encoding="utf-8")
        self._append_command_log(
            {
                "timestamp": datetime.now(UTC).isoformat(),
                "stage": stage,
                "command": " ".join(result.command),
                "cwd": str(cwd),
                "returncode": result.returncode,
                "stdout_log": str(stdout_log),
                "stderr_log": str(stderr_log),
            }
        )

    @staticmethod
    def _indicates_failure(result: CommandResult) -> bool:
        if result.returncode != 0:
            return True

        text = f"{result.stdout}\n{result.stderr}".lower()
        known_error_markers = [
            "rbt_file_read_error",
            "bad_receptor_file",
            "cavity file",
            "inappropriate molecular file type",
            "fatal",
        ]
        return any(marker in text for marker in known_error_markers)

    @staticmethod
    def _available_memory_bytes() -> int | None:
        try:
            pages = os.sysconf("SC_AVPHYS_PAGES")
            page_size = os.sysconf("SC_PAGE_SIZE")
            value = int(pages) * int(page_size)
            return value if value > 0 else None
        except Exception:
            pass
        try:
            proc = subprocess.run(["vm_stat"], check=False, capture_output=True, text=True, timeout=5)
            if proc.returncode != 0:
                return None
            page_size = 4096
            first = proc.stdout.splitlines()[0] if proc.stdout.splitlines() else ""
            match = re.search(r"page size of (\d+) bytes", first)
            if match:
                page_size = int(match.group(1))
            page_counts: dict[str, int] = {}
            for line in proc.stdout.splitlines()[1:]:
                if ":" not in line:
                    continue
                key, value = line.split(":", 1)
                text = value.strip().rstrip(".").replace(",", "")
                try:
                    page_counts[key.strip()] = int(text)
                except Exception:
                    continue
            available_pages = (
                page_counts.get("Pages free", 0)
                + page_counts.get("Pages inactive", 0)
                + page_counts.get("Pages speculative", 0)
                + page_counts.get("File-backed pages", 0)
            )
            value = int(available_pages) * int(page_size)
            return value if value > 0 else None
        except Exception:
            return None

    @staticmethod
    def _cavity_volume_from_text(text: str) -> float | None:
        for pattern in (r"total\s+volume\s*[:=]?\s*([0-9]+(?:\.[0-9]+)?)", r"volume\s*[:=]\s*([0-9]+(?:\.[0-9]+)?)"):
            match = re.search(pattern, text, flags=re.IGNORECASE)
            if match:
                try:
                    return float(match.group(1))
                except Exception:
                    return None
        return None

    def _cavity_artifact_usable(self, cavity_file: Path, log_path: Path | None = None) -> bool:
        if not cavity_file.exists() or cavity_file.stat().st_size <= 0:
            return False
        if log_path is not None and log_path.exists():
            volume = self._cavity_volume_from_text(log_path.read_text(encoding="utf-8", errors="ignore"))
            if volume is not None and volume <= 0.0:
                return False
        return True

    def _estimate_memory_bytes_per_job(self, ligand_files: Sequence[Path]) -> int:
        sample_n = max(1, int(self.config.memory_probe_ligands))
        sample = list(ligand_files[:sample_n])
        sizes = [path.stat().st_size for path in sample if path.exists()]
        avg_size = float(sum(sizes) / len(sizes)) if sizes else 0.0
        static_estimate = int(avg_size * 80.0 * max(1, int(self.config.n_runs)))
        floor_estimate = int(max(1, int(self.config.min_memory_per_job_mb)) * 1024 * 1024)
        return max(static_estimate, floor_estimate)

    def _resolve_memory_limited_jobs(self, ligand_files: Sequence[Path], work_dir: Path) -> int:
        configured_jobs = max(1, int(self.config.parallel_jobs))
        requested_jobs = min(configured_jobs, max(1, len(ligand_files)))
        available = self._available_memory_bytes()
        per_job = self._estimate_memory_bytes_per_job(ligand_files)
        memory_jobs = requested_jobs
        if self.config.auto_batch_memory and available is not None and per_job > 0:
            usable = max(1, int(float(available) * max(0.1, min(1.0, float(self.config.memory_safety_fraction)))))
            memory_jobs = max(1, usable // per_job)
        resolved = max(1, min(requested_jobs, memory_jobs))
        plan = {
            "parallel_jobs_configured": configured_jobs,
            "parallel_jobs_requested_for_batch": requested_jobs,
            "parallel_jobs_resolved": resolved,
            "ligand_count": len(ligand_files),
            "sampled_ligand_count": min(len(ligand_files), max(1, int(self.config.memory_probe_ligands))),
            "available_memory_bytes": available,
            "estimated_memory_bytes_per_job": per_job,
            "memory_safety_fraction": float(self.config.memory_safety_fraction),
            "auto_batch_memory": bool(self.config.auto_batch_memory),
            "batching_policy": "memory_limited_parallel_jobs",
        }
        (work_dir / "memory_batch_plan.json").write_text(json.dumps(plan, indent=2), encoding="utf-8")
        return resolved

    @staticmethod
    def _post_docking_confidence(extra: dict[str, object], score: float, success: bool) -> float:
        if not success or not np.isfinite(score):
            return 0.0
        native = dict(extra.get("rdock_native", {}))
        pose_count = float(native.get("n_generated_poses", extra.get("pose_count", 0)) or 0)
        std_top5 = native.get("std_top5_pose_score", np.nan)
        gap = native.get("pose_score_gap_1_2", np.nan)
        pose_inside = bool(extra.get("pose_in_fixed_pocket", False))
        pose_term = min(1.0, pose_count / 5.0)
        variance_term = 0.5
        try:
            std_value = abs(float(std_top5))
            if np.isfinite(std_value):
                variance_term = 1.0 / (1.0 + std_value)
        except Exception:
            pass
        gap_term = 0.5
        try:
            gap_value = abs(float(gap))
            if np.isfinite(gap_value):
                gap_term = min(1.0, gap_value / 2.0)
        except Exception:
            pass
        pocket_term = 1.0 if pose_inside else 0.25
        return float(max(0.0, min(1.0, 0.25 * pose_term + 0.25 * variance_term + 0.20 * gap_term + 0.30 * pocket_term)))

    @staticmethod
    def _biological_interaction_proxy(native: dict[str, object], derived: dict[str, object], pose_inside: bool) -> float:
        def _finite(value: object, default: float = 0.0) -> float:
            try:
                out = float(value)
            except Exception:
                return default
            return out if np.isfinite(out) else default

        polar = abs(_finite(native.get("rdock_polar_term"), 0.0))
        vdw = abs(_finite(native.get("rdock_vdw_term"), 0.0))
        overlap = max(0.0, min(1.0, _finite(derived.get("contact_overlap_consistency"), 0.0)))
        hotspot = max(0.0, min(1.0, _finite(derived.get("hotspot_contact_frequency"), 0.0)))
        energetic = max(0.0, min(1.0, (0.04 * polar) + (0.01 * vdw)))
        pocket_bonus = 0.15 if pose_inside else 0.0
        return float(max(0.0, min(1.0, 0.45 * energetic + 0.20 * overlap + 0.20 * hotspot + pocket_bonus)))

    def check_capability(self) -> BackendCapability:
        bins = {
            "rbdock": shutil.which(self.config.rbdock_bin),
            "rbcavity": shutil.which(self.config.rbcavity_bin),
            "sdtether": shutil.which(self.config.sdtether_bin),
            "obabel": shutil.which("obabel"),
        }
        available = bins["rbdock"] is not None and bins["rbcavity"] is not None and bins["obabel"] is not None
        return BackendCapability(backend_name="rdock", available=available, details=bins)

    def _resolve_target_pocket(self, target_path: Path, work_dir: Path) -> PocketSpec:
        spec = resolve_pocket_spec(
            target_path=target_path,
            pocket_mode=self.config.pocket_mode,
            pocket_center=self.config.pocket_center,
            pocket_box_size=self.config.pocket_box_size,
            pocket_radius=self.config.pocket_radius,
            pocket_reference_ligand_id=self.config.pocket_reference_ligand_id,
            pocket_relaxation_margin=self.config.pocket_relaxation_margin,
            fallback_radius=self.config.mapper_radius,
        )
        write_pocket_spec(work_dir / "pocket_spec.json", spec)
        return spec

    def prepare_target(self, target_path: str | Path, work_dir: str | Path) -> Dict[str, Path]:
        source = Path(target_path)
        if not source.exists():
            raise DockingError(f"Target file does not exist: {source}")

        wd = Path(work_dir)
        wd.mkdir(parents=True, exist_ok=True)

        prepared = wd / f"target_prepared{source.suffix.lower()}"
        prepared.write_bytes(source.read_bytes())

        receptor_mol2 = wd / "receptor.mol2"
        suffix = source.suffix.lower()
        if suffix == ".mol2":
            receptor_mol2.write_bytes(source.read_bytes())
        else:
            obabel = shutil.which("obabel")
            if obabel is None:
                raise DockingError("Open Babel executable `obabel` is required for receptor preparation")

            try:
                result = run_command([obabel, str(prepared), "-O", str(receptor_mol2)], cwd=wd, timeout=120)
            except TimeoutExpired as exc:
                raise DockingError(f"obabel timed out while preparing receptor: {exc}") from exc
            self._record_command(
                stage="prepare_target_obabel",
                result=result,
                cwd=wd,
                stdout_log=wd / "prepare_target_obabel.stdout.log",
                stderr_log=wd / "prepare_target_obabel.stderr.log",
            )
            if self._indicates_failure(result) or not receptor_mol2.exists() or receptor_mol2.stat().st_size == 0:
                raise DockingError(
                    "Failed to produce receptor.mol2 from target structure. "
                    f"Return code: {result.returncode}, stderr: {result.stderr.strip()}"
                )

        pocket = self._resolve_target_pocket(source, wd)
        self.logger.info(
            "Resolved pocket mode=%s source=%s center=(%.3f, %.3f, %.3f) radius=%.3f",
            pocket.mode,
            pocket.source,
            pocket.center[0],
            pocket.center[1],
            pocket.center[2],
            pocket.radius,
        )

        plip_receptor_pdb: Path | None = wd / "receptor_plip.pdb"
        if suffix == ".pdb":
            plip_receptor_pdb.write_bytes(prepared.read_bytes())
        else:
            obabel = shutil.which("obabel")
            if obabel is not None:
                try:
                    result = run_command([obabel, str(receptor_mol2), "-O", str(plip_receptor_pdb)], cwd=wd, timeout=120)
                    self._record_command(
                        stage="prepare_target_plip_pdb",
                        result=result,
                        cwd=wd,
                        stdout_log=wd / "prepare_target_plip_pdb.stdout.log",
                        stderr_log=wd / "prepare_target_plip_pdb.stderr.log",
                    )
                    if result.returncode != 0 or not plip_receptor_pdb.exists() or plip_receptor_pdb.stat().st_size == 0:
                        plip_receptor_pdb = prepared if prepared.suffix.lower() == ".pdb" else None
                except Exception:
                    plip_receptor_pdb = prepared if prepared.suffix.lower() == ".pdb" else None

        context = {
            "target_prepared": prepared,
            "receptor_mol2": receptor_mol2,
            "target_work_dir": wd,
            "pocket_spec_json": wd / "pocket_spec.json",
        }
        if plip_receptor_pdb is not None:
            context["plip_receptor_pdb"] = plip_receptor_pdb
        return context

    def prepare_ligand(self, ligand_id: str, smiles: str, work_dir: str | Path) -> Path:
        wd = Path(work_dir)
        wd.mkdir(parents=True, exist_ok=True)
        return prepare_ligand_sdf(ligand_id, smiles, wd / f"{ligand_id}.sdf")

    def build_site_or_constraints(
        self,
        target_context: Dict[str, Path],
        reference_ligand: Path,
        work_dir: str | Path,
    ) -> Path:
        receptor_mol2 = target_context.get("receptor_mol2")
        if receptor_mol2 is None or not receptor_mol2.exists():
            raise DockingError("Missing receptor_mol2 in target context")

        wd = Path(work_dir)
        wd.mkdir(parents=True, exist_ok=True)

        prm = wd / "receptor.prm"
        pocket_json = target_context.get("pocket_spec_json")
        if pocket_json and Path(pocket_json).exists():
            pocket = PocketSpec.from_dict(json.loads(Path(pocket_json).read_text(encoding="utf-8")))
            write_receptor_prm_sphere(
                receptor_mol2=receptor_mol2,
                center=pocket.center,
                radius=pocket.radius,
                out_path=prm,
            )
            return prm

        if not self.config.allow_legacy_generated_pocket:
            raise DockingError(
                "Missing pocket_spec_json while strict fixed-pocket mode is active. "
                "Provide user_fixed_pocket or reference_complex_pocket settings."
            )

        write_receptor_prm(
            receptor_mol2=receptor_mol2,
            reference_ligand_sdf=reference_ligand,
            out_path=prm,
            radius=self.config.mapper_radius,
        )
        return prm

    @staticmethod
    def _failed_real_result(ligand_id: str, message: str, command: Sequence[str] | None = None) -> DockingResult:
        return DockingResult(
            ligand_id=ligand_id,
            docking_score=float("nan"),
            pose_path=None,
            backend_name="rdock",
            backend_mode="real-rdock",
            score_source="rdock_error",
            raw_output_file="",
            parsed_from="",
            fallback_used=False,
            success=False,
            message=message,
            command=" ".join(command) if command else "",
            extra={},
        )

    def dock(
        self,
        target_context: Dict[str, Path],
        ligand_files: Sequence[Path],
        work_dir: str | Path,
        allow_mock: bool = False,
        require_real_backend: bool = False,
    ) -> list[DockingResult]:
        self._ensure_runtime_env()
        capability = self.check_capability()
        wd = Path(work_dir)
        wd.mkdir(parents=True, exist_ok=True)

        if allow_mock:
            raise DockingError(
                "Mock rDock fallback has been removed. Install/configure rDock and OpenBabel, "
                "or call with allow_mock=False to receive the actionable real-backend error."
            )

        if not capability.available:
            msg = f"rDock capability check failed: {capability.details}"
            raise BackendUnavailableError(msg)

        if not ligand_files:
            return []

        pocket_spec: PocketSpec | None = None
        pocket_json = target_context.get("pocket_spec_json")
        if pocket_json is not None and Path(pocket_json).exists():
            pocket_spec = PocketSpec.from_dict(json.loads(Path(pocket_json).read_text(encoding="utf-8")))
        else:
            target_prepared = target_context.get("target_prepared")
            if target_prepared is not None and Path(target_prepared).exists():
                resolved = self._resolve_target_pocket(Path(target_prepared), Path(target_context.get("target_work_dir", wd)))
                write_pocket_spec(Path(target_context.get("target_work_dir", wd)) / "pocket_spec.json", resolved)
                target_context["pocket_spec_json"] = Path(target_context.get("target_work_dir", wd)) / "pocket_spec.json"
                pocket_spec = resolved

        site_dir = Path(target_context.get("target_work_dir", wd))
        site_dir.mkdir(parents=True, exist_ok=True)
        cached_prm = Path(target_context["site_prm"]) if "site_prm" in target_context else None
        cached_cavity = Path(target_context["site_cavity"]) if "site_cavity" in target_context else None
        if (
            cached_prm is not None
            and cached_cavity is not None
            and cached_prm.exists()
            and cached_cavity.exists()
            and self._cavity_artifact_usable(cached_cavity, site_dir / "rbcavity.stdout.log")
        ):
            prm_file = cached_prm
            cavity_file = cached_cavity
        else:
            prm_file = self.build_site_or_constraints(target_context, ligand_files[0], site_dir)
            try:
                cavity = run_command(
                    [self.config.rbcavity_bin, "-was", "-r", str(prm_file)],
                    cwd=site_dir,
                    timeout=self.config.command_timeout_seconds,
                )
            except TimeoutExpired as exc:
                raise DockingError(f"rbcavity timed out: {exc}") from exc
            self._record_command(
                stage="rbcavity",
                result=cavity,
                cwd=site_dir,
                stdout_log=site_dir / "rbcavity.stdout.log",
                stderr_log=site_dir / "rbcavity.stderr.log",
            )

            cavity_file = site_dir / f"{prm_file.stem}.as"
            cavity_ok = self._cavity_artifact_usable(cavity_file, site_dir / "rbcavity.stdout.log")
            if self._indicates_failure(cavity) or not cavity_ok:
                msg = (
                    "rbcavity failed or did not produce cavity file. "
                    f"expected={cavity_file}, rc={cavity.returncode}, stderr={cavity.stderr.strip()}"
                )
                raise DockingError(msg)
            target_context["site_prm"] = prm_file
            target_context["site_cavity"] = cavity_file

        # Keep batch-local cavity artifact for compatibility with existing validation/tests.
        local_prm = wd / prm_file.name
        if prm_file.exists() and prm_file != local_prm and not local_prm.exists():
            shutil.copy2(prm_file, local_prm)
        local_cavity = wd / cavity_file.name
        if cavity_file.exists() and cavity_file != local_cavity and not local_cavity.exists():
            shutil.copy2(cavity_file, local_cavity)

        protocol_prm = self._resolve_protocol_prm()

        def _dock_single(ligand_file: Path) -> DockingResult:
            ligand_id = ligand_file.stem
            out_prefix = wd / f"{ligand_id}_rdock"
            cmd = [
                self.config.rbdock_bin,
                "-i",
                str(ligand_file),
                "-o",
                str(out_prefix),
                "-r",
                str(prm_file),
                "-p",
                str(protocol_prm),
                "-n",
                str(self.config.n_runs),
            ]
            if self.config.seed is not None:
                cmd.extend(["-s", str(int(self.config.seed))])
            try:
                proc = run_command(cmd, cwd=wd, timeout=self.config.command_timeout_seconds)
            except TimeoutExpired as exc:
                msg = f"rbdock timed out for {ligand_id}: {exc}"
                if self.config.allow_partial_failures:
                    return self._failed_real_result(ligand_id, msg, cmd)
                raise DockingError(msg) from exc
            self._record_command(
                stage=f"rbdock:{ligand_id}",
                result=proc,
                cwd=wd,
                stdout_log=wd / f"{ligand_id}.rbdock.stdout.log",
                stderr_log=wd / f"{ligand_id}.rbdock.stderr.log",
            )

            if self._indicates_failure(proc):
                msg = f"rbdock failed for {ligand_id}: rc={proc.returncode}, stderr={proc.stderr.strip()}"
                if self.config.allow_partial_failures:
                    return self._failed_real_result(ligand_id, msg, cmd)
                raise DockingError(msg)

            pose_candidates = sorted(wd.glob(f"{ligand_id}_rdock*.sd"))
            if not pose_candidates:
                msg = f"rbdock produced no .sd output for {ligand_id} in {wd}"
                if self.config.allow_partial_failures:
                    return self._failed_real_result(ligand_id, msg, cmd)
                raise DockingError(msg)

            pose_file = pose_candidates[0]
            try:
                parsed = parse_rdock_sdf(pose_file)
            except Exception as exc:
                msg = f"Failed parsing rDock output for {ligand_id}: {exc}"
                if self.config.allow_partial_failures:
                    return self._failed_real_result(ligand_id, msg, cmd)
                raise DockingError(msg) from exc

            pose_centroid = centroid_from_sdf(pose_file)
            pocket_distance = pose_distance_to_center(pose_centroid, pocket_spec) if pocket_spec is not None else float("nan")
            pose_inside = is_pose_in_pocket(pose_centroid, pocket_spec) if pocket_spec is not None else False
            native_features = dict(parsed.get("native_features", {}))
            derived_features = dict(parsed.get("derived_features", {}))
            fallback_interaction_proxy = self._biological_interaction_proxy(native_features, derived_features, pose_inside)
            plip_summary = None
            plip_receptor = target_context.get("plip_receptor_pdb")
            if (
                self.config.enable_plip_interactions
                and plip_receptor is not None
                and Path(plip_receptor).exists()
                and plip_import_available()
            ):
                plip_summary = analyze_pose_with_plip(
                    receptor_pdb=Path(plip_receptor),
                    pose_sdf=pose_file,
                    ligand_id=ligand_id,
                    work_dir=wd / "plip",
                    timeout_seconds=int(self.config.plip_timeout_seconds),
                )
            plip_payload = plip_summary.to_dict() if plip_summary is not None else {
                "available": plip_import_available(),
                "success": False,
                "source": "plip",
                "interaction_score": 0.0,
                "interaction_count": 0,
                "message": "PLIP disabled or receptor PDB unavailable",
            }
            interaction_score = (
                float(plip_payload.get("interaction_score", 0.0))
                if bool(plip_payload.get("success", False))
                else fallback_interaction_proxy
            )
            interaction_source = "plip" if bool(plip_payload.get("success", False)) else "rdock_energy_pose_proxy"
            extra = {
                "all_scores": parsed.get("all_scores", []),
                "pose_count": parsed.get("pose_count"),
                "rdock_native": native_features,
                "rdock_derived": derived_features,
                "rdock_feature_provenance": parsed.get("feature_provenance", []),
                "pocket_spec": pocket_spec.to_dict() if pocket_spec is not None else {},
                "pose_centroid": pose_centroid.tolist() if pose_centroid.size == 3 and np.isfinite(pose_centroid).all() else [],
                "pose_distance_to_pocket_center": pocket_distance,
                "pose_in_fixed_pocket": pose_inside,
                "plip_interactions": plip_payload,
                "biological_interaction_proxy_score": interaction_score,
                "biological_interaction_source": interaction_source,
            }
            extra["post_docking_confidence_score"] = self._post_docking_confidence(extra, float(parsed["score"]), True)

            return DockingResult(
                ligand_id=ligand_id,
                docking_score=float(parsed["score"]),
                pose_path=pose_file,
                backend_name="rdock",
                backend_mode="real-rdock",
                score_source=f"rdock_tag:{parsed['score_tag']}",
                raw_output_file=str(pose_file),
                parsed_from=f"{pose_file}::{parsed['score_tag']}",
                fallback_used=False,
                success=True,
                command=" ".join(cmd),
                extra=extra,
            )

        results: list[DockingResult] = []
        jobs = self._resolve_memory_limited_jobs(ligand_files, wd)
        if jobs <= 1 or len(ligand_files) <= 1:
            for ligand_file in ligand_files:
                results.append(_dock_single(ligand_file))
        else:
            with ThreadPoolExecutor(max_workers=min(jobs, len(ligand_files))) as ex:
                for res in ex.map(_dock_single, ligand_files):
                    results.append(res)

        return results

    def parse_results(self, results: Sequence[DockingResult]) -> list[dict[str, object]]:
        parsed: list[dict[str, object]] = []
        nan = float("nan")
        for result in results:
            native = dict((result.extra or {}).get("rdock_native", {}))
            derived = dict((result.extra or {}).get("rdock_derived", {}))
            pocket = dict((result.extra or {}).get("pocket_spec", {}))
            center = pocket.get("center", [nan, nan, nan])
            box = pocket.get("box_size", [nan, nan, nan])
            confidence = float((result.extra or {}).get("post_docking_confidence_score", 0.0))
            interaction_proxy = float((result.extra or {}).get("biological_interaction_proxy_score", 0.0))
            interaction_weighted_score = float(result.docking_score) - (0.5 * interaction_proxy) if result.success else nan
            plip_payload = dict((result.extra or {}).get("plip_interactions", {}))
            parsed.append(
                {
                    "ligand_id": result.ligand_id,
                    "docking_score": float(result.docking_score),
                    "backend_name": result.backend_name,
                    "backend_mode": result.backend_mode,
                    "score_source": result.score_source,
                    "raw_output_file": result.raw_output_file,
                    "parsed_from": result.parsed_from,
                    "fallback_used": bool(result.fallback_used),
                    "success": bool(result.success),
                    "message": result.message,
                    "pose_path": str(result.pose_path) if result.pose_path else "",
                    "command": result.command,
                    "quantity_type": "docking_score",
                    "rdock_total_score": native.get("rdock_total_score", float(result.docking_score)),
                    "rdock_pose_rank": native.get("rdock_pose_rank", 1),
                    "n_generated_poses": native.get("n_generated_poses", (result.extra or {}).get("pose_count", 1)),
                    "best_pose_score": native.get("best_pose_score", float(result.docking_score)),
                    "mean_top3_pose_score": native.get("mean_top3_pose_score", float(result.docking_score)),
                    "mean_top5_pose_score": native.get("mean_top5_pose_score", float(result.docking_score)),
                    "std_top5_pose_score": native.get("std_top5_pose_score", nan),
                    "pose_score_gap_1_2": native.get("pose_score_gap_1_2", nan),
                    "rdock_restraint_term": native.get("rdock_restraint_term", nan),
                    "rdock_internal_ligand_term": native.get("rdock_internal_ligand_term", nan),
                    "rdock_polar_term": native.get("rdock_polar_term", nan),
                    "rdock_vdw_term": native.get("rdock_vdw_term", nan),
                    "top_pose_rmsd_consistency": derived.get("top_pose_rmsd_consistency", nan),
                    "contact_overlap_consistency": derived.get("contact_overlap_consistency", nan),
                    "hotspot_contact_frequency": derived.get("hotspot_contact_frequency", nan),
                    "subpocket_match_score": derived.get("subpocket_match_score", nan),
                    "replicate_mean_score": nan,
                    "replicate_score_variance": nan,
                    "replicate_consensus_score": nan,
                    "rdock_feature_provenance": json.dumps((result.extra or {}).get("rdock_feature_provenance", [])),
                    "pocket_mode": pocket.get("mode", ""),
                    "pocket_source": pocket.get("source", ""),
                    "pocket_center_x": float(center[0]) if isinstance(center, (list, tuple)) and len(center) == 3 else nan,
                    "pocket_center_y": float(center[1]) if isinstance(center, (list, tuple)) and len(center) == 3 else nan,
                    "pocket_center_z": float(center[2]) if isinstance(center, (list, tuple)) and len(center) == 3 else nan,
                    "pocket_radius": float(pocket.get("radius", nan)),
                    "pocket_box_size_x": float(box[0]) if isinstance(box, (list, tuple)) and len(box) == 3 else nan,
                    "pocket_box_size_y": float(box[1]) if isinstance(box, (list, tuple)) and len(box) == 3 else nan,
                    "pocket_box_size_z": float(box[2]) if isinstance(box, (list, tuple)) and len(box) == 3 else nan,
                    "pose_distance_to_pocket_center": float((result.extra or {}).get("pose_distance_to_pocket_center", nan)),
                    "pose_in_fixed_pocket": bool((result.extra or {}).get("pose_in_fixed_pocket", False)),
                    "post_docking_confidence_score": confidence,
                    "biological_interaction_proxy_score": interaction_proxy,
                    "interaction_weighted_docking_score": interaction_weighted_score,
                    "interaction_filter_pass": bool(interaction_proxy > 0.0),
                    "interaction_feature_source": str((result.extra or {}).get("biological_interaction_source", "")),
                    "plip_available": bool(plip_payload.get("available", False)),
                    "plip_success": bool(plip_payload.get("success", False)),
                    "plip_interaction_count": int(plip_payload.get("interaction_count", 0) or 0),
                    "plip_hydrophobic_count": int(plip_payload.get("hydrophobic_count", 0) or 0),
                    "plip_hbond_count": int(plip_payload.get("hbond_count", 0) or 0),
                    "plip_saltbridge_count": int(plip_payload.get("saltbridge_count", 0) or 0),
                    "plip_pistacking_count": int(plip_payload.get("pistacking_count", 0) or 0),
                    "plip_pication_count": int(plip_payload.get("pication_count", 0) or 0),
                    "plip_halogen_count": int(plip_payload.get("halogen_count", 0) or 0),
                    "plip_waterbridge_count": int(plip_payload.get("waterbridge_count", 0) or 0),
                    "plip_metal_count": int(plip_payload.get("metal_count", 0) or 0),
                    "plip_message": str(plip_payload.get("message", "")),
                }
            )
        return parsed

    def extract_interface_features(self, parsed_results: Sequence[dict[str, object]]) -> list[dict[str, float]]:
        normalized = [{"docking_score": float(row.get("docking_score", 0.0))} for row in parsed_results]
        return extract_simple_interface_features(normalized)