#!/usr/bin/env python3
"""Verify the exact C11 replay environment and its native geospatial stack."""

from __future__ import annotations

import argparse
import hashlib
import importlib.metadata
import json
import platform
import re
import sys
import warnings
from pathlib import Path


ROOT = Path(__file__).resolve().parents[1]
ENV_DIR = ROOT / "release_tools/environments"
LOCK = ENV_DIR / "requirements-replay.lock.txt"
PYTHON_VERSION = (ENV_DIR / "python-replay.version").read_text(encoding="utf-8").strip()
EXPECTED_IMPLEMENTATION = "CPython"
EXPECTED_SYSTEM = "Linux"
EXPECTED_MACHINE = "x86_64"


def sha256(path: Path) -> str:
    return hashlib.sha256(path.read_bytes()).hexdigest()


def locked_versions(path: Path) -> dict[str, str]:
    versions: dict[str, str] = {}
    for line in path.read_text(encoding="utf-8").splitlines():
        match = re.match(r"^([A-Za-z0-9_.-]+)==([^ ;\\]+)", line)
        if match:
            versions[re.sub(r"[-_.]+", "-", match.group(1)).lower()] = match.group(2)
    if not versions:
        raise ValueError(f"no locked packages found in {path}")
    return versions


def installed_versions() -> dict[str, str]:
    return {
        re.sub(r"[-_.]+", "-", distribution.metadata["Name"]).lower(): distribution.version
        for distribution in importlib.metadata.distributions()
        if distribution.metadata.get("Name")
    }


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--output", type=Path)
    args = parser.parse_args()

    locked = locked_versions(LOCK)
    installed = installed_versions()
    actual_python = platform.python_version()
    actual_implementation = platform.python_implementation()
    actual_system = platform.system()
    actual_machine = platform.machine()
    missing = sorted(name for name in locked if name not in installed)
    mismatched = {
        name: {"expected": version, "actual": installed.get(name)}
        for name, version in locked.items()
        if installed.get(name) != version
    }
    unexpected = sorted(name for name in installed if name not in locked)

    with warnings.catch_warnings(record=True) as caught:
        warnings.simplefilter("error")
        import numpy as np
        import pyproj
        import rasterio
        import scipy
        from PIL import Image
        from rasterio.io import MemoryFile
        from scipy import ndimage
        from shapely.geometry import Polygon

        labels, components = ndimage.label(np.array([[1, 0], [0, 1]], dtype="uint8"))
        if components != 2 or labels.shape != (2, 2):
            raise AssertionError("SciPy connected-component smoke test failed")
        profile = {
            "driver": "GTiff",
            "height": 2,
            "width": 2,
            "count": 1,
            "dtype": "uint8",
            "nodata": 255,
            "transform": rasterio.transform.from_origin(0, 2, 1, 1),
            "crs": "EPSG:4326",
        }
        with MemoryFile() as memory:
            with memory.open(**profile) as dataset:
                dataset.write(np.array([[1, 0], [255, 1]], dtype="uint8"), 1)
            with memory.open() as dataset:
                if dataset.nodata != 255 or int((dataset.read(1) == 1).sum()) != 2:
                    raise AssertionError("Rasterio finite-nodata smoke test failed")
        if Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]).area != 1.0:
            raise AssertionError("Shapely geometry smoke test failed")
        x, y = pyproj.Transformer.from_crs(4326, 3857, always_xy=True).transform(0, 0)
        if abs(x) > 1e-9 or abs(y) > 1e-9:
            raise AssertionError("PyProj transform smoke test failed")
        with Image.new("RGB", (2, 2)) as image:
            if image.size != (2, 2):
                raise AssertionError("Pillow smoke test failed")

    platform_matches = (
        actual_implementation == EXPECTED_IMPLEMENTATION
        and actual_system == EXPECTED_SYSTEM
        and actual_machine == EXPECTED_MACHINE
    )

    report = {
        "schema_version": "geodisaster_replay_environment_v1",
        "ready": (
            actual_python == PYTHON_VERSION
            and platform_matches
            and not missing
            and not mismatched
            and not unexpected
        ),
        "python": {
            "expected": PYTHON_VERSION,
            "actual": actual_python,
            "expected_implementation": EXPECTED_IMPLEMENTATION,
            "implementation": actual_implementation,
            "executable": sys.executable,
        },
        "platform": {
            "expected_system": EXPECTED_SYSTEM,
            "system": actual_system,
            "expected_machine": EXPECTED_MACHINE,
            "machine": actual_machine,
            "matches": platform_matches,
            "release": platform.release(),
            "libc": platform.libc_ver(),
        },
        "lock": {
            "path": str(LOCK.relative_to(ROOT)),
            "sha256": sha256(LOCK),
            "packages": locked,
        },
        "installed_packages": installed,
        "missing_packages": missing,
        "mismatched_packages": mismatched,
        "unexpected_packages": unexpected,
        "native_libraries": {
            "gdal": rasterio.__gdal_version__,
            "proj": pyproj.proj_version_str,
            "geos": getattr(__import__("shapely"), "geos_version_string", None),
        },
        "compatibility_warnings": [str(item.message) for item in caught],
        "smoke_tests": {
            "numpy_scipy": "passed",
            "rasterio_finite_nodata": "passed",
            "shapely": "passed",
            "pyproj": "passed",
            "pillow": "passed",
        },
    }
    if args.output:
        args.output.parent.mkdir(parents=True, exist_ok=True)
        args.output.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n", encoding="utf-8")
    print(json.dumps(report, indent=2, sort_keys=True))
    if not report["ready"]:
        raise SystemExit(1)


if __name__ == "__main__":
    main()