#!/usr/bin/env python3
"""Analyse docking poses with PoseBusters and OST.

The script processes one docking run directory (for example
``docking/gnina_redock``) and writes pose-level CSV and Parquet files beneath a
shared analysis directory.
"""

from __future__ import annotations

import argparse
import csv
import json
import logging
import re
import shutil
import subprocess
from concurrent.futures import ProcessPoolExecutor, as_completed
from pathlib import Path
from typing import Sequence

import pandas as pd
from posebusters import PoseBusters
from rdkit import Chem, RDLogger


SUPPORTED_METHODS = {"gnina", "smina", "diffdock"}


def file_ok(path: Path) -> bool:
    """Return whether a file exists and is non-empty."""
    return path.is_file() and path.stat().st_size > 0


def infer_similarity_label(path: Path) -> str:
    """Infer a date label from a similarity TSV filename."""
    match = re.search(r"\d{4}-\d{2}-\d{2}", path.name)
    if match is None:
        raise ValueError(f"Could not infer date label from similarity TSV: {path}")
    return match.group(0)


def load_similarity_dicts(
    similarity_tsvs: Sequence[Path] | None,
) -> dict[str, dict[str, str]] | None:
    """Load optional similarity TSVs and suffix metric names by date."""
    if not similarity_tsvs:
        return None

    metric_cols = ["sucos_shape", "pocket_qcov", "sucos_shape_pocket_qcov"]
    similarity_dict: dict[str, dict[str, str]] = {}

    for similarity_tsv in similarity_tsvs:
        path = similarity_tsv.expanduser().resolve()
        if not file_ok(path):
            raise FileNotFoundError(f"Similarity TSV not found or empty: {path}")

        label = infer_similarity_label(path)
        with path.open("r", encoding="utf-8", newline="") as handle:
            reader = csv.DictReader(handle, delimiter="\t")
            if reader.fieldnames is None or reader.fieldnames[0] is None:
                raise ValueError(f"Similarity TSV has no header: {path}")
            missing = set(metric_cols) - set(reader.fieldnames)
            if missing:
                raise ValueError(
                    f"Similarity TSV is missing columns {sorted(missing)}: {path}"
                )

            id_column = reader.fieldnames[0]
            for row in reader:
                complex_id = row[id_column]
                similarity_dict.setdefault(complex_id, {})
                for col in metric_cols:
                    similarity_dict[complex_id][f"{col}-{label}"] = row[col]

    return similarity_dict


def add_similarity_metrics(
    df: pd.DataFrame,
    similarity_dict: dict[str, dict[str, str]] | None,
) -> pd.DataFrame:
    """Attach optional similarity metrics for each comparison complex."""
    if similarity_dict is None:
        return df
    metric_cols = sorted({col for values in similarity_dict.values() for col in values})
    for col in metric_cols:
        df[col] = df["compare_id"].map(
            lambda complex_id: similarity_dict.get(complex_id, {}).get(col)
        )
    return df


def structure_root_from_run(run_dir: Path) -> Path:
    """Resolve the dataset root from ``<dataset>/docking/<run>``."""
    if run_dir.parent.name != "docking":
        raise ValueError(
            f"Run directory must be directly beneath a 'docking' directory: {run_dir}"
        )
    structure_root = run_dir.parent.parent
    if not (structure_root / "prepared_inputs" / "redock").is_dir():
        raise FileNotFoundError(
            f"Redock prepared inputs not found beneath dataset root: {structure_root}"
        )
    return structure_root


def reference_paths(structure_root: Path, complex_id: str) -> tuple[Path, Path]:
    """Return the redock receptor and crystallographic ligand for one complex."""
    directory = structure_root / "prepared_inputs" / "redock" / complex_id
    protein = directory / f"{complex_id}_prepared.pdb"
    ligand = directory / f"{complex_id}_reference_ligand.sdf"
    if not file_ok(protein):
        raise FileNotFoundError(f"Missing reference receptor: {protein}")
    if not file_ok(ligand):
        raise FileNotFoundError(f"Missing reference ligand: {ligand}")
    return protein, ligand


