docking_pipeline/rdock.py

from __future__ import annotations

import json
import math
import os
import shutil
from concurrent.futures import ThreadPoolExecutor, as_completed
from dataclasses import asdict, dataclass, field
from datetime import UTC, datetime
from pathlib import Path
from typing import Any

try:  # pragma: no cover
    from tqdm import tqdm
except Exception:  # pragma: no cover
    tqdm = None  # type: ignore[assignment]

from .provenance import (
    CommandRecord,
    CommandRunner,
    RDockPipelineError,
    fail_if_bad_command,
    probe_version,
    require_executable,
    require_file,
    resolve_dock_prm_path,
    resolve_rbt_root,
    sha256_file,
)
from .sdf import best_per_ligand, ligand_id_from_block, parse_rdock_sdf_records, parse_tags, records_to_rows, split_sdf_file, write_rows_csv, write_sdf_blocks, write_sdf_records


@dataclass
class TargetConfig:
    receptor: str
    reference_ligand: str
    target_dir: str
    receptor_mol2: str
    receptor_prm: str
    cavity_as: str
    pocket_center: list[float]
    pocket_radius: float
    diagnostics: dict[str, Any]


@dataclass
class RDockRunConfig:
    n_runs: int = 50
    jobs: int | str = "auto"
    cpu_fraction: float = 0.85
    timeout_seconds: int = 3600
    chunk_size: int | None = None
    rbdock_bin: str = "rbdock"
    rbcavity_bin: str = "rbcavity"
    obabel_bin: str = "obabel"
    sdsort_bin: str = "sdsort"
    sdfilter_bin: str = "sdfilter"
    sdreport_bin: str = "sdreport"
    sdrmsd_bin: str = "sdrmsd"
    sdsplit_bin: str = "sdsplit"
    dock_prm: str | None = None
    rbt_root: str | None = None
    require_reporting_tools: bool = False


@dataclass
class RunArtifacts:
    run_dir: str
    manifest: str
    config_yaml: str
    commands_log: str
    all_poses_sdf: str
    best_per_ligand_sdf: str
    scores_long_csv: str
    best_per_ligand_csv: str
    report_md: str
    command_records: list[dict[str, Any]] = field(default_factory=list)
    best_ligand_poses_sdf: str | None = None


def _tail_text(path: Path, limit: int = 2000) -> str:
    if not path.exists():
        return ""
    try:
        text = path.read_text(encoding="utf-8", errors="ignore")
    except Exception:
        return ""
    return text[-limit:]


def _classify_chunk_failure(
    rec: CommandRecord | None,
    out_sd: Path,
    stdout_log: Path,
    stderr_log: Path,
) -> str:
    combined = f"{_tail_text(stdout_log, 4000)}\n{_tail_text(stderr_log, 4000)}".lower()
    exit_code = int(rec.exit_code) if rec is not None else None
    if exit_code == 124 or "timeout after" in combined:
        return "rdock_timeout"
    if exit_code == -15 or "sigterm" in combined or "terminated" in combined:
        return "rdock_sigterm"
    if exit_code == -9 or "sigkill" in combined or "killed" in combined:
        return "rdock_sigkill"
    if not out_sd.exists():
        if exit_code not in (None, 0):
            return f"rdock_nonzero_exit_{exit_code}"
        return "missing_rdock_output_sdf"
    if "not enough diversity" in combined or "population failure" in combined:
        return "rdock_population_not_enough_diversity"
    if "explicit valence" in combined:
        return "rdkit_or_obabel_explicit_valence"
    if "2d" in combined and "record" in combined:
        return "rdock_2d_record"
    try:
        records = parse_rdock_sdf_records(out_sd, require_score=False)
    except Exception:
        return "rdock_unknown_failure"
    if not records:
        return "rdock_no_valid_scored_poses"
    valid_records = [record for record in records if record.score is not None]
    if not valid_records:
        return "rdock_missing_score"
    return "rdock_unknown_failure"


def _write_yaml_like(path: Path, payload: dict[str, Any]) -> None:
    try:
        import yaml

        text = yaml.safe_dump(payload, sort_keys=False)
    except Exception:
        text = json.dumps(payload, indent=2)
    path.write_text(text, encoding="utf-8")


