docking_pipeline/dataset.py

from __future__ import annotations

import csv
import json
import math
import subprocess
import shutil
import urllib.request
from datetime import UTC, datetime
from pathlib import Path
from typing import Any

from .config_io import dump_json_like, load_structured_file
from .provenance import RDockPipelineError, probe_version, require_executable, require_file
from .rdock import RDockEngine, RDockRunConfig, load_target_config
from .sdf import ligand_id_from_block, parse_tags, split_sdf_file


IGNORED_SOLVENT_RESNAMES = {
    "HOH",
    "WAT",
    "DOD",
    "SOL",
    "EDO",
    "GOL",
    "PEG",
    "PG4",
    "PGE",
    "MPD",
    "EOH",
    "IPA",
    "DMS",
    "ACT",
    "ACY",
    "FMT",
    "TRS",
    "MES",
    "BME",
}
IGNORED_BUFFER_RESNAMES = {
    "SO4",
    "PO4",
    "CL",
    "BR",
    "IOD",
    "NO3",
    "SCN",
    "IMD",
    "CIT",
    "ACE",
}
METAL_ELEMENTS = {
    "LI",
    "NA",
    "K",
    "RB",
    "CS",
    "MG",
    "CA",
    "SR",
    "BA",
    "ZN",
    "FE",
    "CO",
    "NI",
    "CU",
    "MN",
    "CD",
    "HG",
    "AG",
    "AU",
}


def count_sdf_records(path: str | Path) -> int:
    return len(split_sdf_file(path))


def list_known_good_complexes(config_path: str | Path) -> list[dict[str, Any]]:
    payload = load_structured_file(config_path)
    complexes = payload.get("complexes")
    if not isinstance(complexes, list):
        raise RDockPipelineError(f"`complexes` list missing in {config_path}")
    return [dict(item) for item in complexes]


def _parse_pdb_atom_line(line: str) -> dict[str, Any]:
    record = line[:6].strip()
    atom_name = line[12:16].strip()
    resname = line[17:20].strip().upper()
    chain = line[21:22].strip()
    residue_id = line[22:26].strip()
    try:
        x = float(line[30:38].strip())
        y = float(line[38:46].strip())
        z = float(line[46:54].strip())
    except ValueError:
        x = y = z = math.nan
    element = line[76:78].strip().upper() or "".join(char for char in atom_name if char.isalpha())[:2].upper()
    return {
        "record": record,
        "atom_name": atom_name,
        "resname": resname,
        "chain": chain,
        "residue_id": residue_id,
        "x": x,
        "y": y,
        "z": z,
        "element": element,
        "line": line,
    }


def _is_heavy_atom(element: str) -> bool:
    return bool(element) and element != "H"


def _classify_hetero_group(resname: str, elements: set[str], heavy_atom_count: int) -> tuple[bool, str]:
    if resname in IGNORED_SOLVENT_RESNAMES:
        return True, "solvent"
    if resname in IGNORED_BUFFER_RESNAMES:
        return True, "buffer_or_salt"
    if elements and elements.issubset(METAL_ELEMENTS):
        return True, "ion_or_metal"
    if heavy_atom_count <= 1:
        return True, "tiny_fragment"
    return False, ""