def docked_protein_path(structure_root: Path, mode: str, complex_id: str) -> Path:
    """Return the exact receptor used for one docking mode."""
    directory = structure_root / "prepared_inputs" / mode / complex_id
    if not directory.is_dir():
        raise FileNotFoundError(f"Prepared receptor directory not found: {directory}")

    if mode == "redock":
        path = directory / f"{complex_id}_prepared.pdb"
    elif mode == "fragment_crossdock":
        matches = sorted(directory.glob("fragment_crossdock_*_aligned.pdb"))
        if len(matches) != 1:
            raise FileNotFoundError(
                f"Expected one fragment-crossdock receptor in {directory}; found {len(matches)}"
            )
        path = matches[0]
    else:
        path = directory / f"{mode}_prepared_aligned.pdb"

    if not file_ok(path):
        raise FileNotFoundError(f"Docked receptor not found or empty: {path}")
    return path


def seed_dirs(complex_dir: Path) -> list[Path]:
    """Return immediate seed directories for one docked complex."""
    directories = sorted(path for path in complex_dir.glob("seed_*") if path.is_dir())
    if not directories:
        raise FileNotFoundError(f"No seed directories found in: {complex_dir}")
    return directories


def pose_dir(seed_dir: Path) -> Path:
    """Return the canonical docked-pose directory."""
    directory = seed_dir / "docked_poses"
    if not directory.is_dir():
        raise FileNotFoundError(f"Docked-pose directory not found: {directory}")
    return directory


def format_chain_mapping(mapping: dict | None) -> str | None:
    """Format an OST chain mapping as a compact string."""
    if not mapping:
        return None
    return ",".join(f"{key}:{value}" for key, value in sorted(mapping.items()))


def ost_to_df(path: Path) -> pd.DataFrame:
    """Convert OST ligand-comparison output to a pose-level table."""
    with path.open("r", encoding="utf-8") as handle:
        ost = json.load(handle)

    lddt_rows = []
    for row in ost["lddt_pli"]["full_results"]:
        sample = int(row["model_ligand"].rsplit(":", 1)[1])
        score = row.get("score")
        lddt_rows.append(
            {"sample": sample, "lddt_pli": float(score) if score is not None else 0.0}
        )

    rmsd_rows = []
    for row in ost["rmsd"]["full_results"]:
        sample = int(row["model_ligand"].rsplit(":", 1)[1])
        score = row.get("score")
        rmsd_rows.append(
            {
                "sample": sample,
                "lig_rmsd": float(score) if score is not None else 99.0,
                "rmsd_chain_mapping": format_chain_mapping(row.get("chain_mapping")),
                "lddt_lp": row.get("lddt_lp"),
                "pocket_bb_rmsd": row.get("bb_rmsd"),
            }
        )
    return pd.DataFrame(lddt_rows).merge(
        pd.DataFrame(rmsd_rows), on="sample", how="outer"
    )


def posebusters_to_df(path: Path) -> pd.DataFrame:
    """Convert PoseBusters output to a pose-level validity table."""
    df = pd.read_csv(path).copy()

    if "position" in df.columns:
        df["sample"] = df["position"].astype(int)
    else:
        df["sample"] = range(len(df))

    meta_cols = {"file", "molecule", "position", "sample"}
    metric_cols = [col for col in df.columns if col not in meta_cols]

    if not metric_cols:
        raise ValueError(f"PoseBusters output contains no check columns: {path}")

    df["pb_valid"] = df[metric_cols].all(axis=1)

    return df[["sample", "pb_valid"]]


def sdf_to_pose_df(
    path: Path, score_property: str, flip_sign: bool = False
) -> pd.DataFrame:
    """Read pose scores from a ranked SDF file."""
    rows: list[dict[str, object]] = []
    for sample, mol in enumerate(Chem.SDMolSupplier(str(path), removeHs=False)):
        if mol is None:
            raise ValueError(f"Invalid molecule at position {sample} in {path}")
        if not mol.HasProp(score_property):
            raise ValueError(f"Pose {sample} in {path} is missing '{score_property}'")
        score = float(mol.GetProp(score_property))
        rows.append({"sample": sample, "rank_score": -score if flip_sign else score})
    if not rows:
        raise ValueError(f"No poses found in SDF: {path}")
    return pd.DataFrame(rows)


