"""Fixture registry loading and manifest verification.

The registry is metadata, not result data: fixture ids, seeds, generator

versions, hosting, and expected manifests are committed so rows can later

point to reproducible fixture identity without committing generated bytes.

"""

from __future__ import annotations

import hashlib

import json

from dataclasses import dataclass

from pathlib import Path

from typing import Any

ROOT = Path(__file__).resolve().parents[2]

DEFAULT_FIXTURE_REGISTRY = ROOT / "config" / "fixtures.json"

@dataclass(frozen=True)

class FixtureSpec:

    fixture_id: str

    generator: str

    version: str

    seed: str

    description: str

    manifest: str | None

    license: str

    hosting: tuple[str, ...]

    status: str = "active"

    def row_fields(self) -> dict[str, Any]:

        return {

            "fixture_id": self.fixture_id,

            "fixture_generator": self.generator,

            "fixture_version": self.version,

            "fixture_seed": self.seed,

            "fixture_manifest_sha256": self.manifest,

        }

def load_fixture_registry(path: Path = DEFAULT_FIXTURE_REGISTRY) -> dict[str, FixtureSpec]:

    raw = json.loads(path.read_text())

    if raw.get("schema_version") != 1:

        raise ValueError(f"unsupported fixture registry schema_version: {raw.get('schema_version')!r}")

    fixtures = raw.get("fixtures")

    if not isinstance(fixtures, dict):

        raise ValueError("fixture registry requires an object-valued 'fixtures' key")

    return {fixture_id: _parse_fixture(fixture_id, data) for fixture_id, data in fixtures.items()}

def _parse_fixture(fixture_id: str, data: dict[str, Any]) -> FixtureSpec:

    missing = [

        key

        for key in ("generator", "version", "seed", "description", "license", "hosting")

        if key not in data

    ]

    if missing:

        raise ValueError(f"fixture {fixture_id!r} missing required keys: {', '.join(missing)}")

    hosting = data["hosting"]

    if not isinstance(hosting, list) or not all(isinstance(item, str) for item in hosting):

        raise ValueError(f"fixture {fixture_id!r} hosting must be a list of strings")

    manifest = data.get("manifest")

    if manifest is not None and (

        not isinstance(manifest, str) or len(manifest) != 64 or any(ch not in "0123456789abcdef" for ch in manifest)

    ):

        raise ValueError(f"fixture {fixture_id!r} manifest must be a lowercase sha256 hex string or null")

    return FixtureSpec(

        fixture_id=fixture_id,

        generator=str(data["generator"]),

        version=str(data["version"]),

        seed=str(data["seed"]),

        description=str(data["description"]),

        manifest=manifest,

        license=str(data["license"]),

        hosting=tuple(hosting),

        status=str(data.get("status", "active")),

    )

def tree_manifest_sha256(root: Path) -> str:

    """Hash paths, file modes, and file contents under ``root`` deterministically."""

    digest = hashlib.sha256()

    for path in sorted(item for item in root.rglob("*") if item.is_file()):

        rel = path.relative_to(root).as_posix()

        mode = path.stat().st_mode & 0o777

        digest.update(f"{rel}\0{mode:o}\0".encode("utf-8"))

        with path.open("rb") as fh:

            for chunk in iter(lambda: fh.read(1024 * 1024), b""):

                digest.update(chunk)

        digest.update(b"\0")

    return digest.hexdigest()

def verify_fixture(spec: FixtureSpec, root: Path) -> tuple[str, str | None]:

    """Verify a fixture tree against the spec's pinned manifest.

    Returns ``(status, actual_manifest)`` where status is one of:

    - ``"verified"``: manifest is pinned and the tree hash matches it.

    - ``"unverifiable:manifest_null"``: the tree exists and is non-empty but

      the registry pins no manifest; nothing can be verified (null means

      unmeasured, never a silent pass).

    - ``"failed:<reason>"``: the tree is missing (``path_missing``), not a

      directory (``not_a_directory``), empty (``tree_empty``), or its hash

      does not match the pinned manifest (``manifest_mismatch``).

    ``actual_manifest`` is ``None`` whenever no meaningful tree hash exists

    (missing, non-directory, or empty roots).

    """

    if not root.exists():

        return "failed:path_missing", None

    if not root.is_dir():

        return "failed:not_a_directory", None

    if not any(item.is_file() for item in root.rglob("*")):

        return "failed:tree_empty", None

    actual = tree_manifest_sha256(root)

    if spec.manifest is None:

        return "unverifiable:manifest_null", actual

    if actual == spec.manifest:

        return "verified", actual

    return "failed:manifest_mismatch", actual