//SPDX-License-Identifier: LGPL-3.0-only
//SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®

// GlbAsset::Load on a GLB built here in memory: the node hierarchy (TRS and
// matrix nodes), two primitives with two materials, an interleaved
// position/normal buffer view (strided accessors), normalized UV and weight
// accessors, generated indices, computed tangents, a skin's inverse-bind
// matrices, an embedded PNG and an extension kept in the raw JSON. A room as
// Blender exports one: a camera, KHR_lights_punctual lights, glowing and glass
// materials, and extras. Then the ways a file can be broken, which must come
// back as errors rather than crash: bad magic, truncation, a sparse accessor,
// an accessor past its view, a light that doesn't exist, a stride or count
// whose arithmetic wraps round to look in bounds, a skin's skeleton that
// doesn't exist, a chunk longer than the file, a path that isn't a file, an
// image wider than a texture's 16-bit size holds, and children that form a
// cycle. A chain 100,000 nodes deep loads in good time: the cycle check
// walked every node up to its root.
//
// With CRAFTER_ASSET_TEST_GLB pointing at a real skinned .glb (a rig exported
// from Blender, say), it also loads that and checks every joint's world
// matrix times its inverse-bind matrix is the identity in the rest pose,
// which is what a skinned mesh at rest relies on.

#include <cstdlib>
import Crafter.Asset;
import Crafter.Math;
import std;

using namespace Crafter;

namespace {

int failures = 0;

void Check(bool ok, std::string_view what) {
    std::println("{}  {}", ok ? "PASS" : "FAIL", what);
    if (!ok) ++failures;
}

bool Near(float a, float b, float epsilon = 1e-4f) {
    return std::abs(a - b) < epsilon;
}

// A 2x2 RGBA PNG: red, green, blue, and white with alpha 0.
constexpr std::array<std::uint8_t, 76> kPng = {
    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x08, 0x06, 0x00, 0x00, 0x00, 0x72, 0xb6, 0x0d,
    0x24, 0x00, 0x00, 0x00, 0x13, 0x49, 0x44, 0x41, 0x54, 0x78, 0xda, 0x63, 0xf8, 0xcf, 0xc0, 0xf0,
    0x1f, 0x0c, 0x81, 0x34, 0x08, 0x30, 0x00, 0x00, 0x48, 0xc9, 0x08, 0xf8, 0xc5, 0x34, 0xfd, 0x05,
    0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};

struct Writer {
    std::vector<std::byte> bytes;

    template <typename T>
    void Put(T value) {
        const auto* p = reinterpret_cast<const std::byte*>(&value);
        bytes.insert(bytes.end(), p, p + sizeof(T));
    }
    void Pad(std::size_t alignment, std::byte fill) {
        while (bytes.size() % alignment != 0) bytes.push_back(fill);
    }
};

// header + JSON chunk (space-padded) + BIN chunk (zero-padded), as the GLB
// container lays them out.
std::vector<std::byte> BuildGlb(std::string_view json, const std::vector<std::byte>& bin) {
    Writer jsonChunk;
    for (char c : json) jsonChunk.Put(c);
    jsonChunk.Pad(4, std::byte{' '});
    std::vector<std::byte> binPadded = bin;
    while (binPadded.size() % 4 != 0) binPadded.push_back(std::byte{0});

    Writer out;
    out.Put<std::uint32_t>(0x46546C67);  // "glTF"
    out.Put<std::uint32_t>(2);
    out.Put<std::uint32_t>(static_cast<std::uint32_t>(12 + 8 + jsonChunk.bytes.size() + 8 + binPadded.size()));
    out.Put<std::uint32_t>(static_cast<std::uint32_t>(jsonChunk.bytes.size()));
    out.Put<std::uint32_t>(0x4E4F534A);  // "JSON"
    out.bytes.insert(out.bytes.end(), jsonChunk.bytes.begin(), jsonChunk.bytes.end());
    out.Put<std::uint32_t>(static_cast<std::uint32_t>(binPadded.size()));
    out.Put<std::uint32_t>(0x004E4942);  // "BIN\0"
    out.bytes.insert(out.bytes.end(), binPadded.begin(), binPadded.end());
    return out.bytes;
}

std::vector<std::byte> FixtureBin() {
    Writer w;
    // bufferView 0, offset 0: interleaved position + normal, stride 24.
    const std::array<std::array<float, 3>, 3> positions = {{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}}};
    for (const auto& p : positions) {
        for (float f : p) w.Put(f);
        for (float f : {0.0f, 0.0f, 1.0f}) w.Put(f);
    }
    // bufferView 1, offset 72: TEXCOORD_0 as normalized u16.
    for (std::uint16_t u : {0, 0, 65535, 0, 0, 65535}) w.Put(u);
    // bufferView 2, offset 84: u8 indices.
    for (std::uint8_t i : {0, 1, 2}) w.Put(i);
    w.Pad(4, std::byte{0});
    // bufferView 3, offset 88: JOINTS_0 as u8.
    for (int v = 0; v < 3; ++v) for (std::uint8_t j : {0, 1, 0, 0}) w.Put(j);
    // bufferView 4, offset 100: WEIGHTS_0 as normalized u8 that don't sum to 255.
    for (int v = 0; v < 3; ++v) for (std::uint8_t j : {128, 64, 0, 0}) w.Put(j);
    // bufferView 5, offset 112: the second primitive's positions.
    for (float f : {0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f}) w.Put(f);
    // bufferView 6, offset 148: two inverse-bind matrices, column-major.
    for (float f : {1.0f, 0.0f, 0.0f, 0.0f,  0.0f, 1.0f, 0.0f, 0.0f,  0.0f, 0.0f, 1.0f, 0.0f,  0.0f, 0.0f, 0.0f, 1.0f}) w.Put(f);
    for (float f : {1.0f, 0.0f, 0.0f, 0.0f,  0.0f, 1.0f, 0.0f, 0.0f,  0.0f, 0.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f}) w.Put(f);
    // bufferView 7, offset 276: the PNG.
    for (std::uint8_t b : kPng) w.Put(b);
    return w.bytes;
}