def list_hetero_ligands(pdb_like: str | Path, min_reference_ligand_atoms: int = 8) -> list[dict[str, Any]]:
    source = require_file(pdb_like, "PDB/mmCIF structure")
    groups: dict[tuple[str, str, str], dict[str, Any]] = {}
    for line in source.read_text(encoding="utf-8", errors="ignore").splitlines():
        if not line.startswith("HETATM"):
            continue
        atom = _parse_pdb_atom_line(line)
        key = (atom["resname"], atom["chain"], atom["residue_id"])
        group = groups.setdefault(
            key,
            {
                "resname": atom["resname"],
                "chain": atom["chain"],
                "residue_id": atom["residue_id"],
                "atom_count": 0,
                "heavy_atom_count": 0,
                "elements": set(),
            },
        )
        group["atom_count"] += 1
        if _is_heavy_atom(atom["element"]):
            group["heavy_atom_count"] += 1
        if atom["element"]:
            group["elements"].add(atom["element"])
    rows: list[dict[str, Any]] = []
    for _, group in sorted(groups.items()):
        ignored, reason = _classify_hetero_group(
            str(group["resname"]),
            set(group["elements"]),
            int(group["heavy_atom_count"]),
        )
        rows.append(
            {
                "resname": str(group["resname"]),
                "chain": str(group["chain"]),
                "residue_id": str(group["residue_id"]),
                "atom_count": int(group["atom_count"]),
                "heavy_atom_count": int(group["heavy_atom_count"]),
                "ignored": ignored,
                "ignored_reason": reason,
                "candidate_ligand": (not ignored) and int(group["heavy_atom_count"]) >= int(min_reference_ligand_atoms),
            }
        )
    return rows


def auto_detect_reference_ligand(
    pdb_like: str | Path,
    receptor_chain: str,
    min_reference_ligand_atoms: int = 8,
) -> tuple[dict[str, Any], list[dict[str, Any]]]:
    source = require_file(pdb_like, "PDB/mmCIF structure")
    hetero = list_hetero_ligands(source, min_reference_ligand_atoms=min_reference_ligand_atoms)
    receptor_chains = {item.strip() for item in receptor_chain.split(",") if item.strip()}
    receptor_atoms: list[tuple[float, float, float]] = []
    ligand_atoms: dict[tuple[str, str, str], list[tuple[float, float, float]]] = {}
    for line in source.read_text(encoding="utf-8", errors="ignore").splitlines():
        if not line.startswith(("ATOM", "HETATM")):
            continue
        atom = _parse_pdb_atom_line(line)
        if line.startswith("ATOM") and (not receptor_chains or atom["chain"] in receptor_chains):
            if not math.isnan(atom["x"]):
                receptor_atoms.append((atom["x"], atom["y"], atom["z"]))
        elif line.startswith("HETATM"):
            key = (atom["resname"], atom["chain"], atom["residue_id"])
            ligand_atoms.setdefault(key, [])
            if not math.isnan(atom["x"]):
                ligand_atoms[key].append((atom["x"], atom["y"], atom["z"]))
    if not receptor_atoms:
        raise RDockPipelineError(f"No receptor atoms found in {source} for chain(s) {receptor_chain}")

    def _min_distance(points: list[tuple[float, float, float]]) -> float:
        best = math.inf
        for lx, ly, lz in points:
            for rx, ry, rz in receptor_atoms:
                dist = math.dist((lx, ly, lz), (rx, ry, rz))
                if dist < best:
                    best = dist
        return best

    candidates: list[dict[str, Any]] = []
    for row in hetero:
        key = (str(row["resname"]), str(row["chain"]), str(row["residue_id"]))
        points = ligand_atoms.get(key, [])
        if not points:
            continue
        min_dist = _min_distance(points)
        enriched = dict(row)
        enriched["min_distance_to_receptor"] = min_dist
        enriched["contact_candidate"] = bool(row["candidate_ligand"]) and min_dist <= 6.0
        candidates.append(enriched)
    viable = [row for row in candidates if row["candidate_ligand"]]
    if not viable:
        raise RDockPipelineError(
            f"No suitable reference ligand candidates found in {source}. "
            f"Available hetero entries: {candidates[:20]}"
        )
    viable.sort(
        key=lambda item: (
            int(bool(item.get("contact_candidate"))),
            int(item.get("heavy_atom_count", 0)),
            int(item.get("atom_count", 0)),
            -float(item.get("min_distance_to_receptor", math.inf)),
        ),
        reverse=True,
    )
    return viable[0], candidates