def _sanitize_chunk_output_scores(path: Path) -> tuple[list[Any], int]:
    records = parse_rdock_sdf_records(path, require_score=False)
    valid_records = [record for record in records if record.score is not None]
    dropped = len(records) - len(valid_records)
    if dropped > 0:
        write_sdf_records(valid_records, path)
    return valid_records, dropped


def _normalize_receptor_prm_paths(prm_path: Path, config_dir: Path, dataset_target_dir: Path) -> bool:
    if not prm_path.exists():
        return False
    text = prm_path.read_text(encoding="utf-8", errors="ignore")
    updated_lines: list[str] = []
    changed = False
    receptor_candidate = config_dir / "receptor.mol2"
    reference_candidates = [
        config_dir / "reference_ligand.sdf",
        dataset_target_dir / "reference_ligand.sdf",
    ]
    for line in text.splitlines():
        stripped = line.strip()
        if stripped.startswith("RECEPTOR_FILE ") and receptor_candidate.exists():
            new_line = f"RECEPTOR_FILE {receptor_candidate.name}"
            if line != new_line:
                line = new_line
                changed = True
        elif stripped.startswith("REF_MOL "):
            for candidate in reference_candidates:
                if candidate.exists():
                    new_line = f"    REF_MOL {candidate.name}"
                    if line != new_line:
                        line = new_line
                        changed = True
                    break
        updated_lines.append(line)
    if changed:
        prm_path.write_text("\n".join(updated_lines) + "\n", encoding="utf-8")
    return changed


def _coords_from_pdb(path: Path, include_hetatm: bool) -> np.ndarray:
    coords: list[list[float]] = []
    for line in path.read_text(encoding="utf-8", errors="ignore").splitlines():
        if not line.startswith(("ATOM", "HETATM")):
            continue
        if line.startswith("HETATM") and not include_hetatm:
            continue
        try:
            coords.append([float(line[30:38]), float(line[38:46]), float(line[46:54])])
        except Exception:
            continue
    return coords  # type: ignore[return-value]


def _coords_from_mol2(path: Path) -> np.ndarray:
    coords: list[list[float]] = []
    in_atoms = False
    for line in path.read_text(encoding="utf-8", errors="ignore").splitlines():
        if line.startswith("@<TRIPOS>ATOM"):
            in_atoms = True
            continue
        if line.startswith("@<TRIPOS>") and in_atoms:
            break
        if not in_atoms:
            continue
        parts = line.split()
        if len(parts) >= 5:
            try:
                coords.append([float(parts[2]), float(parts[3]), float(parts[4])])
            except Exception:
                continue
    return coords  # type: ignore[return-value]


def _coords_from_sdf(path: Path) -> np.ndarray:
    first = path.read_text(encoding="utf-8", errors="ignore").split("$$$$", 1)[0]
    lines = first.splitlines()
    if len(lines) < 4:
        return []  # type: ignore[return-value]
    try:
        atom_count = int(lines[3][0:3])
    except Exception:
        atom_count = 0
    coords = []
    for line in lines[4 : 4 + atom_count]:
        try:
            coords.append([float(line[0:10]), float(line[10:20]), float(line[20:30])])
        except Exception:
            parts = line.split()
            if len(parts) >= 3:
                try:
                    coords.append([float(parts[0]), float(parts[1]), float(parts[2])])
                except Exception:
                    continue
    return coords  # type: ignore[return-value]


def _coords_for_structure(path: Path, receptor: bool) -> np.ndarray:
    suffix = path.suffix.lower()
    if suffix == ".mol2":
        return _coords_from_mol2(path)
    if suffix in {".sdf", ".sd"}:
        return _coords_from_sdf(path)
    if suffix in {".pdb", ".ent", ".cif", ".mmcif"}:
        return _coords_from_pdb(path, include_hetatm=not receptor)
    raise RDockPipelineError(f"Unsupported structure format for coordinate validation: {path}")