std::string FixtureJson(std::string_view accessor6Extra = "", std::uint32_t accessor7Count = 2) {
    return std::format(R"({{
  "asset": {{"version": "2.0"}},
  "scene": 0,
  "scenes": [{{"nodes": [0]}}],
  "nodes": [
    {{"name": "Root", "children": [1], "mesh": 0, "skin": 0,
      "translation": [1, 2, 3], "rotation": [0, 0, 0.70710678, 0.70710678], "scale": [2, 2, 2]}},
    {{"name": "Child", "matrix": [1,0,0,0, 0,1,0,0, 0,0,1,0, 5,6,7,1]}}
  ],
  "meshes": [{{"name": "Mesh", "primitives": [
    {{"attributes": {{"POSITION": 0, "NORMAL": 1, "TEXCOORD_0": 2, "JOINTS_0": 4, "WEIGHTS_0": 5}}, "indices": 3, "material": 0}},
    {{"attributes": {{"POSITION": 6}}, "material": 1}}
  ]}}],
  "skins": [{{"name": "Skin", "joints": [0, 1], "inverseBindMatrices": 7}}],
  "materials": [
    {{"name": "Mat0", "pbrMetallicRoughness": {{"baseColorFactor": [0.5, 0.25, 1, 1], "metallicFactor": 0.1,
      "roughnessFactor": 0.7, "baseColorTexture": {{"index": 0}}}},
      "normalTexture": {{"index": 0, "scale": 0.5}}, "alphaMode": "MASK", "alphaCutoff": 0.3, "doubleSided": true}},
    {{"name": "Mat1"}}
  ],
  "textures": [{{"source": 0, "sampler": 0}}],
  "samplers": [{{"magFilter": 9728, "minFilter": 9729}}],
  "images": [{{"bufferView": 7, "mimeType": "image/png"}}],
  "accessors": [
    {{"bufferView": 0, "byteOffset": 0, "componentType": 5126, "count": 3, "type": "VEC3"}},
    {{"bufferView": 0, "byteOffset": 12, "componentType": 5126, "count": 3, "type": "VEC3"}},
    {{"bufferView": 1, "componentType": 5123, "normalized": true, "count": 3, "type": "VEC2"}},
    {{"bufferView": 2, "componentType": 5121, "count": 3, "type": "SCALAR"}},
    {{"bufferView": 3, "componentType": 5121, "count": 3, "type": "VEC4"}},
    {{"bufferView": 4, "componentType": 5121, "normalized": true, "count": 3, "type": "VEC4"}},
    {{"bufferView": 5, "componentType": 5126, "count": 3, "type": "VEC3"{}}},
    {{"bufferView": 6, "componentType": 5126, "count": {}, "type": "MAT4"}}
  ],
  "bufferViews": [
    {{"buffer": 0, "byteOffset": 0, "byteLength": 72, "byteStride": 24}},
    {{"buffer": 0, "byteOffset": 72, "byteLength": 12}},
    {{"buffer": 0, "byteOffset": 84, "byteLength": 3}},
    {{"buffer": 0, "byteOffset": 88, "byteLength": 12}},
    {{"buffer": 0, "byteOffset": 100, "byteLength": 12}},
    {{"buffer": 0, "byteOffset": 112, "byteLength": 36}},
    {{"buffer": 0, "byteOffset": 148, "byteLength": 128}},
    {{"buffer": 0, "byteOffset": 276, "byteLength": 76}}
  ],
  "buffers": [{{"byteLength": 352}}],
  "extensionsUsed": ["VRMC_springBone"],
  "extensions": {{"VRMC_springBone": {{"specVersion": "1.0"}}}}
}})", accessor6Extra, accessor7Count);
}