def resolve_known_good_defaults(
    config_path: str | Path,
    pdb_id: str,
    receptor_chain: str | None,
    ligand_resname: str | None,
    ligand_chain: str | None,
) -> dict[str, str]:
    pdb_upper = pdb_id.upper().strip()
    matches = [item for item in list_known_good_complexes(config_path) if str(item.get("pdb_id", "")).upper() == pdb_upper]
    if not matches:
        return {
            "pdb_id": pdb_upper,
            "receptor_chain": receptor_chain or "",
            "reference_ligand_resname": ligand_resname or "",
            "reference_ligand_chain": ligand_chain or "",
        }
    chosen = matches[0]
    return {
        "pdb_id": pdb_upper,
        "receptor_chain": receptor_chain or str(chosen.get("receptor_chain", "")),
        "reference_ligand_resname": ligand_resname or str(chosen.get("reference_ligand_resname", "")),
        "reference_ligand_chain": ligand_chain or str(chosen.get("reference_ligand_chain", "")),
    }


def download_pdb_structure(pdb_id: str, out_dir: str | Path, force: bool = False) -> Path:
    target_dir = Path(out_dir)
    target_dir.mkdir(parents=True, exist_ok=True)
    pdb_id = pdb_id.upper().strip()
    pdb_path = target_dir / f"{pdb_id.lower()}.pdb"
    if pdb_path.exists() and pdb_path.stat().st_size > 0 and not force:
        return pdb_path
    url = f"https://files.rcsb.org/download/{pdb_id}.pdb"
    try:
        urllib.request.urlretrieve(url, pdb_path)
    except Exception as exc:
        curl = shutil.which("curl")
        if curl:
            proc = subprocess.run(
                [curl, "-fsSL", url, "-o", str(pdb_path)],
                check=False,
                capture_output=True,
                text=True,
            )
            if proc.returncode == 0 and pdb_path.exists() and pdb_path.stat().st_size > 0:
                return require_file(pdb_path, f"downloaded PDB for {pdb_id}")
            raise RDockPipelineError(
                f"Failed to download PDB {pdb_id} from {url}. urllib error: {exc}. "
                f"curl stderr: {proc.stderr.strip() or '<empty>'}. "
                f"Check network access or provide a locally cached PDB in {target_dir}."
            ) from exc
        raise RDockPipelineError(
            f"Failed to download PDB {pdb_id} from {url}: {exc}. "
            "curl is not available for fallback; check network access or pre-stage the PDB file locally."
        ) from exc
    return require_file(pdb_path, f"downloaded PDB for {pdb_id}")


def extract_receptor_and_reference_ligand(
    pdb_like: str | Path,
    receptor_chain: str,
    ligand_resname: str,
    ligand_chain: str,
    out_dir: str | Path,
    min_reference_ligand_atoms: int = 8,
) -> tuple[Path, Path, list[dict[str, str]]]:
    source = require_file(pdb_like, "PDB/mmCIF structure")
    out_root = Path(out_dir)
    out_root.mkdir(parents=True, exist_ok=True)
    receptor = out_root / "target_raw.pdb"
    ligand_pdb = out_root / "reference_ligand_raw.pdb"

    receptor_lines: list[str] = []
    ligand_lines: list[str] = []
    hetero_rows = list_hetero_ligands(source, min_reference_ligand_atoms=min_reference_ligand_atoms)
    receptor_chains = {item.strip() for item in receptor_chain.split(",") if item.strip()}
    wanted_resname = ligand_resname.upper().strip()
    wanted_chain = ligand_chain.strip()
    wanted_keys = {
        (str(item["resname"]), str(item["chain"]), str(item["residue_id"]))
        for item in hetero_rows
        if str(item["resname"]) == wanted_resname and (not wanted_chain or str(item["chain"]) == wanted_chain)
    }

    for line in source.read_text(encoding="utf-8", errors="ignore").splitlines():
        record = line[:6].strip()
        atom = _parse_pdb_atom_line(line)
        chain = str(atom["chain"])
        resname = str(atom["resname"])
        if record == "ATOM" and (not receptor_chains or chain in receptor_chains):
            receptor_lines.append(line)
        if record == "HETATM":
            key = (resname, chain, str(atom["residue_id"]))
            if key in wanted_keys:
                ligand_lines.append(line)
    if not receptor_lines:
        raise RDockPipelineError(f"No receptor atoms found in {source} for chain(s) {receptor_chain}")
    if not ligand_lines:
        raise RDockPipelineError(
            f"Reference ligand {wanted_resname} chain {wanted_chain or '*'} not found in {source}. "
            f"Available hetero ligands: {hetero_rows[:20]}"
        )

    receptor.write_text("\n".join(receptor_lines + ["END", ""]), encoding="utf-8")
    ligand_pdb.write_text("\n".join(ligand_lines + ["END", ""]), encoding="utf-8")
    return receptor, ligand_pdb, hetero_rows


