from __future__ import annotations

import hashlib
import json
import os
import shutil
import subprocess
from dataclasses import asdict, dataclass
from datetime import UTC, datetime
from pathlib import Path
from typing import Sequence


class RDockPipelineError(RuntimeError):
    """Raised for actionable pipeline failures."""


def _candidate_rbt_roots(
    preferred: str | Path | None = None,
    executable: str | None = None,
    env: dict[str, str] | None = None,
) -> list[Path]:
    merged_env = os.environ if env is None else env
    candidates: list[Path] = []

    def _push(path: str | Path | None) -> None:
        if not path:
            return
        p = Path(path)
        if p not in candidates:
            candidates.append(p)

    _push(preferred)
    _push(merged_env.get("RBT_ROOT"))
    rdock_root = merged_env.get("RDOCK_ROOT")
    if rdock_root:
        _push(rdock_root)
        _push(Path(rdock_root) / "share")
        _push(Path(rdock_root) / "share" / "rdock")

    conda_prefix = merged_env.get("CONDA_PREFIX")
    if conda_prefix:
        _push(Path(conda_prefix) / "share" / "rdock")
        _push(Path(conda_prefix) / "share")
        _push(conda_prefix)

    resolved_executable = executable
    if executable and not os.path.sep in executable:
        resolved_executable = shutil.which(executable) or executable
    if resolved_executable:
        prefix = Path(resolved_executable).resolve().parent.parent
        _push(prefix / "share" / "rdock")
        _push(prefix / "share")
        _push(prefix)

    for candidate in (
        Path("/opt/homebrew/opt/rdock/share"),
        Path("/usr/local/opt/rdock/share"),
        Path("/usr/share/rdock"),
        Path("/usr/local/share/rdock"),
    ):
        _push(candidate)
    cellar = Path("/opt/homebrew/Cellar/rdock")
    if cellar.exists():
        for candidate in sorted(cellar.glob("*/share"), reverse=True):
            _push(candidate)
    return candidates


def _is_valid_rbt_root(path: Path) -> bool:
    return (path / "data" / "RbtElements.dat").exists()


def resolve_rbt_root(
    preferred: str | Path | None = None,
    executable: str | None = None,
    env: dict[str, str] | None = None,
) -> str | None:
    for candidate in _candidate_rbt_roots(preferred=preferred, executable=executable, env=env):
        if _is_valid_rbt_root(candidate):
            return str(candidate.resolve())
    return None


def resolve_dock_prm_path(
    preferred_rbt_root: str | Path | None = None,
    executable: str | None = None,
    env: dict[str, str] | None = None,
) -> Path | None:
    root = resolve_rbt_root(preferred=preferred_rbt_root, executable=executable, env=env)
    candidates: list[Path] = []
    if root:
        root_path = Path(root)
        candidates.extend([root_path / "data" / "scripts" / "dock.prm", root_path / "data" / "dock.prm"])
    candidates.append(Path("dock.prm"))
    for candidate in candidates:
        if candidate.exists() and candidate.is_file() and candidate.stat().st_size > 0:
            return candidate.resolve()
    return None


def sha256_file(path: str | Path) -> str:
    source = Path(path)
    h = hashlib.sha256()
    with source.open("rb") as handle:
        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
            h.update(chunk)
    return h.hexdigest()


def require_file(path: str | Path, label: str) -> Path:
    p = Path(path)
    if not p.exists():
        raise RDockPipelineError(f"Missing {label}: {p}")
    if p.is_file() and p.stat().st_size == 0:
        raise RDockPipelineError(f"Empty {label}: {p}")
    return p


def require_executable(name: str) -> str:
    resolved = shutil.which(name)
    if not resolved:
        raise RDockPipelineError(
            f"Required executable `{name}` was not found on PATH. Install rDock/OpenBabel "
            "and ensure RBT_ROOT/RBT_HOME/library paths are configured before running."
        )
    return resolved