bool NearMatrix(const MatrixRowMajor<float, 4, 4, 1>& m, std::array<float, 16> expected) {
    const std::array<float, 16> got = m.Store();
    for (std::size_t i = 0; i < 16; ++i) {
        if (!Near(got[i], expected[i])) return false;
    }
    return true;
}

void TestFixture() {
    const std::vector<std::byte> glb = BuildGlb(FixtureJson(), FixtureBin());
    const std::expected<GlbAsset, std::string> loaded = GlbAsset::Load(glb);
    Check(loaded.has_value(), loaded.has_value() ? "the fixture loads" : std::format("the fixture loads: {}", loaded.error()));
    if (!loaded) return;
    const GlbAsset& a = *loaded;

    // Nodes and scene.
    Check(a.nodes.size() == 2 && a.nodes[0].name == "Root" && a.nodes[1].name == "Child", "two named nodes");
    Check(a.nodes[0].parent == -1 && a.nodes[1].parent == 0 && a.nodes[0].children == std::vector<std::uint32_t>{1},
          "parent and children links");
    Check(a.sceneRoots == std::vector<std::uint32_t>{0}, "the default scene's roots");
    const GlbNode& root = a.nodes[0];
    Check(!root.hasMatrix && Near(root.translation.x, 1) && Near(root.translation.y, 2) && Near(root.translation.z, 3)
          && Near(root.rotation.z, 0.70710678f) && Near(root.rotation.w, 0.70710678f) && Near(root.scale.y, 2),
          "TRS node");
    Check(root.mesh == 0 && root.skin == 0 && a.nodes[1].mesh == -1, "mesh and skin references");
    Check(a.nodes[1].hasMatrix && NearMatrix(a.nodes[1].matrix, {1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  5, 6, 7, 1}),
          "matrix node, translation in row 3");

    // Primitives.
    Check(a.meshes.size() == 1 && a.meshes[0].primitives.size() == 2, "one mesh with two primitives");
    if (a.meshes.size() != 1 || a.meshes[0].primitives.size() != 2) return;
    const GlbPrimitive& p0 = a.meshes[0].primitives[0];
    const GlbPrimitive& p1 = a.meshes[0].primitives[1];
    Check(p0.positions.size() == 3 && Near(p0.positions[1].x, 1) && Near(p0.positions[2].y, 1),
          "positions read through a strided view");
    Check(p0.normals.size() == 3 && Near(p0.normals[2].z, 1) && Near(p0.normals[0].x, 0), "normals read at their byte offset");
    Check(p0.uv0.size() == 3 && Near(p0.uv0[1].x, 1) && Near(p0.uv0[2].y, 1) && Near(p0.uv0[1].y, 0),
          "normalized u16 UVs");
    Check(p0.indices == std::vector<std::uint32_t>{0, 1, 2}, "u8 indices widened");
    Check(p0.joints.size() == 3 && p0.joints[0] == std::array<std::uint16_t, 4>{0, 1, 0, 0}, "u8 joints");
    Check(p0.weights.size() == 3 && Near(p0.weights[0][0], 2.0f / 3.0f) && Near(p0.weights[0][1], 1.0f / 3.0f),
          "normalized u8 weights, renormalized to sum 1");
    // glTF's v runs down the image, so the bitangent (normal map +Y, "up")
    // points along -v: here -Y, which is cross(normal, tangent) * -1.
    Check(p0.tangents.size() == 3 && Near(p0.tangents[0].x, 1) && Near(p0.tangents[0].y, 0)
          && Near(p0.tangents[0].z, 0) && Near(p0.tangents[0].w, -1),
          "tangents computed from the UVs, with glTF's bitangent sign");
    Check(p0.material == 0 && p1.material == 1, "primitive materials");
    Check(p1.positions.size() == 3 && Near(p1.positions[2].z, 1) && p1.indices == std::vector<std::uint32_t>{0, 1, 2},
          "a primitive without indices gets 0..n-1");
    Check(p1.normals.empty() && p1.tangents.empty() && p1.joints.empty(), "absent streams stay empty");

    // Skin.
    Check(a.skins.size() == 1 && a.skins[0].joints == std::vector<std::uint32_t>{0, 1}
          && a.skins[0].inverseBindMatrices.size() == 2
          && NearMatrix(a.skins[0].inverseBindMatrices[1], {1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  -1, 0, 0, 1}),
          "skin joints and inverse-bind matrices");

    // Materials, textures, images.
    Check(a.materials.size() == 2, "two materials");
    if (a.materials.size() == 2) {
        const GlbMaterial& m0 = a.materials[0];
        Check(Near(m0.baseColorFactor[1], 0.25f) && Near(m0.metallicFactor, 0.1f) && Near(m0.roughnessFactor, 0.7f)
              && m0.baseColorTexture.texture == 0 && m0.normalTexture.texture == 0 && Near(m0.normalTexture.scale, 0.5f)
              && m0.alphaMode == GlbAlphaMode::Mask && Near(m0.alphaCutoff, 0.3f) && m0.doubleSided,
              "material factors, textures and alpha mode");
        const GlbMaterial& m1 = a.materials[1];
        Check(Near(m1.metallicFactor, 1) && Near(m1.roughnessFactor, 1) && m1.baseColorTexture.texture == -1
              && m1.alphaMode == GlbAlphaMode::Opaque && !m1.doubleSided,
              "material defaults");
    }
    Check(a.textures.size() == 1 && a.textures[0].image == 0 && a.textures[0].sampler == 0, "texture source and sampler");
    Check(a.samplers.size() == 1 && a.samplers[0].magFilter == 9728 && a.samplers[0].minFilter == 9729, "sampler filters");
    Check(a.images.size() == 1 && a.images[0].sizeX == 2 && a.images[0].sizeY == 2 && a.images[0].pixels.size() == 4,
          "the embedded PNG decodes");
    if (a.images.size() == 1 && a.images[0].pixels.size() == 4) {
        const GlbRGBA8 first = a.images[0].pixels[0];
        Check(first.r == 255 && first.g == 0 && first.b == 0 && first.a == 255 && a.images[0].pixels[3].a == 0
              && a.images[0].opaque == OpaqueType::SemiOpaque,
              "image pixels and opacity");
    }
    Check(a.json.find("VRMC_springBone") != std::string::npos, "the raw JSON keeps extensions");
}

