"""Content-addressed snapshot and admission for the installed GPU environment."""

from __future__ import annotations

import importlib
import importlib.metadata
import json
import platform
import re
import sys
from pathlib import Path
from typing import Any

from ..atomic_io import atomic_write_json

_NORMALIZE_NAME = re.compile(r"[-_.]+")


def _name(value: str) -> str:
    return _NORMALIZE_NAME.sub("-", value).lower()


def installed_distributions() -> dict[str, str]:
    """Return every installed distribution as a canonical name/version map."""

    values: dict[str, str] = {}
    for distribution in importlib.metadata.distributions():
        raw_name = distribution.metadata.get("Name")
        if not raw_name:
            continue
        name = _name(str(raw_name))
        version = str(distribution.version)
        previous = values.get(name)
        if previous is not None and previous != version:
            raise RuntimeError(f"multiple installed versions for {name}: {previous}, {version}")
        values[name] = version
    return dict(sorted(values.items()))


def current_environment_snapshot() -> dict[str, Any]:
    """Capture Python, every wheel version, torch/CUDA, and visible GPU facts."""

    torch_record: dict[str, Any] | None = None
    try:
        torch = importlib.import_module("torch")
    except ImportError:
        torch = None
    if torch is not None:
        cuda = torch.cuda
        devices = []
        if bool(cuda.is_available()):
            for index in range(int(cuda.device_count())):
                properties = cuda.get_device_properties(index)
                devices.append(
                    {
                        "index": index,
                        "name": str(properties.name),
                        "capability": list(cuda.get_device_capability(index)),
                        "total_memory": int(properties.total_memory),
                    }
                )
        cudnn = getattr(torch.backends, "cudnn", None)
        torch_record = {
            "version": str(torch.__version__),
            "compiled_cuda": str(torch.version.cuda),
            "cudnn_version": int(cudnn.version())
            if cudnn is not None and cudnn.version() is not None
            else None,
            "cuda_available": bool(cuda.is_available()),
            "devices": devices,
        }
    return {
        "schema_version": 1,
        "kind": "training_environment_lock",
        "python": {
            "version": platform.python_version(),
            "implementation": platform.python_implementation(),
            "executable": str(Path(sys.executable).resolve()),
        },
        "platform": platform.platform(),
        "distributions": installed_distributions(),
        "torch": torch_record,
    }


def write_environment_snapshot(path: str | Path) -> dict[str, Any]:
    destination = Path(path)
    if destination.exists():
        raise FileExistsError(f"refusing to overwrite environment lock: {destination}")
    snapshot = current_environment_snapshot()
    atomic_write_json(destination, snapshot)
    return snapshot


def environment_lock_errors(path: str | Path) -> list[str]:
    """Compare the current process against an immutable environment snapshot."""

    source = Path(path)
    try:
        expected = json.loads(source.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError) as exc:
        return [f"cannot read training environment lock: {exc}"]
    if not isinstance(expected, dict) or expected.get("schema_version") != 1:
        return ["training environment lock must use schema_version=1"]
    if expected.get("kind") != "training_environment_lock":
        return ["environment lock has the wrong kind"]
    actual = current_environment_snapshot()
    errors: list[str] = []
    for field in ("python", "platform", "distributions", "torch"):
        if expected.get(field) != actual.get(field):
            errors.append(f"installed environment differs from lock field {field}")
    return errors