date_game/scripts/validate_assets.py

#!/usr/bin/env python3
"""Validate generated character asset manifest and PNG files."""

from __future__ import annotations

import json
import struct
import sys
from pathlib import Path


ROOT = Path(__file__).resolve().parents[1]
DATA = ROOT / "data"
PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"


def load_json(path: Path) -> dict:
    with path.open("r", encoding="utf-8") as handle:
        return json.load(handle)


def fail(message: str) -> None:
    print(f"ERROR: {message}", file=sys.stderr)
    raise SystemExit(1)


def png_dimensions(path: Path) -> tuple[int, int]:
    with path.open("rb") as handle:
        signature = handle.read(8)
        if signature != PNG_SIGNATURE:
            fail(f"{path} is not a PNG file")

        length_bytes = handle.read(4)
        chunk_type = handle.read(4)
        if len(length_bytes) != 4 or chunk_type != b"IHDR":
            fail(f"{path} is missing a PNG IHDR chunk")

        length = struct.unpack(">I", length_bytes)[0]
        if length < 8:
            fail(f"{path} has an invalid PNG IHDR chunk")

        width, height = struct.unpack(">II", handle.read(8))
        return width, height


def validate_asset_image(path: Path, min_width: int, min_height: int, label: str) -> None:
    if not path.exists():
        fail(f"{label} asset is missing: {path}")

    width, height = png_dimensions(path)
    if width < min_width or height < min_height:
        fail(
            f"{label} asset is too small: "
            f"{width}x{height}, minimum {min_width}x{min_height}"
        )


def main() -> None:
    characters_doc = load_json(DATA / "characters.json")
    assets_doc = load_json(DATA / "character_assets.json")

    character_ids = [character["id"] for character in characters_doc["characters"]]
    character_id_set = set(character_ids)
    asset_entries = assets_doc["assets"]
    asset_ids = [entry["character_id"] for entry in asset_entries]

    if set(asset_ids) != character_id_set:
        missing = sorted(character_id_set.difference(asset_ids))
        extra = sorted(set(asset_ids).difference(character_id_set))
        fail(f"asset manifest mismatch; missing={missing}, extra={extra}")

    if len(asset_ids) != len(set(asset_ids)):
        fail("asset manifest contains duplicate character ids")

    minimum = assets_doc["minimum_dimensions"]
    min_width = minimum["width"]
    min_height = minimum["height"]
    accepted = 0

    reference = ROOT / assets_doc["style"]["reference"]
    if not reference.exists():
        fail(f"style reference is missing: {reference}")
    png_dimensions(reference)

    for alternate in assets_doc["style"].get("alternates", []):
        alternate_reference = ROOT / alternate["reference"]
        if not alternate_reference.exists():
            fail(f"alternate style reference is missing: {alternate_reference}")
        png_dimensions(alternate_reference)

    for entry in asset_entries:
        status = entry["status"]
        if status not in {"accepted", "needs_revision", "pending", "rejected"}:
            fail(f"{entry['character_id']} has invalid status {status}")

        if status not in {"accepted", "needs_revision"}:
            continue

        if status == "accepted":
            accepted += 1

        if "path" not in entry:
            fail(f"{entry['character_id']} has status {status} but no path")

        validate_asset_image(
            ROOT / entry["path"],
            min_width,
            min_height,
            entry["character_id"],
        )

    revision_count = sum(
        1 for entry in asset_entries if entry["status"] == "needs_revision"
    )

    date_cg_accepted = 0
    date_cg_revision_count = 0
    for cg_set in assets_doc.get("date_cgs", []):
        character_id = cg_set["character_id"]
        if character_id not in character_id_set:
            fail(f"date CG set references missing character id: {character_id}")

        if cg_set["status"] not in {"accepted", "partial", "needs_revision", "pending", "rejected"}:
            fail(f"{cg_set['set_id']} has invalid status {cg_set['status']}")

        previous_max = -1
        for tier in cg_set["tiers"]:
            status = tier["status"]
            if status not in {"accepted", "needs_revision", "pending", "rejected"}:
                fail(f"{cg_set['set_id']} tier has invalid status {status}")

            affection_min = tier["affection_min"]
            affection_max = tier["affection_max"]
            if affection_min <= previous_max:
                fail(f"{cg_set['set_id']} has overlapping affection tiers")
            if affection_max is not None and affection_max < affection_min:
                fail(f"{cg_set['set_id']} has an invalid affection tier range")
            previous_max = affection_max if affection_max is not None else affection_min

            path_value = tier.get("path")
            if status == "accepted":
                date_cg_accepted += 1
                if not path_value:
                    fail(f"{cg_set['set_id']} accepted tier lacks a path")
                validate_asset_image(
                    ROOT / path_value,
                    min_width,
                    min_height,
                    f"{cg_set['set_id']} affection {affection_min}",
                )
            elif status == "needs_revision":
                date_cg_revision_count += 1
                if path_value:
                    validate_asset_image(
                        ROOT / path_value,
                        min_width,
                        min_height,
                        f"{cg_set['set_id']} revision candidate {affection_min}",
                    )

    print(
        "Validated character asset manifest: "
        f"{accepted}/{len(asset_entries)} accepted, "
        f"{revision_count} needs revision, "
        f"{date_cg_accepted} accepted date CG tiers, "
        f"{date_cg_revision_count} date CG tiers need revision."
    )


if __name__ == "__main__":
    main()