// What a room exported from Blender carries beyond meshes: a camera,
// KHR_lights_punctual lights, glowing and glass materials
// (KHR_materials_emissive_strength, _transmission, _ior), and the custom
// properties Blender writes as `extras` on the scene, nodes, materials and
// lights. The image is the fixture's PNG, at the same place in the buffer.
std::string RoomJson(std::string_view candleLight = "0") {
    return std::format(R"({{
  "asset": {{"version": "2.0"}},
  "scene": 0,
  "scenes": [{{"nodes": [0, 1, 2, 3, 4], "extras": {{"exposure": 1.5}}}}],
  "nodes": [
    {{"name": "Camera", "camera": 0, "translation": [0, 1.2, 1.5]}},
    {{"name": "Candle", "extensions": {{"KHR_lights_punctual": {{"light": {}}}}}, "extras": {{"flicker": 0.3}}}},
    {{"name": "Moon", "extensions": {{"KHR_lights_punctual": {{"light": 1}}}}}},
    {{"name": "Sun", "extensions": {{"KHR_lights_punctual": {{"light": 2}}}}}},
    {{"name": "Seat", "extras": {{"seat": true, "height": 1.6}}}}
  ],
  "cameras": [{{"name": "Webcam", "type": "perspective",
    "perspective": {{"yfov": 0.75, "aspectRatio": 1.7777778, "znear": 0.05, "zfar": 100}}}}],
  "extensionsUsed": ["KHR_lights_punctual", "KHR_materials_emissive_strength", "KHR_materials_transmission", "KHR_materials_ior"],
  "extensions": {{"KHR_lights_punctual": {{"lights": [
    {{"name": "CandleLight", "type": "point", "color": [1, 0.6, 0.3], "intensity": 5, "range": 4, "extras": {{"shadows": false}}}},
    {{"name": "MoonLight", "type": "spot", "intensity": 20, "spot": {{"innerConeAngle": 0.2, "outerConeAngle": 0.5}}}},
    {{"name": "SunLight", "type": "directional", "color": [0.5, 0.6, 1], "intensity": 0.8}}
  ]}}}},
  "materials": [
    {{"name": "Flame", "emissiveFactor": [1, 0.5, 0.1],
      "extensions": {{"KHR_materials_emissive_strength": {{"emissiveStrength": 8}}}}, "extras": {{"effect": "flicker"}}}},
    {{"name": "StainedGlass", "pbrMetallicRoughness": {{"baseColorTexture": {{"index": 0}}}},
      "extensions": {{"KHR_materials_transmission": {{"transmissionFactor": 0.9, "transmissionTexture": {{"index": 0}}}},
                     "KHR_materials_ior": {{"ior": 1.45}}}}}},
    {{"name": "Plain"}}
  ],
  "textures": [{{"source": 0}}],
  "images": [{{"bufferView": 0, "mimeType": "image/png"}}],
  "bufferViews": [{{"buffer": 0, "byteOffset": 276, "byteLength": 76}}],
  "buffers": [{{"byteLength": 352}}]
}})", candleLight);
}

