#!/usr/bin/env python3
"""Validate checksums and tensor invariants for this artifact bundle."""

from __future__ import annotations

import hashlib
import json
import math
from pathlib import Path


ROOT = Path(__file__).resolve().parent


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


def verify_manifest() -> None:
    manifest = json.loads((ROOT / "manifest.json").read_text())
    for relative, expected in manifest["files"].items():
        path = ROOT / relative
        if not path.is_file():
            raise AssertionError(f"missing file: {relative}")
        if path.stat().st_size != expected["bytes"]:
            raise AssertionError(f"size mismatch: {relative}")
        actual = sha256(path)
        if actual != expected["sha256"]:
            raise AssertionError(f"checksum mismatch: {relative}")
    print(f"Checksums OK: {len(manifest['files'])} files")


def load_tensor(path, torch):
    try:
        return torch.load(path, map_location="cpu", weights_only=True)
    except TypeError:
        return torch.load(path, map_location="cpu")


def verify_layer_bundle(path: Path, layers: list[int], hidden_size: int, torch) -> None:
    bundle = load_tensor(path, torch)
    if set(bundle) != {"raw", "unit", "norm"}:
        raise AssertionError(f"unexpected keys in {path}")
    for family in ("raw", "unit", "norm"):
        if set(bundle[family]) != set(layers):
            raise AssertionError(f"layer mismatch in {path}:{family}")
    for layer in layers:
        raw = bundle["raw"][layer].float()
        unit = bundle["unit"][layer].float()
        stored_norm = float(bundle["norm"][layer])
        if tuple(raw.shape) != (hidden_size,) or tuple(unit.shape) != (hidden_size,):
            raise AssertionError(f"shape mismatch in {path}, layer {layer}")
        actual_norm = float(raw.norm())
        if not math.isclose(actual_norm, stored_norm, rel_tol=1e-5, abs_tol=1e-5):
            raise AssertionError(f"raw norm mismatch in {path}, layer {layer}")
        if not math.isclose(float(unit.norm()), 1.0, rel_tol=1e-5, abs_tol=1e-5):
            raise AssertionError(f"unit norm mismatch in {path}, layer {layer}")
        if not torch.allclose(unit, raw / raw.norm(), rtol=1e-5, atol=1e-6):
            raise AssertionError(f"unit vector mismatch in {path}, layer {layer}")


def verify_tensors() -> None:
    try:
        import torch
    except ImportError:
        print("PyTorch not installed; skipped tensor-content validation")
        return

    for metadata_path in sorted(ROOT.glob("*/caa/metadata.json")):
        metadata = json.loads(metadata_path.read_text())
        verify_layer_bundle(
            metadata_path.parent / "caa.pt",
            metadata["vector"]["layers"],
            metadata["model"]["hidden_size"],
            torch,
        )

    # lat-pca, cs-grad and cs-lora all use the caa layer-bundle schema and name the file in
    # metadata, so one loop covers every arm that ships a per-layer bundle.
    for arm in ("lat-pca", "cs-grad", "cs-lora"):
        for metadata_path in sorted(ROOT.glob(f"*/{arm}/metadata.json")):
            metadata = json.loads(metadata_path.read_text())
            verify_layer_bundle(
                metadata_path.parent / metadata["vector"]["file"],
                metadata["vector"]["layers"],
                metadata["model"]["hidden_size"],
                torch,
            )

    for metadata_path in sorted(ROOT.glob("*/direction-ablation/metadata.json")):
        metadata = json.loads(metadata_path.read_text())
        direction = load_tensor(metadata_path.parent / "direction.pt", torch).float()
        expected_shape = (metadata["model"]["hidden_size"],)
        if tuple(direction.shape) != expected_shape:
            raise AssertionError(f"shape mismatch in {metadata_path.parent / 'direction.pt'}")
        expected_norm = metadata["selection"]["direction_norm"]
        if not math.isclose(float(direction.norm()), expected_norm, rel_tol=1e-5, abs_tol=1e-5):
            raise AssertionError(f"norm mismatch in {metadata_path.parent / 'direction.pt'}")

    print("Tensor contents OK")


if __name__ == "__main__":
    verify_manifest()
    verify_tensors()