def rank_molecules(
    molecules: list[Chem.Mol],
    score_property: str,
    descending: bool,
) -> list[Chem.Mol]:
    """Rank molecules by an SDF score property and annotate their rank."""
    for molecule in molecules:
        if not molecule.HasProp(score_property):
            raise ValueError(
                f"Molecule is missing required score property '{score_property}'"
            )
    ranked = sorted(
        molecules,
        key=lambda molecule: float(molecule.GetProp(score_property)),
        reverse=descending,
    )
    for rank, molecule in enumerate(ranked, start=1):
        molecule.SetIntProp("rank", rank)
    return ranked


def join_diffdock_sdfs(input_dir: Path, output_sdf: Path) -> None:
    """Combine DiffDock rank files while preserving confidence and rank metadata."""
    files = sorted(input_dir.glob("rank*_confidence*.sdf"))
    if not files:
        raise FileNotFoundError(f"No DiffDock SDF files found in: {input_dir}")

    def parse_rank_conf(path: Path) -> tuple[int, float]:
        match = re.search(r"rank(\d+)_confidence([-\d\.eE]+)", path.stem)
        if match is None:
            raise ValueError(f"Unexpected DiffDock filename: {path.name}")
        return int(match.group(1)), float(match.group(2))

    with Chem.SDWriter(str(output_sdf)) as writer:
        for path in sorted(files, key=lambda item: parse_rank_conf(item)[0]):
            molecules = [mol for mol in Chem.SDMolSupplier(str(path), removeHs=False)]
            if len(molecules) != 1 or molecules[0] is None:
                raise ValueError(f"Expected exactly one valid molecule in {path}")
            rank, confidence = parse_rank_conf(path)
            molecule = molecules[0]
            molecule.SetIntProp("rank", rank)
            molecule.SetProp("confidence", f"{confidence:.6f}")
            writer.write(molecule)


def join_docking_sdfs(
    input_dir: Path,
    output_sdf: Path,
    score_property: str,
    descending: bool,
) -> None:
    """Combine all GNINA/Smina pose files and rank poses globally."""
    files = sorted(input_dir.glob("*_docked_*.sdf"))
    if not files:
        raise FileNotFoundError(f"No docking SDF files found in: {input_dir}")

    molecules: list[Chem.Mol] = []
    for path in files:
        for index, molecule in enumerate(Chem.SDMolSupplier(str(path), removeHs=False)):
            if molecule is None:
                raise ValueError(f"Invalid molecule at position {index} in {path}")
            molecules.append(molecule)

    with Chem.SDWriter(str(output_sdf)) as writer:
        for molecule in rank_molecules(molecules, score_property, descending):
            writer.write(molecule)


def run_posebusters(
    buster: PoseBusters,
    sdf_path: Path,
    receptor_path: Path,
    output_path: Path,
    overwrite: bool,
) -> None:
    """Run PoseBusters unless a valid cached output is available."""
    if file_ok(output_path) and not overwrite:
        return
    molecules = list(Chem.SDMolSupplier(str(sdf_path), removeHs=False))
    if not molecules or any(molecule is None for molecule in molecules):
        raise ValueError(f"Could not read all poses from {sdf_path}")
    results = buster.bust(molecules, None, receptor_path)
    results.to_csv(output_path, index=False)


def run_ost(
    sdf_path: Path,
    docked_receptor_path: Path,
    reference_receptor_path: Path,
    reference_ligand_path: Path,
    output_path: Path,
    overwrite: bool,
) -> None:
    """Run OST ligand-structure comparison unless cached output is available."""
    if file_ok(output_path) and not overwrite:
        return
    command = [
        "ost",
        "compare-ligand-structures",
        "-m",
        str(docked_receptor_path),
        "-ml",
        str(sdf_path),
        "-r",
        str(reference_receptor_path),
        "-rl",
        str(reference_ligand_path),
        "--lddt-pli",
        "--rmsd",
        "-o",
        str(output_path),
        "-v",
        "0",
        "--full-results",
    ]
    subprocess.run(command, check=True)