void TestRoom() {
    const std::expected<GlbAsset, std::string> loaded = GlbAsset::Load(BuildGlb(RoomJson(), FixtureBin()));
    Check(loaded.has_value(), loaded.has_value() ? "the room fixture loads" : std::format("the room fixture loads: {}", loaded.error()));
    if (!loaded) return;
    const GlbAsset& a = *loaded;

    Check(a.cameras.size() == 1 && a.nodes[0].camera == 0 && a.nodes[1].camera == -1, "a node's camera");
    if (a.cameras.size() == 1) {
        const GlbCamera& c = a.cameras[0];
        Check(c.name == "Webcam" && !c.orthographic && Near(c.yfov, 0.75f) && Near(c.aspectRatio, 1.7777778f)
              && Near(c.znear, 0.05f) && Near(c.zfar, 100),
              "a perspective camera's field of view, aspect and clip planes");
    }

    Check(a.lights.size() == 3 && a.nodes[1].light == 0 && a.nodes[2].light == 1 && a.nodes[3].light == 2 && a.nodes[0].light == -1,
          "nodes' KHR_lights_punctual lights");
    if (a.lights.size() == 3) {
        const GlbLight& point = a.lights[0];
        Check(point.name == "CandleLight" && point.type == GlbLightType::Point && Near(point.color[1], 0.6f)
              && Near(point.intensity, 5) && Near(point.range, 4),
              "a point light's colour, intensity and range");
        const GlbLight& spot = a.lights[1];
        Check(spot.type == GlbLightType::Spot && Near(spot.innerConeAngle, 0.2f) && Near(spot.outerConeAngle, 0.5f)
              && Near(spot.color[0], 1) && Near(spot.range, 0),
              "a spot light's cone, with white and no range by default");
        const GlbLight& sun = a.lights[2];
        Check(sun.type == GlbLightType::Directional && Near(sun.intensity, 0.8f) && Near(sun.outerConeAngle, std::numbers::pi_v<float> / 4),
              "a directional light, the cone left at the extension's default");
        Check(point.extras == R"({"shadows":false})" && spot.extras.empty(), "a light's extras, as JSON text");
    }

    Check(a.materials.size() == 3, "three materials");
    if (a.materials.size() == 3) {
        const GlbMaterial& flame = a.materials[0];
        Check(Near(flame.emissiveStrength, 8) && Near(flame.emissiveFactor[1], 0.5f) && Near(flame.transmissionFactor, 0),
              "KHR_materials_emissive_strength");
        const GlbMaterial& glass = a.materials[1];
        Check(Near(glass.transmissionFactor, 0.9f) && glass.transmissionTexture.texture == 0 && Near(glass.ior, 1.45f),
              "KHR_materials_transmission with its texture, and KHR_materials_ior");
        const GlbMaterial& plain = a.materials[2];
        Check(Near(plain.emissiveStrength, 1) && Near(plain.transmissionFactor, 0) && plain.transmissionTexture.texture == -1
              && Near(plain.ior, 1.5f) && plain.extras.empty(),
              "the extensions' defaults where a material has none");
        Check(flame.extras == R"({"effect":"flicker"})", "a material's extras, as JSON text");
    }

    Check(a.nodes[1].extras == R"({"flicker":0.3})" && a.nodes[4].extras == R"({"height":1.6,"seat":true})" && a.nodes[0].extras.empty(),
          "nodes' extras, as JSON text");
    Check(a.extras == R"({"exposure":1.5})", "the default scene's extras, as JSON text");

    // A node may only name a light the extension defines.
    const auto missingLight = GlbAsset::Load(BuildGlb(RoomJson("7"), FixtureBin()));
    Check(!missingLight && missingLight.error().find("light") != std::string::npos, "a node naming a light that doesn't exist is an error");
}