def probe_version(executable: str) -> str:
    for args in ([executable, "--version"], [executable, "-version"], [executable, "-h"]):
        try:
            proc = subprocess.run(args, check=False, capture_output=True, text=True, timeout=10)
        except Exception:
            continue
        text = "\n".join([proc.stdout or "", proc.stderr or ""]).strip()
        if text:
            for line in text.splitlines():
                probe = line.strip()
                if probe and set(probe) != {"*"}:
                    return probe[:240]
            return text.splitlines()[0][:240]
    return "unavailable"


@dataclass
class CommandRecord:
    stage: str
    command: list[str]
    cwd: str
    start_time: str
    end_time: str
    exit_code: int
    stdout_log: str
    stderr_log: str

    def to_dict(self) -> dict[str, object]:
        return asdict(self)


class CommandRunner:
    def __init__(self, command_log: str | Path) -> None:
        self.command_log = Path(command_log)
        self.command_log.parent.mkdir(parents=True, exist_ok=True)
        self.records: list[CommandRecord] = []

    def run(
        self,
        stage: str,
        command: Sequence[str],
        cwd: str | Path,
        stdout_log: str | Path,
        stderr_log: str | Path,
        timeout: int | None = None,
        env: dict[str, str] | None = None,
    ) -> CommandRecord:
        cwd_path = Path(cwd)
        stdout_path = Path(stdout_log)
        stderr_path = Path(stderr_log)
        stdout_path.parent.mkdir(parents=True, exist_ok=True)
        stderr_path.parent.mkdir(parents=True, exist_ok=True)
        start = datetime.now(UTC).isoformat()
        merged_env = os.environ.copy()
        if env:
            merged_env.update(env)
        try:
            proc = subprocess.run(
                list(command),
                cwd=str(cwd_path),
                check=False,
                capture_output=True,
                text=True,
                timeout=timeout,
                env=merged_env,
            )
            stdout = proc.stdout or ""
            stderr = proc.stderr or ""
            rc = int(proc.returncode)
        except subprocess.TimeoutExpired as exc:
            stdout = exc.stdout if isinstance(exc.stdout, str) else ""
            stderr = (exc.stderr if isinstance(exc.stderr, str) else "") + f"\nTIMEOUT after {timeout}s"
            rc = 124
        end = datetime.now(UTC).isoformat()
        stdout_path.write_text(stdout, encoding="utf-8")
        stderr_path.write_text(stderr, encoding="utf-8")
        rec = CommandRecord(
            stage=stage,
            command=list(command),
            cwd=str(cwd_path),
            start_time=start,
            end_time=end,
            exit_code=rc,
            stdout_log=str(stdout_path),
            stderr_log=str(stderr_path),
        )
        self.records.append(rec)
        with self.command_log.open("a", encoding="utf-8") as handle:
            handle.write(json.dumps(rec.to_dict(), sort_keys=True) + "\n")
        return rec


def fail_if_bad_command(record: CommandRecord, expected: str) -> None:
    stdout = Path(record.stdout_log).read_text(encoding="utf-8", errors="ignore") if record.stdout_log else ""
    stderr = Path(record.stderr_log).read_text(encoding="utf-8", errors="ignore") if record.stderr_log else ""
    text = f"{stdout}\n{stderr}"
    error_markers = (
        "RBT_FILE_READ_ERROR",
        "RBT_ERROR",
        "BAD_RECEPTOR_FILE",
        "Error opening",
        "Segmentation fault",
        "Fatal",
    )
    if record.exit_code == 0 and not any(marker.lower() in text.lower() for marker in error_markers):
        return
    raise RDockPipelineError(
        f"{expected} failed with exit code {record.exit_code}. Command: {' '.join(record.command)}. "
        f"See stdout log: {record.stdout_log}; stderr log: {record.stderr_log}. "
        f"Last diagnostic: {text.strip()[-1200:]}"
    )