def validate_dataset_dir(dataset_dir: str | Path, check_rdock_tools: bool = False) -> dict[str, Any]:
    root = Path(dataset_dir)
    manifest_path = root / "dataset_manifest.json"
    manifest = json.loads(require_file(manifest_path, "dataset manifest").read_text(encoding="utf-8"))
    required = {
        "target_mol2": root / "target" / "target.mol2",
        "all_ligands_sdf": root / "ligands" / "all_ligands.sdf",
        "invalid_ligands_csv": root / "ligands" / "invalid_ligands.csv",
        "preparation_report": root / "qc" / "preparation_report.md",
        "target_config": root / "target" / "rdock_prm" / "target_config.yaml",
    }
    for label, path in required.items():
        require_file(path, label)
    ligand_count = count_sdf_records(required["all_ligands_sdf"])
    expected_count = int(manifest.get("ligands_prepared", 0))
    if expected_count and ligand_count != expected_count:
        raise RDockPipelineError(
            f"Ligand count mismatch for {root}: manifest says {expected_count}, SDF contains {ligand_count}"
        )
    reference_ligand = root / "target" / "reference_ligand.sdf"
    ref_count = count_sdf_records(reference_ligand) if reference_ligand.exists() else 0
    target_config = load_target_config(required["target_config"])
    cavity = require_file(target_config.cavity_as, "rDock cavity .as file from dataset")
    if cavity.stat().st_size <= 0:
        raise RDockPipelineError(f"Invalid empty cavity file in dataset: {cavity}")
    ligand_source = str(manifest.get("ligand_source", ""))
    if ligand_source.startswith("pubchem") and not manifest.get("pubchem_diagnostics"):
        require_file(root / "logs" / "pubchem_diagnostics.json", "PubChem diagnostics log")
    tools: dict[str, str] = {}
    if check_rdock_tools:
        tools = {
            "rbdock": probe_version(require_executable("rbdock")),
            "rbcavity": probe_version(require_executable("rbcavity")),
            "obabel": probe_version(require_executable("obabel")),
        }
    return {
        "dataset_dir": str(root),
        "manifest": manifest,
        "ligand_count": ligand_count,
        "reference_records": ref_count,
        "has_reference_ligand": ref_count > 0,
        "target_config": str(required["target_config"]),
        "executables": tools,
    }


def create_dataset_manifest(
    dataset_dir: str | Path,
    payload: dict[str, Any],
) -> Path:
    root = Path(dataset_dir)
    payload = dict(payload)
    payload["created_at"] = datetime.now(UTC).isoformat()
    return dump_json_like(root / "dataset_manifest.json", payload)


def _first_pdb_id(raw_dir: Path) -> str:
    for candidate in sorted(list(raw_dir.glob("*.pdb")) + list(raw_dir.glob("*.cif")) + list(raw_dir.glob("*.mmcif"))):
        stem = candidate.stem.strip()
        if stem:
            return stem[:4].upper()
    return ""


def _infer_reference_fields(target_dir: Path) -> tuple[str, str]:
    raw_pdb = target_dir / "reference_ligand_raw.pdb"
    if raw_pdb.exists():
        for line in raw_pdb.read_text(encoding="utf-8", errors="ignore").splitlines():
            if line.startswith("HETATM"):
                atom = _parse_pdb_atom_line(line)
                return str(atom["resname"]), str(atom["chain"])
    return "", ""