// A grey PNG `width` by 1, its row stored without compression: big-endian
// chunks with their CRCs, and zlib's stored blocks with its Adler-32.
std::vector<std::byte> WidePng(std::uint32_t width) {
    std::vector<std::uint8_t> row(1 + width, 128);
    row[0] = 0;  // no filter
    std::vector<std::uint8_t> zlib = {0x78, 0x01};
    for (std::size_t at = 0; at < row.size();) {
        const std::size_t n = std::min<std::size_t>(65535, row.size() - at);
        zlib.push_back(at + n == row.size() ? 1 : 0);
        for (std::uint16_t v : {static_cast<std::uint16_t>(n), static_cast<std::uint16_t>(~n)}) {
            zlib.push_back(static_cast<std::uint8_t>(v));
            zlib.push_back(static_cast<std::uint8_t>(v >> 8));
        }
        zlib.insert(zlib.end(), row.begin() + static_cast<std::ptrdiff_t>(at), row.begin() + static_cast<std::ptrdiff_t>(at + n));
        at += n;
    }
    std::uint32_t a = 1, b = 0;
    for (std::uint8_t c : row) {
        a = (a + c) % 65521;
        b = (b + a) % 65521;
    }
    std::vector<std::uint8_t> png = {0x89, 'P', 'N', 'G', '\r', '\n', 0x1A, '\n'};
    auto be32 = [](std::vector<std::uint8_t>& out, std::uint32_t v) {
        for (int shift = 24; shift >= 0; shift -= 8) out.push_back(static_cast<std::uint8_t>(v >> shift));
    };
    be32(zlib, (b << 16) | a);
    auto chunk = [&](const char* type, const std::vector<std::uint8_t>& data) {
        be32(png, static_cast<std::uint32_t>(data.size()));
        std::vector<std::uint8_t> typed(type, type + 4);
        typed.insert(typed.end(), data.begin(), data.end());
        std::uint32_t crc = 0xFFFFFFFF;
        for (std::uint8_t byte : typed) {
            crc ^= byte;
            for (int k = 0; k < 8; ++k) crc = (crc >> 1) ^ (0xEDB88320 & (0 - (crc & 1)));
        }
        png.insert(png.end(), typed.begin(), typed.end());
        be32(png, ~crc);
    };
    std::vector<std::uint8_t> header;
    be32(header, width);
    be32(header, 1);
    header.insert(header.end(), {8, 0, 0, 0, 0});  // 8-bit grey
    chunk("IHDR", header);
    chunk("IDAT", zlib);
    chunk("IEND", {});
    std::vector<std::byte> out(png.size());
    std::memcpy(out.data(), png.data(), png.size());
    return out;
}