def process_complex(
    complex_dir: Path,
    structure_root: Path,
    method: str,
    mode: str,
    run_label: str,
    overwrite: bool,
    similarity_dict: dict[str, dict[str, str]] | None,
) -> pd.DataFrame:
    """Analyse all seeds for one complex."""
    complex_id = complex_dir.name
    RDLogger.DisableLog("rdApp.warning")
    buster = PoseBusters(config="dock")

    reference_receptor, reference_ligand = reference_paths(structure_root, complex_id)
    docked_receptor = docked_protein_path(structure_root, mode, complex_id)
    reference_mol = Chem.MolFromMolFile(str(reference_ligand), removeHs=False)
    if reference_mol is None:
        raise ValueError(f"Could not read reference ligand: {reference_ligand}")
    ligand_smiles = Chem.MolToSmiles(reference_mol)

    if method == "gnina":
        score_property, flip_sign, descending = "CNNscore", False, True
    elif method == "smina":
        score_property, flip_sign, descending = "minimizedAffinity", True, False
    elif method == "diffdock":
        score_property, flip_sign, descending = "confidence", False, True
    else:
        raise ValueError(f"Unsupported method: {method}")

    results: list[pd.DataFrame] = []
    for seed_dir in seed_dirs(complex_dir):
        raw_pose_dir = pose_dir(seed_dir)
        joined_sdf = seed_dir / f"{complex_id}_{run_label}_joined.sdf"

        if method == "diffdock":
            if not file_ok(joined_sdf) or overwrite:
                join_diffdock_sdfs(raw_pose_dir, joined_sdf)
        else:
            if not file_ok(joined_sdf) or overwrite:
                join_docking_sdfs(raw_pose_dir, joined_sdf, score_property, descending)

        pb_path = seed_dir / f"PB_{complex_id}_{run_label}.csv"
        run_posebusters(buster, joined_sdf, docked_receptor, pb_path, overwrite)
        ost_path = seed_dir / f"OST_{complex_id}_{run_label}.json"
        run_ost(
            joined_sdf,
            docked_receptor,
            reference_receptor,
            reference_ligand,
            ost_path,
            overwrite,
        )

        pose_df = sdf_to_pose_df(joined_sdf, score_property, flip_sign=flip_sign)
        pb_df = posebusters_to_df(pb_path)
        ost_df = ost_to_df(ost_path)
        ost_df["compare_id"] = complex_id

        df = pose_df.merge(pb_df, on="sample", how="left", validate="one_to_one").merge(
            ost_df, on="sample", how="left", validate="one_to_one"
        )
        df = add_similarity_metrics(df, similarity_dict)
        df["dock_prot"] = mode
        df["complex_id"] = complex_id
        df["seed"] = seed_dir.name
        df["method"] = method
        df["ligand_smiles"] = ligand_smiles
        results.append(df)

    return pd.concat(results, ignore_index=True)


def build_parser() -> argparse.ArgumentParser:
    """Build the command-line parser."""
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "run_dir", type=Path, help="One method/mode docking run directory."
    )
    parser.add_argument("--method", required=True, choices=sorted(SUPPORTED_METHODS))
    parser.add_argument("--mode", required=True, help="Prepared docking mode name.")
    parser.add_argument(
        "--similarity-tsv",
        type=Path,
        nargs="+",
        default=None,
        help="Optional similarity TSV file(s).",
    )
    parser.add_argument(
        "--num-workers",
        "-j",
        type=int,
        default=8,
        help="Number of complexes analysed in parallel (default: 8).",
    )
    parser.add_argument(
        "--overwrite",
        action="store_true",
        help="Recompute cached OST/PoseBusters outputs.",
    )
    parser.add_argument(
        "--output-dir",
        type=Path,
        default=None,
        help="Analysis root (default: sibling analysis directory).",
    )
    parser.add_argument("--suffix", default="", help="Optional output filename suffix.")
    parser.add_argument("--verbose", "-v", action="store_true")
    return parser