def _validate_receptor_ligand_geometry(receptor: Path, ligand: Path) -> tuple[list[float], dict[str, Any]]:
    receptor_coords = _coords_for_structure(receptor, receptor=True)
    ligand_coords = _coords_for_structure(ligand, receptor=False)
    if not receptor_coords:
        raise RDockPipelineError(f"Missing receptor atoms or coordinates in {receptor}")
    if not ligand_coords:
        raise RDockPipelineError(f"Missing ligand coordinates in reference ligand {ligand}")
    n_lig = len(ligand_coords)
    center = [sum(coord[i] for coord in ligand_coords) / n_lig for i in range(3)]

    def dist(a: list[float], b: list[float]) -> float:
        return ((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2 + (a[2] - b[2]) ** 2) ** 0.5

    all_dists = [dist(r, l) for r in receptor_coords for l in ligand_coords]
    min_receptor_ligand_dist = min(all_dists)
    centroid_to_receptor = min(dist(r, center) for r in receptor_coords)
    severe_clashes = sum(1 for d in all_dists if d < 1.0)
    clash_fraction = severe_clashes / float(max(1, len(ligand_coords)))
    if centroid_to_receptor > 20.0:
        raise RDockPipelineError(
            f"Reference ligand centroid is {centroid_to_receptor:.2f} A from the nearest receptor atom; "
            "check receptor/reference ligand pairing and coordinate frames."
        )
    if clash_fraction > 1.0:
        raise RDockPipelineError(
            f"Severe receptor-ligand clashes before docking ({severe_clashes} atom pairs < 1.0 A). "
            "Check protonation, alternate locations, and coordinate consistency."
        )
    spread = max(dist(l, center) for l in ligand_coords)
    return [float(center[0]), float(center[1]), float(center[2])], {
        "receptor_atom_count": int(len(receptor_coords)),
        "reference_ligand_atom_count": int(len(ligand_coords)),
        "reference_ligand_centroid": [float(x) for x in center],
        "reference_ligand_radius": spread,
        "min_receptor_ligand_distance": min_receptor_ligand_dist,
        "reference_centroid_to_nearest_receptor_atom": centroid_to_receptor,
        "severe_clash_pairs_lt_1A": severe_clashes,
    }


class RDockEngine:
    def __init__(self, config: RDockRunConfig | None = None) -> None:
        self.config = config or RDockRunConfig()

    def _env(self) -> dict[str, str]:
        env: dict[str, str] = {}
        resolved = resolve_rbt_root(preferred=self.config.rbt_root, executable=self.config.rbdock_bin)
        if resolved:
            env["RBT_ROOT"] = resolved
            env["RBT_HOME"] = resolved
        return env

    def _dock_prm(self) -> Path:
        if self.config.dock_prm:
            return require_file(self.config.dock_prm, "rDock protocol dock.prm")
        candidate = resolve_dock_prm_path(preferred_rbt_root=self.config.rbt_root, executable=self.config.rbdock_bin)
        if candidate is not None:
            return candidate
        raise RDockPipelineError(
            "Could not locate rDock dock.prm. Pass --dock-prm or set RBT_ROOT so "
            "$RBT_ROOT/data/scripts/dock.prm exists."
        )

    def check_required_tools(self, validation: bool = False) -> dict[str, str]:
        needed = {
            "rbdock": self.config.rbdock_bin,
            "rbcavity": self.config.rbcavity_bin,
            "obabel": self.config.obabel_bin,
        }
        if validation or self.config.require_reporting_tools:
            needed.update(
                {
                    "sdsort": self.config.sdsort_bin,
                    "sdfilter": self.config.sdfilter_bin,
                    "sdreport": self.config.sdreport_bin,
                    "sdrmsd": self.config.sdrmsd_bin,
                }
            )
        return {key: require_executable(bin_name) for key, bin_name in needed.items()}

    def prepare_target(self, receptor: str | Path, reference_ligand: str | Path, out_dir: str | Path) -> TargetConfig:
        tools = self.check_required_tools(validation=False)
        receptor_path = require_file(receptor, "receptor structure")
        ref_path = require_file(reference_ligand, "reference ligand")
        out = Path(out_dir)
        out.mkdir(parents=True, exist_ok=True)
        command_log = out / "commands.log"
        runner = CommandRunner(command_log)

        receptor_copy = out / receptor_path.name
        reference_copy = out / ref_path.name
        if receptor_path.resolve() != receptor_copy.resolve():
            shutil.copy2(receptor_path, receptor_copy)
        if ref_path.resolve() != reference_copy.resolve():
            shutil.copy2(ref_path, reference_copy)

        center, diagnostics = _validate_receptor_ligand_geometry(receptor_copy, reference_copy)
        receptor_mol2 = out / "receptor.mol2"
        if receptor_copy.suffix.lower() == ".mol2":
            shutil.copy2(receptor_copy, receptor_mol2)
        else:
            rec = runner.run(
                "prepare_receptor_obabel",
                [tools["obabel"], str(receptor_copy.resolve()), "-O", str(receptor_mol2.resolve())],
                cwd=out,
                stdout_log=out / "prepare_receptor_obabel.stdout.log",
                stderr_log=out / "prepare_receptor_obabel.stderr.log",
                timeout=300,
                env=self._env(),
            )
            fail_if_bad_command(rec, "OpenBabel receptor conversion")
        require_file(receptor_mol2, "prepared receptor MOL2")

        prm = out / "receptor.prm"
        prm.write_text(
            "\n".join(
                [
                    "RBT_PARAMETER_FILE_V1.00",
                    "TITLE rdock_receptor_reference_ligand",
                    f"RECEPTOR_FILE {receptor_mol2.name}",
                    "",
                    "SECTION MAPPER",
                    "    SITE_MAPPER RbtLigandSiteMapper",
                    f"    REF_MOL {reference_copy.name}",
                    "    RADIUS 6.0",
                    "    SMALL_SPHERE 1.5",
                    "END_SECTION",
                    "",
                    "SECTION CAVITY",
                    "    SCORING_FUNCTION RbtCavityGridSF",
                    "END_SECTION",
                    "",
                ]
            ),
            encoding="utf-8",
        )
        _normalize_receptor_prm_paths(prm, out, out)

        rec = runner.run(
            "rbcavity",
            [tools["rbcavity"], "-r", prm.name, "-was"],
            cwd=out,
            stdout_log=out / "rbcavity.stdout.log",
            stderr_log=out / "rbcavity.stderr.log",
            timeout=self.config.timeout_seconds,
            env=self._env(),
        )
        fail_if_bad_command(rec, "rbcavity cavity generation")
        cavity = out / f"{prm.stem}.as"
        require_file(cavity, "rDock cavity .as file")
        if cavity.stat().st_size < 16:
            raise RDockPipelineError(f"rbcavity produced an invalid tiny cavity file: {cavity}")

        target_config = TargetConfig(
            receptor=str(receptor_copy),
            reference_ligand=str(reference_copy),
            target_dir=str(out),
            receptor_mol2=str(receptor_mol2),
            receptor_prm=str(prm),
            cavity_as=str(cavity),
            pocket_center=center,
            pocket_radius=float(max(6.0, diagnostics["reference_ligand_radius"] + 2.0)),
            diagnostics=diagnostics,
        )
        _write_yaml_like(out / "target_config.yaml", asdict(target_config))
        return target_config

    def _resolve_jobs(self, requested: int | str | None = None) -> int:
        value = self.config.jobs if requested is None else requested
        if isinstance(value, str) and value.lower() == "auto":
            cpus = os.cpu_count() or 1
            reserve = 1 if cpus <= 4 else 2
            return max(1, min(cpus - reserve, int(math.floor(cpus * self.config.cpu_fraction))))
        return max(1, int(value))

    def _split_input_sdf(self, ligands_sdf: Path, split_dir: Path, jobs: int, chunk_size: int | None = None) -> list[Path]:
        blocks = split_sdf_file(ligands_sdf)
        if jobs <= 1 or len(blocks) <= 1:
            target = split_dir / "chunk_000.sdf"
            write_sdf_blocks(blocks, target)
            return [target]
        max_chunk_records = int(chunk_size or 0)
        if max_chunk_records > 0:
            chunks = [blocks[idx : idx + max_chunk_records] for idx in range(0, len(blocks), max_chunk_records)]
        else:
            chunks = [[] for _ in range(min(jobs, len(blocks)))]
            for idx, block in enumerate(blocks):
                chunks[idx % len(chunks)].append(block)
        paths = []
        for idx, chunk in enumerate(chunks):
            path = split_dir / f"chunk_{idx:03d}.sdf"
            write_sdf_blocks(chunk, path)
            paths.append(path)
        return paths

    def dock_sdf(
        self,
        target_config: TargetConfig,
        ligands_sdf: str | Path,
        run_dir: str | Path,
        n_runs: int | None = None,
        jobs: int | str | None = None,
        run_id: str | None = None,
        validation_labels_csv: str | Path | None = None,
        resume: bool = False,
    ) -> RunArtifacts:
        self.check_required_tools(validation=False)
        ligands = require_file(ligands_sdf, "ligand SDF")
        dock_prm = self._dock_prm()
        run_root = Path(run_dir)
        run_root.mkdir(parents=True, exist_ok=True)
        for name in ("target", "ligands", "rdock", "poses", "tables", "metrics"):
            (run_root / name).mkdir(parents=True, exist_ok=True)
        commands_log = run_root / "commands.log"
        runner = CommandRunner(commands_log)
        progress_log = run_root / "rdock" / "progress.log"

        def _emit_progress(message: str, payload: dict[str, Any] | None = None) -> None:
            line = f"[rdock] {message}"
            print(line, flush=True)
            progress_log.parent.mkdir(parents=True, exist_ok=True)
            with progress_log.open("a", encoding="utf-8") as handle:
                handle.write(line + "\n")
            if payload is not None:
                (run_root / "rdock" / "progress.json").write_text(json.dumps(payload, indent=2), encoding="utf-8")

        target_dir = run_root / "target"
        for src in (target_config.receptor, target_config.reference_ligand, target_config.receptor_mol2, target_config.receptor_prm, target_config.cavity_as):
            p = Path(src)
            if p.exists():
                shutil.copy2(p, target_dir / p.name)
        lig_copy = run_root / "ligands" / ligands.name
        if ligands.resolve() != lig_copy.resolve():
            shutil.copy2(ligands, lig_copy)
        shutil.copy2(dock_prm, run_root / "rdock" / "dock.prm")

        resolved_jobs = self._resolve_jobs(jobs)
        actual_n_runs = int(n_runs if n_runs is not None else self.config.n_runs)
        chunks = self._split_input_sdf(lig_copy, run_root / "rdock" / "chunks", resolved_jobs, self.config.chunk_size)
        rbdock = require_executable(self.config.rbdock_bin)
        failure_policy = os.environ.get("RDOCK_CHUNK_FAILURE_POLICY", "mark_failed").strip().lower() or "mark_failed"
        if failure_policy not in {"mark_failed", "fail"}:
            raise RDockPipelineError(f"Unsupported RDOCK_CHUNK_FAILURE_POLICY={failure_policy!r}")
        local_prm = require_file(target_dir / Path(target_config.receptor_prm).name, "copied receptor.prm for run")
        _normalize_receptor_prm_paths(local_prm, target_dir, target_dir)
        out_files: dict[int, Path] = {}
        failed_chunk_rows: list[dict[str, Any]] = []
        failed_ligand_rows: list[dict[str, Any]] = []
        records_without_score_dropped_total = 0
        _emit_progress(
            "dock:start",
            {
                "run_dir": str(run_root),
                "jobs": resolved_jobs,
                "n_runs": actual_n_runs,
                "chunk_count": len(chunks),
                "ligands_sdf": str(lig_copy),
                "failure_policy": failure_policy,
            },
        )

        def _run_chunk(idx: int, chunk: Path) -> tuple[int, CommandRecord, Path]:
            out_prefix = run_root / "rdock" / f"chunk_{idx:03d}_out"
            out_sd = out_prefix.with_suffix(".sd")
            if resume and out_sd.exists() and out_sd.stat().st_size > 0:
                try:
                    expected_ligand_ids = {
                        ligand_id_from_block(block, parse_tags(block), block_idx)
                        for block_idx, block in enumerate(split_sdf_file(chunk))
                    }
                    valid_records, _ = _sanitize_chunk_output_scores(out_sd)
                    if not valid_records:
                        raise RDockPipelineError(f"Resume chunk {idx} has no valid scored poses after sanitization")
                    observed_ligand_ids = {record.ligand_id for record in valid_records}
                    if not expected_ligand_ids.issubset(observed_ligand_ids):
                        missing = len(expected_ligand_ids - observed_ligand_ids)
                        raise RDockPipelineError(f"Resume chunk {idx} is incomplete; missing scored poses for {missing} input ligands")
                    stdout_log = run_root / "rdock" / f"chunk_{idx:03d}.stdout.log"
                    stderr_log = run_root / "rdock" / f"chunk_{idx:03d}.stderr.log"
                    stdout_log.touch(exist_ok=True)
                    stderr_log.touch(exist_ok=True)
                    rec = CommandRecord(
                        stage=f"rbdock_chunk_{idx:03d}_resume",
                        command=[rbdock, "-r", local_prm.name, "-p", str(dock_prm.resolve()), "-n", str(actual_n_runs), "-i", str(chunk.resolve()), "-o", str(out_prefix.resolve())],
                        cwd=str(target_dir),
                        start_time=datetime.now(UTC).isoformat(),
                        end_time=datetime.now(UTC).isoformat(),
                        exit_code=0,
                        stdout_log=str(stdout_log),
                        stderr_log=str(stderr_log),
                    )
                    return idx, rec, out_sd
                except RDockPipelineError:
                    try:
                        out_sd.unlink(missing_ok=True)
                    except Exception:
                        pass
            rec = runner.run(
                f"rbdock_chunk_{idx:03d}",
                [
                    rbdock,
                    "-r",
                    local_prm.name,
                    "-p",
                    str(dock_prm.resolve()),
                    "-n",
                    str(actual_n_runs),
                    "-i",
                    str(chunk.resolve()),
                    "-o",
                    str(out_prefix.resolve()),
                ],
                cwd=target_dir,
                stdout_log=run_root / "rdock" / f"chunk_{idx:03d}.stdout.log",
                stderr_log=run_root / "rdock" / f"chunk_{idx:03d}.stderr.log",
                timeout=self.config.timeout_seconds,
                env=self._env(),
            )
            return idx, rec, out_sd

        progress = tqdm(total=len(chunks), desc=f"rDock chunks ({actual_n_runs} runs)", unit="chunk") if tqdm is not None else None
        with ThreadPoolExecutor(max_workers=min(resolved_jobs, len(chunks))) as pool:
            futures = [pool.submit(_run_chunk, idx, chunk) for idx, chunk in enumerate(chunks)]
            completed = 0
            for fut in as_completed(futures):
                idx, rec, out_sd = fut.result()
                stdout_log = run_root / "rdock" / f"chunk_{idx:03d}.stdout.log"
                stderr_log = run_root / "rdock" / f"chunk_{idx:03d}.stderr.log"
                chunk_blocks = split_sdf_file(chunks[idx])
                failure_reason = ""
                dropped_records = 0
                try:
                    fail_if_bad_command(rec, f"rbdock chunk {idx}")
                    require_file(out_sd, f"rDock output SDF for chunk {idx}")
                    valid_records, dropped_records = _sanitize_chunk_output_scores(out_sd)
                    if not valid_records:
                        raise RDockPipelineError("rDock output had no valid scored poses")
                    out_files[idx] = out_sd
                    records_without_score_dropped_total += dropped_records
                except Exception as exc:
                    failure_reason = _classify_chunk_failure(rec, out_sd, stdout_log, stderr_log)
                    failed_chunk_rows.append(
                        {
                            "chunk_id": idx,
                            "input_sdf": str(chunks[idx]),
                            "expected_output_sdf": str(out_sd),
                            "stdout_log": str(stdout_log),
                            "stderr_log": str(stderr_log),
                            "n_input_ligands": len(chunk_blocks),
                            "failure_reason": failure_reason,
                            "exit_code": rec.exit_code,
                            "stdout_tail": _tail_text(stdout_log),
                            "stderr_tail": _tail_text(stderr_log),
                        }
                    )
                    for block_index, block in enumerate(chunk_blocks):
                        try:
                            tags = parse_tags(block)
                            ligand_id = ligand_id_from_block(block, tags, block_index)
                        except Exception:
                            ligand_id = f"ligand_{block_index:06d}"
                        failed_ligand_rows.append(
                            {
                                "ligand_id": ligand_id,
                                "chunk_id": idx,
                                "failure_reason": failure_reason,
                                "source_input_sdf": str(chunks[idx]),
                            }
                        )
                    if failure_policy == "fail":
                        raise RDockPipelineError(
                            f"rDock chunk {idx} failed with policy=fail: {failure_reason} ({exc})"
                        ) from exc
                completed += 1
                if progress is not None:
                    progress.update(1)
                    progress.set_postfix(last_chunk=idx, completed=f"{completed}/{len(chunks)}")
                _emit_progress(
                    "dock:chunk_complete",
                    {
                        "completed_chunks": completed,
                        "total_chunks": len(chunks),
                        "last_chunk": idx,
                        "output": str(out_sd),
                        "records_without_score_dropped": dropped_records,
                        "failure_reason": failure_reason,
                    },
                )
        if progress is not None:
            progress.close()

        all_blocks: list[str] = []
        for idx in sorted(out_files):
            all_blocks.extend(split_sdf_file(out_files[idx]))
        all_poses = run_root / "poses" / "all_poses.sdf"
        if all_blocks:
            write_sdf_blocks(all_blocks, all_poses)
            records = parse_rdock_sdf_records(all_poses, require_score=True)
            best = best_per_ligand(records)
        else:
            all_poses.write_text("", encoding="utf-8")
            records = []
            best = []
        best_sdf = write_sdf_records(best, run_root / "poses" / "best_per_ligand.sdf")
        best_ligand_poses_sdf: str | None = None
        if best:
            top_ligand_id = best[0].ligand_id
            best_ligand_records = [rec for rec in records if rec.ligand_id == top_ligand_id]
            best_ligand_path = run_root / "poses" / f"best_ligand_{actual_n_runs}.sdf"
            write_sdf_records(best_ligand_records, best_ligand_path)
            best_ligand_poses_sdf = str(best_ligand_path)
        scores_long = write_rows_csv(records_to_rows(records), run_root / "tables" / "scores_long.csv")
        best_csv = write_rows_csv(records_to_rows(best), run_root / "tables" / "best_per_ligand.csv")
        failed_chunks_csv = write_rows_csv(failed_chunk_rows, run_root / "tables" / "failed_chunks.csv")
        failed_ligands_csv = write_rows_csv(failed_ligand_rows, run_root / "tables" / "failed_ligands.csv")
        failure_summary = {
            "failure_policy": failure_policy,
            "total_chunks": len(chunks),
            "successful_chunks": len(out_files),
            "failed_chunks": len(failed_chunk_rows),
            "failed_ligands": len(failed_ligand_rows),
            "records_without_score_dropped": records_without_score_dropped_total,
        }
        (run_root / "metrics" / "rdock_failure_summary.json").write_text(json.dumps(failure_summary, indent=2), encoding="utf-8")

        labels_map: dict[str, int] = {}
        if validation_labels_csv:
            import pandas as pd

            label_df = pd.read_csv(validation_labels_csv)
            labels_map = dict(zip(label_df["ligand_id"].astype(str), label_df["label"].astype(int)))
            best_rows = records_to_rows(best)
            for row in best_rows:
                row["label"] = labels_map.get(str(row["ligand_id"]), 0)
            best_csv = write_rows_csv(best_rows, best_csv)

        manifest_path = run_root / "manifest.json"
        config_yaml = run_root / "config.yaml"
        report_md = run_root / "report.md"
        now = datetime.now(UTC).isoformat()
        file_inputs = {
            "ligands_sdf": str(lig_copy),
            "dock_prm": str(run_root / "rdock" / "dock.prm"),
            "receptor_prm": str(local_prm),
            "cavity_as": str(target_dir / Path(target_config.cavity_as).name),
        }
        manifest = {
            "run_id": run_id or run_root.name,
            "created_at": now,
            "engine": "real-rdock",
            "n_runs": actual_n_runs,
            "jobs": resolved_jobs,
            "input_hashes": {k: sha256_file(v) for k, v in file_inputs.items() if Path(v).exists()},
            "rdock_versions": {
                "rbdock": probe_version(rbdock),
                "rbcavity": probe_version(require_executable(self.config.rbcavity_bin)),
            },
            "target_config": asdict(target_config),
            "commands": [r.to_dict() for r in runner.records],
            "artifacts": {
                "all_poses_sdf": str(all_poses),
                "best_per_ligand_sdf": str(best_sdf),
                "best_ligand_poses_sdf": best_ligand_poses_sdf,
                "scores_long_csv": str(scores_long),
                "best_per_ligand_csv": str(best_csv),
                "failed_chunks_csv": str(failed_chunks_csv),
                "failed_ligands_csv": str(failed_ligands_csv),
                "rdock_failure_summary_json": str(run_root / "metrics" / "rdock_failure_summary.json"),
                "commands_log": str(commands_log),
            },
            "pose_count": len(records),
            "docked_ligand_count": len(best),
            "rdock_failure_summary": failure_summary,
        }
        manifest_path.write_text(json.dumps(manifest, indent=2), encoding="utf-8")
        _write_yaml_like(config_yaml, {"rdock": asdict(self.config), "run": {"n_runs": actual_n_runs, "jobs": resolved_jobs}})
        report_md.write_text(
            "\n".join(
                [
                    "# rDock Run Report",
                    "",
                    f"- Engine: `real-rdock`",
                    f"- Run ID: `{manifest['run_id']}`",
                    f"- n_runs per ligand: `{actual_n_runs}`",
                    f"- local jobs: `{resolved_jobs}`",
                    f"- poses parsed: `{len(records)}`",
                    f"- docked ligands: `{len(best)}`",
                    f"- failed chunks: `{failure_summary['failed_chunks']}`",
                    f"- failed ligands: `{failure_summary['failed_ligands']}`",
                    f"- all poses: `{all_poses}`",
                    f"- best per ligand: `{best_sdf}`",
                    f"- best ligand all poses: `{best_ligand_poses_sdf or ''}`",
                    f"- command log: `{commands_log}`",
                    "",
                    "No surrogate or undocked ligand is reported as a real rDock hit; hit tables are generated only from parsed rDock SDF records with native SCORE fields.",
                ]
            ),
            encoding="utf-8",
        )
        _emit_progress(
            "dock:done",
            {
                "run_dir": str(run_root),
                "pose_count": len(records),
                "docked_ligands": len(best),
                "all_poses_sdf": str(all_poses),
                "best_per_ligand_csv": str(best_csv),
                "failed_chunks": failure_summary["failed_chunks"],
                "failed_ligands": failure_summary["failed_ligands"],
            },
        )
        return RunArtifacts(
            run_dir=str(run_root),
            manifest=str(manifest_path),
            config_yaml=str(config_yaml),
            commands_log=str(commands_log),
            all_poses_sdf=str(all_poses),
            best_per_ligand_sdf=str(best_sdf),
            scores_long_csv=str(scores_long),
            best_per_ligand_csv=str(best_csv),
            report_md=str(report_md),
            command_records=[r.to_dict() for r in runner.records],
            best_ligand_poses_sdf=best_ligand_poses_sdf,
        )


def load_target_config(path: str | Path) -> TargetConfig:
    source = require_file(path, "target config")
    try:
        import yaml

        data = yaml.safe_load(source.read_text(encoding="utf-8"))
    except Exception:
        data = json.loads(source.read_text(encoding="utf-8"))
    if not isinstance(data, dict):
        raise RDockPipelineError(f"Invalid target config payload in {source}")

    config_dir = source.parent.resolve()
    dataset_target_dir = config_dir.parent.resolve()

    def _rebase_file(value: object, *candidate_dirs: Path) -> str:
        text = str(value or "").strip()
        if not text:
            return text
        current = Path(text)
        if current.exists():
            return str(current.resolve())
        for base in candidate_dirs:
            candidate = (base / current.name).resolve()
            if candidate.exists():
                return str(candidate)
        return text

    data["target_dir"] = str(config_dir)
    data["receptor_prm"] = _rebase_file(data.get("receptor_prm", ""), config_dir)
    data["cavity_as"] = _rebase_file(data.get("cavity_as", ""), config_dir)
    data["receptor_mol2"] = _rebase_file(data.get("receptor_mol2", ""), config_dir, dataset_target_dir)
    data["reference_ligand"] = _rebase_file(data.get("reference_ligand", ""), config_dir, dataset_target_dir)
    data["receptor"] = _rebase_file(data.get("receptor", ""), config_dir, dataset_target_dir)
    if data.get("receptor_prm"):
        _normalize_receptor_prm_paths(Path(str(data["receptor_prm"])), config_dir, dataset_target_dir)
    return TargetConfig(**data)