void TestBrokenFiles() {
    std::vector<std::byte> glb = BuildGlb(FixtureJson(), FixtureBin());

    std::vector<std::byte> badMagic = glb;
    badMagic[0] = std::byte{'X'};
    const auto magic = GlbAsset::Load(badMagic);
    Check(!magic && magic.error().find("magic") != std::string::npos, "bad magic is an error");

    const std::vector<std::byte> truncated(glb.begin(), glb.begin() + static_cast<std::ptrdiff_t>(glb.size() / 2));
    Check(!GlbAsset::Load(truncated), "a truncated file is an error");

    const auto sparse = GlbAsset::Load(BuildGlb(
        FixtureJson(R"(, "sparse": {"count": 1, "indices": {"bufferView": 2, "componentType": 5121}, "values": {"bufferView": 5}})"),
        FixtureBin()));
    Check(!sparse && sparse.error().find("sparse") != std::string::npos, "a sparse accessor is an error");

    const auto outside = GlbAsset::Load(BuildGlb(FixtureJson("", 3), FixtureBin()));
    Check(!outside && outside.error().find("bufferView") != std::string::npos, "an accessor past its buffer view is an error");

    Check(!GlbAsset::Load(std::filesystem::path("/nonexistent/file.glb")), "a missing file is an error");

    // The fixture's JSON with each `from` replaced by its `to`.
    auto with = [](std::initializer_list<std::pair<std::string_view, std::string_view>> changes) {
        std::string json = FixtureJson();
        for (const auto& [from, to] : changes) json.replace(json.find(from), from.size(), to);
        return BuildGlb(json, FixtureBin());
    };
    // Accessor 0 reads the interleaved view: 3 elements, 24 bytes apart. An
    // offset and a negative stride that wrap round to land in bounds.
    const auto wrappedStride = GlbAsset::Load(with({{R"("byteStride": 24)", R"("byteStride": -4096)"},
                                                    {R"({"bufferView": 0, "byteOffset": 0,)", R"({"bufferView": 0, "byteOffset": 8192,)"}}));
    Check(!wrappedStride, "a negative byteStride is an error, however the offsets add up");
    // A count whose elements' 24-byte strides wrap round to nothing.
    const auto wrappedCount = GlbAsset::Load(with({{R"({"bufferView": 0, "byteOffset": 0, "componentType": 5126, "count": 3,)",
                                                    R"({"bufferView": 0, "byteOffset": 0, "componentType": 5126, "count": 2305843009213693953,)"}}));
    Check(!wrappedCount, "a count too large for its view is an error, however its size wraps");
    const auto skeleton = GlbAsset::Load(with({{R"("joints": [0, 1],)", R"("joints": [0, 1], "skeleton": 99,)"}}));
    Check(!skeleton && skeleton.error().find("skeleton") != std::string::npos, "a skin's skeleton that doesn't exist is an error");
    Check(!GlbAsset::Load(std::filesystem::temp_directory_path()), "a directory is an error");

    // The first chunk's length, past the end of the file; on a 32-bit build
    // its sum with the offset wraps round to a small number.
    std::vector<std::byte> longChunk = glb;
    const std::uint32_t huge = 0xFFFFFFF0;
    std::memcpy(longChunk.data() + 12, &huge, sizeof(huge));
    Check(!GlbAsset::Load(longChunk), "a chunk longer than the file is an error");

    // Nodes alone: a cycle, and a long chain.
    auto nodesOnly = [](std::string_view nodes) {
        return BuildGlb(std::format(R"({{"asset": {{"version": "2.0"}}, "nodes": [{}]}})", nodes), {});
    };
    const auto cycle = GlbAsset::Load(nodesOnly(R"({"children": [1]}, {"children": [2]}, {"children": [0]})"));
    Check(!cycle && cycle.error().find("cycle") != std::string::npos, "children that form a cycle are an error");
    constexpr std::size_t kChain = 100000;
    std::string chain;
    for (std::size_t i = 0; i + 1 < kChain; ++i) chain += std::format(R"({{"children": [{}]}},)", i + 1);
    chain += "{}";
    const auto started = std::chrono::steady_clock::now();
    const auto deep = GlbAsset::Load(nodesOnly(chain));
    const auto took = std::chrono::steady_clock::now() - started;
    Check(deep && deep->nodes.size() == kChain && deep->nodes.back().parent == static_cast<std::int32_t>(kChain - 2),
          deep ? "a chain 100,000 nodes deep loads, each its parent's child" : std::format("a chain 100,000 nodes deep loads: {}", deep.error()));
    Check(took < std::chrono::seconds(2), std::format("in good time ({} ms)", std::chrono::duration_cast<std::chrono::milliseconds>(took).count()));

    const auto narrow = TextureAsset<GlbRGBA8>::LoadPNGFromMemory<std::uint8_t>(WidePng(16));
    Check(narrow && narrow->sizeX == 16 && narrow->sizeY == 1, "the test's PNG decodes");
    const auto wide = TextureAsset<GlbRGBA8>::LoadPNGFromMemory<std::uint8_t>(WidePng(70000));
    Check(!wide, wide ? std::format("an image 70000 wide is an error, not {} wide", wide->sizeX) : "an image 70000 wide is an error");
}

// Column-major 4x4 helpers for the rest-pose check, kept separate from the
// matrix types under test.
using Mat = std::array<float, 16>;