def main() -> None:
    """Run docking analysis."""
    args = build_parser().parse_args()
    logging.basicConfig(
        level=logging.DEBUG if args.verbose else logging.INFO,
        format="%(asctime)s %(levelname)s %(message)s",
        datefmt="%Y-%m-%d %H:%M:%S",
    )
    logging.getLogger("posebusters").setLevel(logging.ERROR)
    RDLogger.DisableLog("rdApp.warning")

    if shutil.which("ost") is None:
        raise FileNotFoundError("OST executable 'ost' was not found on PATH")
    if args.num_workers < 1:
        raise ValueError("--num-workers must be at least 1")

    run_dir = args.run_dir.expanduser().resolve()
    if not run_dir.is_dir():
        raise FileNotFoundError(f"Docking run directory not found: {run_dir}")
    expected_name = f"{args.method}_{args.mode}"
    if run_dir.name != expected_name:
        raise ValueError(
            f"Run directory name must be '{expected_name}', got '{run_dir.name}'"
        )

    structure_root = structure_root_from_run(run_dir)
    output_dir = (
        args.output_dir.expanduser().resolve()
        if args.output_dir is not None
        else run_dir.parent.parent / "analysis"
    )
    similarity_dict = load_similarity_dicts(args.similarity_tsv)
    run_label = run_dir.name

    complex_dirs = sorted(path for path in run_dir.iterdir() if path.is_dir())
    if not complex_dirs:
        raise ValueError(f"No complex directories found in: {run_dir}")

    all_results: list[pd.DataFrame] = []
    failures: list[tuple[str, str]] = []
    jobs = [
        (
            complex_dir,
            structure_root,
            args.method,
            args.mode,
            run_label,
            args.overwrite,
            similarity_dict,
        )
        for complex_dir in complex_dirs
    ]

    with ProcessPoolExecutor(max_workers=args.num_workers) as executor:
        futures = {executor.submit(process_complex, *job): job[0].name for job in jobs}
        for future in as_completed(futures):
            complex_id = futures[future]
            try:
                all_results.append(future.result())
                logging.info("Finished %s", complex_id)
            except Exception as exc:
                failures.append((complex_id, str(exc)))
                logging.exception("Failed %s", complex_id)

    if not all_results:
        raise RuntimeError("Analysis produced no results")

    final_df = pd.concat(all_results, ignore_index=True)
    column_order = [
        "complex_id",
        "dock_prot",
        "method",
        "seed",
        "sample",
        "rank_score",
        "pb_valid",
        "lig_rmsd",
        "lddt_pli",
        "compare_id",
        "lddt_lp",
        "pocket_bb_rmsd",
        "rmsd_chain_mapping",
        "ligand_smiles",
    ]
    existing = [column for column in column_order if column in final_df.columns]
    extra = [column for column in final_df.columns if column not in column_order]
    final_df = final_df[existing + extra]

    suffix = args.suffix
    if suffix and not suffix.startswith("_"):
        suffix = f"_{suffix}"
    base_name = f"{run_label}{suffix}"
    csv_dir = output_dir / "csv"
    parquet_dir = output_dir / "parquet"
    csv_dir.mkdir(parents=True, exist_ok=True)
    parquet_dir.mkdir(parents=True, exist_ok=True)
    final_df.to_csv(csv_dir / f"{base_name}.csv", index=False)
    final_df.to_parquet(parquet_dir / f"{base_name}.parquet", index=False)

    logging.info("Wrote %d pose rows for %s", len(final_df), run_label)
    if failures:
        failure_path = output_dir / "logs" / f"{run_label}_failed_complexes.tsv"
        failure_path.parent.mkdir(parents=True, exist_ok=True)
        with failure_path.open("w", encoding="utf-8") as handle:
            handle.write("complex_id\treason\n")
            for complex_id, reason in failures:
                handle.write(
                    f"{complex_id}\t{reason.replace(chr(9), ' ').replace(chr(10), ' ')}\n"
                )
        raise SystemExit(f"Analysis completed with {len(failures)} failed complexes")


if __name__ == "__main__":
    main()