def _infer_receptor_chain(target_dir: Path) -> str:
    receptor = target_dir / "target_raw.pdb"
    chains: list[str] = []
    if receptor.exists():
        for line in receptor.read_text(encoding="utf-8", errors="ignore").splitlines():
            if line.startswith("ATOM"):
                chain = _parse_pdb_atom_line(line)["chain"]
                if chain and chain not in chains:
                    chains.append(str(chain))
    return ",".join(chains[:4])


def _read_smiles_rows(smi_path: Path) -> list[dict[str, str]]:
    rows: list[dict[str, str]] = []
    for idx, line in enumerate(smi_path.read_text(encoding="utf-8", errors="ignore").splitlines()):
        text = line.strip()
        if not text or text.startswith("#"):
            continue
        parts = text.replace(",", " ").split()
        smiles = parts[0]
        ligand_id = parts[1] if len(parts) > 1 else f"lig_{idx:05d}"
        rows.append({"ligand_id": ligand_id, "smiles": smiles})
    return rows


def repair_dataset_dir(dataset_dir: str | Path) -> dict[str, Any]:
    root = Path(dataset_dir)
    target = root / "target"
    ligands = root / "ligands"
    logs = root / "logs"
    qc = root / "qc"
    rdock_prm = target / "rdock_prm"
    raw = root / "raw"
    warnings: list[str] = []

    ligands.mkdir(parents=True, exist_ok=True)
    logs.mkdir(parents=True, exist_ok=True)
    qc.mkdir(parents=True, exist_ok=True)

    metadata_csv = ligands / "ligand_metadata.csv"
    smi_path = ligands / "all_ligands.smi"
    sdf_path = ligands / "all_ligands.sdf"
    if not metadata_csv.exists():
        rows = _read_smiles_rows(smi_path) if smi_path.exists() else [{"ligand_id": ligand_id_from_block(block, parse_tags(block), idx), "smiles": ""} for idx, block in enumerate(split_sdf_file(sdf_path))]
        with metadata_csv.open("w", encoding="utf-8", newline="") as handle:
            writer = csv.DictWriter(handle, fieldnames=["ligand_id", "smiles"])
            writer.writeheader()
            writer.writerows(rows)
        warnings.append("reconstructed ligand_metadata.csv")

    invalid_csv = ligands / "invalid_ligands.csv"
    if not invalid_csv.exists():
        invalid_csv.write_text("ligand_id,reason\n", encoding="utf-8")
        warnings.append("created empty invalid_ligands.csv")

    target_config_path = rdock_prm / "target_config.yaml"
    if target_config_path.exists():
        target_config = load_target_config(target_config_path)
        dump_json_like(
            target_config_path,
            {
                "receptor": target_config.receptor,
                "reference_ligand": target_config.reference_ligand,
                "target_dir": target_config.target_dir,
                "receptor_mol2": target_config.receptor_mol2,
                "receptor_prm": target_config.receptor_prm,
                "cavity_as": target_config.cavity_as,
                "pocket_center": target_config.pocket_center,
                "pocket_radius": target_config.pocket_radius,
                "diagnostics": target_config.diagnostics,
            },
        )

    manifest_path = root / "dataset_manifest.json"
    if not manifest_path.exists():
        pdb_id = _first_pdb_id(raw)
        ligand_resname, ligand_chain = _infer_reference_fields(target)
        receptor_chain = _infer_receptor_chain(target)
        ligand_source = "smiles_file"
        pubchem_payload: dict[str, Any] = {}
        pubchem_path = logs / "pubchem_diagnostics.json"
        if pubchem_path.exists():
            try:
                pubchem_payload = json.loads(pubchem_path.read_text(encoding="utf-8"))
            except Exception:
                pubchem_payload = {}
            ligand_source = str(pubchem_payload.get("source") or "pubchem_similarity")
        create_dataset_manifest(
            root,
            {
                "pdb_id": pdb_id,
                "receptor_chain": receptor_chain,
                "reference_ligand_resname": ligand_resname,
                "reference_ligand_chain": ligand_chain,
                "n_ligands_requested": len(_read_smiles_rows(smi_path)) if smi_path.exists() else count_sdf_records(sdf_path),
                "ligands_prepared": count_sdf_records(sdf_path),
                "paths": {
                    "target_mol2": str(target / "target.mol2"),
                    "reference_ligand_sdf": str(target / "reference_ligand.sdf"),
                    "all_ligands_sdf": str(sdf_path),
                    "all_ligands_smi": str(smi_path),
                    "rdock_prm_dir": str(rdock_prm),
                    "target_config_yaml": str(target_config_path),
                },
                "ligand_source": ligand_source,
                "pubchem_diagnostics": pubchem_payload,
                "pocket_definition_mode": "dataset_manifest",
                "has_reference_ligand": (target / "reference_ligand.sdf").exists(),
                "reference_features_enabled": False,
                "production_reference_free_mode": False,
                "warnings": ["dataset manifest reconstructed during repair"],
            },
        )
        warnings.append("reconstructed dataset_manifest.json")
    else:
        try:
            payload = json.loads(manifest_path.read_text(encoding="utf-8"))
        except Exception:
            payload = {}
        if isinstance(payload, dict):
            changed = False
            defaults = {
                "pocket_definition_mode": "dataset_manifest",
                "has_reference_ligand": (target / "reference_ligand.sdf").exists(),
                "reference_features_enabled": False,
                "production_reference_free_mode": False,
            }
            for key, value in defaults.items():
                if key not in payload:
                    payload[key] = value
                    changed = True
            if changed:
                create_dataset_manifest(root, payload)
                warnings.append("updated dataset_manifest.json with optional reference-free fields")

    report_path = qc / "preparation_report.md"
    if not report_path.exists():
        report_path.write_text(
            "\n".join(
                [
                    f"# Dataset Preparation Report: {root.name}",
                    "",
                    "- report_status: `reconstructed`",
                    f"- target_mol2: `{target / 'target.mol2'}`",
                    f"- reference_ligand_sdf: `{target / 'reference_ligand.sdf'}`",
                    f"- all_ligands_sdf: `{sdf_path}`",
                    f"- all_ligands_smi: `{smi_path}`",
                    *[f"- warning: `{warning}`" for warning in warnings],
                ]
            )
            + "\n",
            encoding="utf-8",
        )
        warnings.append("reconstructed qc/preparation_report.md")

    return {"dataset_dir": str(root), "warnings": warnings}