Mat Multiply(const Mat& a, const Mat& b) {
    Mat r{};
    for (int col = 0; col < 4; ++col) {
        for (int row = 0; row < 4; ++row) {
            float sum = 0;
            for (int k = 0; k < 4; ++k) sum += a[k * 4 + row] * b[col * 4 + k];
            r[col * 4 + row] = sum;
        }
    }
    return r;
}

Mat LocalMatrix(const GlbNode& node) {
    if (node.hasMatrix) return node.matrix.Store();  // rows of the row-major copy are glTF's columns
    const float x = node.rotation.x, y = node.rotation.y, z = node.rotation.z, w = node.rotation.w;
    const float sx = node.scale.x, sy = node.scale.y, sz = node.scale.z;
    return {
        (1 - 2 * (y * y + z * z)) * sx, (2 * (x * y + w * z)) * sx,     (2 * (x * z - w * y)) * sx,     0,
        (2 * (x * y - w * z)) * sy,     (1 - 2 * (x * x + z * z)) * sy, (2 * (y * z + w * x)) * sy,     0,
        (2 * (x * z + w * y)) * sz,     (2 * (y * z - w * x)) * sz,     (1 - 2 * (x * x + y * y)) * sz, 0,
        node.translation.x,             node.translation.y,             node.translation.z,             1,
    };
}

void TestRealFile(const char* path) {
    const auto loaded = GlbAsset::Load(std::filesystem::path(path));
    Check(loaded.has_value(), loaded ? std::format("{} loads", path) : std::format("{} loads: {}", path, loaded.error()));
    if (!loaded) return;
    const GlbAsset& a = *loaded;

    std::size_t vertices = 0;
    bool streamsMatch = true;
    bool indicesValid = true;
    for (const GlbMesh& mesh : a.meshes) {
        for (const GlbPrimitive& p : mesh.primitives) {
            vertices += p.positions.size();
            streamsMatch = streamsMatch && p.normals.size() == p.positions.size()
                && (p.joints.empty() || (p.joints.size() == p.positions.size() && p.weights.size() == p.positions.size()));
            indicesValid = indicesValid && p.indices.size() % 3 == 0
                && std::ranges::all_of(p.indices, [&](std::uint32_t i) { return i < p.positions.size(); });
        }
    }
    std::println("      {} meshes, {} vertices, {} nodes, {} skins ({} joints), {} materials, {} images",
                 a.meshes.size(), vertices, a.nodes.size(), a.skins.size(),
                 a.skins.empty() ? 0 : a.skins[0].joints.size(), a.materials.size(), a.images.size());
    Check(streamsMatch, "every vertex stream has one entry per vertex");
    Check(indicesValid, "every index list is whole triangles of valid vertices");
    Check(std::ranges::all_of(a.images, [](const auto& image) { return image.sizeX > 0 && image.pixels.size() == std::size_t(image.sizeX) * image.sizeY; }),
          "every image decodes");

    // World matrices by walking down from the roots, then world * inverseBind
    // per joint.
    std::vector<Mat> world(a.nodes.size());
    std::function<void(std::uint32_t, const Mat&)> walk = [&](std::uint32_t node, const Mat& parent) {
        world[node] = Multiply(parent, LocalMatrix(a.nodes[node]));
        for (std::uint32_t child : a.nodes[node].children) walk(child, world[node]);
    };
    const Mat identity = {1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  0, 0, 0, 1};
    for (std::uint32_t r = 0; r < a.nodes.size(); ++r) {
        if (a.nodes[r].parent == -1) walk(r, identity);
    }
    for (const GlbSkin& skin : a.skins) {
        float worst = 0;
        for (std::size_t j = 0; j < skin.joints.size(); ++j) {
            const Mat bound = Multiply(world[skin.joints[j]], skin.inverseBindMatrices[j].Store());
            for (std::size_t i = 0; i < 16; ++i) worst = std::max(worst, std::abs(bound[i] - identity[i]));
        }
        Check(worst < 1e-3f, std::format("skin '{}': world * inverseBind is the identity at rest (worst {})", skin.name, worst));
    }
}

} // namespace

int main() {
    TestFixture();
    TestRoom();
    TestBrokenFiles();
    if (const char* real = std::getenv("CRAFTER_ASSET_TEST_GLB")) {
        TestRealFile(real);
    } else {
        std::println("SKIP  real-file check (set CRAFTER_ASSET_TEST_GLB to a skinned .glb)");
    }
    std::println("{}", failures == 0 ? "all checks passed" : "check(s) failed");
    return failures == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}