def copy_prepared_target_bundle(target_config_dir: str | Path, dataset_target_dir: str | Path) -> dict[str, str]:
    src = Path(target_config_dir)
    dst = Path(dataset_target_dir)
    dst.mkdir(parents=True, exist_ok=True)
    copied: dict[str, str] = {}
    for path in src.iterdir():
        if path.is_file():
            shutil.copy2(path, dst / path.name)
            copied[path.name] = str(dst / path.name)
    return copied


def prepare_dataset_target_with_rdock(
    receptor_pdb: str | Path,
    reference_ligand_sdf: str | Path,
    out_dir: str | Path,
    jobs: int | str = "auto",
    cpu_fraction: float = 0.85,
) -> dict[str, Any]:
    engine = RDockEngine(RDockRunConfig(jobs=jobs, cpu_fraction=cpu_fraction))
    target_config = engine.prepare_target(receptor_pdb, reference_ligand_sdf, out_dir)
    return {
        "target_config_yaml": str(Path(out_dir) / "target_config.yaml"),
        "target_config": target_config.__dict__,
    }


def read_ligand_metadata(path: str | Path) -> list[dict[str, str]]:
    with require_file(path, "ligand metadata CSV").open("r", encoding="utf-8", newline="") as handle:
        return list(csv.DictReader(handle))