#include <XCEngine/Resources/BuiltinResources.h>

#include <XCEngine/Core/Math/Bounds.h>
#include <XCEngine/Core/Math/Vector2.h>
#include <XCEngine/Core/Math/Vector3.h>
#include <XCEngine/Core/Asset/ResourceManager.h>
#include <XCEngine/Resources/Material/Material.h>
#include <XCEngine/Resources/Mesh/Mesh.h>
#include <XCEngine/Resources/Shader/Shader.h>
#include <XCEngine/Resources/Shader/ShaderLoader.h>
#include <XCEngine/Resources/Texture/Texture.h>

#include <algorithm>
#include <cmath>
#include <filesystem>
#include <system_error>
#include <vector>

namespace XCEngine {
namespace Resources {

namespace {

constexpr const char* kBuiltinPrefix = "builtin://";
constexpr const char* kBuiltinMeshPrefix = "builtin://meshes/";
constexpr const char* kBuiltinMaterialPrefix = "builtin://materials/";
constexpr const char* kBuiltinShaderPrefix = "builtin://shaders/";
constexpr const char* kBuiltinTexturePrefix = "builtin://textures/";
constexpr const char* kBuiltinDefaultPrimitiveMaterialPath = "builtin://materials/default-primitive";
constexpr const char* kBuiltinForwardLitShaderPath = "builtin://shaders/forward-lit";
constexpr const char* kBuiltinUnlitShaderPath = "builtin://shaders/unlit";
constexpr const char* kBuiltinDepthOnlyShaderPath = "builtin://shaders/depth-only";
constexpr const char* kBuiltinShadowCasterShaderPath = "builtin://shaders/shadow-caster";
constexpr const char* kBuiltinObjectIdShaderPath = "builtin://shaders/object-id";
constexpr const char* kBuiltinSkyboxShaderPath = "builtin://shaders/skybox";
constexpr const char* kBuiltinColorScalePostProcessShaderPath =
    "builtin://shaders/color-scale-post-process";
constexpr const char* kBuiltinDefaultPrimitiveTexturePath = "builtin://textures/default-primitive-albedo";
constexpr float kPi = 3.14159265358979323846f;

struct MeshBuffers {
    std::vector<StaticMeshVertex> vertices;
    std::vector<Core::uint32> indices;
};

size_t CalculateBuiltinShaderMemorySize(const Shader& shader);

constexpr const char* kBuiltinForwardLitShaderManifestRelativePath =
    "engine/assets/builtin/shaders/forward-lit/forward-lit.shader";
constexpr const char* kBuiltinUnlitShaderManifestRelativePath =
    "engine/assets/builtin/shaders/unlit/unlit.shader";
constexpr const char* kBuiltinDepthOnlyShaderManifestRelativePath =
    "engine/assets/builtin/shaders/depth-only/depth-only.shader";
constexpr const char* kBuiltinShadowCasterShaderManifestRelativePath =
    "engine/assets/builtin/shaders/shadow-caster/shadow-caster.shader";
constexpr const char* kBuiltinObjectIdShaderManifestRelativePath =
    "engine/assets/builtin/shaders/object-id/object-id.shader";
constexpr const char* kBuiltinSkyboxShaderManifestRelativePath =
    "engine/assets/builtin/shaders/skybox/skybox.shader";
constexpr const char* kBuiltinColorScalePostProcessShaderManifestRelativePath =
    "engine/assets/builtin/shaders/color-scale-post-process/color-scale-post-process.shader";

Containers::String NormalizeBuiltinAssetPath(const std::filesystem::path& path) {
    return Containers::String(path.lexically_normal().generic_string().c_str());
}

bool TryResolveBuiltinAssetPathFromAnchor(
    const std::filesystem::path& anchor,
    const std::filesystem::path& relativePath,
    std::filesystem::path& outPath) {
    if (anchor.empty()) {
        return false;
    }

    std::error_code ec;
    std::filesystem::path current = anchor.lexically_normal();
    if (std::filesystem::is_regular_file(current, ec)) {
        current = current.parent_path();
    }

    while (!current.empty()) {
        const std::filesystem::path candidate = (current / relativePath).lexically_normal();
        if (std::filesystem::exists(candidate, ec)) {
            outPath = candidate;
            return true;
        }

        const std::filesystem::path parent = current.parent_path();
        if (parent == current) {
            break;
        }
        current = parent;
    }

    return false;
}

bool TryResolveBuiltinShaderManifestPath(
    const std::filesystem::path& relativePath,
    Containers::String& outPath) {
    std::filesystem::path resolvedPath;
    std::error_code ec;

    if (TryResolveBuiltinAssetPathFromAnchor(std::filesystem::current_path(ec), relativePath, resolvedPath)) {
        outPath = NormalizeBuiltinAssetPath(resolvedPath);
        return true;
    }

    const Containers::String& resourceRoot = ResourceManager::Get().GetResourceRoot();
    if (!resourceRoot.Empty() &&
        TryResolveBuiltinAssetPathFromAnchor(std::filesystem::path(resourceRoot.CStr()), relativePath, resolvedPath)) {
        outPath = NormalizeBuiltinAssetPath(resolvedPath);
        return true;
    }

    if (TryResolveBuiltinAssetPathFromAnchor(std::filesystem::path(__FILE__), relativePath, resolvedPath)) {
        outPath = NormalizeBuiltinAssetPath(resolvedPath);
        return true;
    }

    return false;
}

const char* GetBuiltinShaderManifestRelativePath(const Containers::String& builtinShaderPath) {
    if (builtinShaderPath == Containers::String(kBuiltinForwardLitShaderPath)) {
        return kBuiltinForwardLitShaderManifestRelativePath;
    }
    if (builtinShaderPath == Containers::String(kBuiltinUnlitShaderPath)) {
        return kBuiltinUnlitShaderManifestRelativePath;
    }
    if (builtinShaderPath == Containers::String(kBuiltinDepthOnlyShaderPath)) {
        return kBuiltinDepthOnlyShaderManifestRelativePath;
    }
    if (builtinShaderPath == Containers::String(kBuiltinShadowCasterShaderPath)) {
        return kBuiltinShadowCasterShaderManifestRelativePath;
    }
    if (builtinShaderPath == Containers::String(kBuiltinObjectIdShaderPath)) {
        return kBuiltinObjectIdShaderManifestRelativePath;
    }
    if (builtinShaderPath == Containers::String(kBuiltinSkyboxShaderPath)) {
        return kBuiltinSkyboxShaderManifestRelativePath;
    }
    if (builtinShaderPath == Containers::String(kBuiltinColorScalePostProcessShaderPath)) {
        return kBuiltinColorScalePostProcessShaderManifestRelativePath;
    }

    return nullptr;
}

bool TryResolveBuiltinShaderManifestPath(
    const Containers::String& builtinShaderPath,
    Containers::String& outPath) {
    const char* relativePath = GetBuiltinShaderManifestRelativePath(builtinShaderPath);
    if (relativePath == nullptr) {
        return false;
    }

    return TryResolveBuiltinShaderManifestPath(std::filesystem::path(relativePath), outPath);
}

Shader* LoadBuiltinShaderFromManifest(
    const Containers::String& builtinPath,
    const Containers::String& manifestPath) {
    ShaderLoader shaderLoader;
    LoadResult result = shaderLoader.Load(manifestPath);
    if (!result || result.resource == nullptr) {
        return nullptr;
    }

    auto* shader = static_cast<Shader*>(result.resource);
    shader->m_path = builtinPath;
    shader->m_guid = ResourceGUID::Generate(builtinPath);
    shader->m_memorySize = CalculateBuiltinShaderMemorySize(*shader);
    return shader;
}

Shader* TryLoadBuiltinShaderFromManifest(const Containers::String& builtinPath) {
    Containers::String manifestPath;
    if (!TryResolveBuiltinShaderManifestPath(builtinPath, manifestPath)) {
        return nullptr;
    }

    return LoadBuiltinShaderFromManifest(builtinPath, manifestPath);
}

Math::Bounds ComputeBounds(const std::vector<StaticMeshVertex>& vertices) {
    if (vertices.empty()) {
        return Math::Bounds();
    }

    Math::Vector3 min = vertices.front().position;
    Math::Vector3 max = vertices.front().position;
    for (const StaticMeshVertex& vertex : vertices) {
        min.x = std::min(min.x, vertex.position.x);
        min.y = std::min(min.y, vertex.position.y);
        min.z = std::min(min.z, vertex.position.z);
        max.x = std::max(max.x, vertex.position.x);
        max.y = std::max(max.y, vertex.position.y);
        max.z = std::max(max.z, vertex.position.z);
    }

    Math::Bounds bounds;
    bounds.SetMinMax(min, max);
    return bounds;
}

StaticMeshVertex MakeVertex(
    const Math::Vector3& position,
    const Math::Vector3& normal,
    const Math::Vector3& tangent,
    const Math::Vector2& uv) {
    StaticMeshVertex vertex;
    vertex.position = position;
    vertex.normal = normal.Normalized();
    vertex.tangent = tangent.Normalized();
    vertex.bitangent = Math::Vector3::Cross(vertex.normal, vertex.tangent).Normalized();
    vertex.uv0 = uv;
    return vertex;
}

void AppendQuad(
    MeshBuffers& buffers,
    const Math::Vector3& bottomLeft,
    const Math::Vector3& bottomRight,
    const Math::Vector3& topRight,
    const Math::Vector3& topLeft,
    const Math::Vector3& normal,
    const Math::Vector3& tangent) {
    const Core::uint32 baseIndex = static_cast<Core::uint32>(buffers.vertices.size());
    buffers.vertices.push_back(MakeVertex(bottomLeft, normal, tangent, Math::Vector2(0.0f, 0.0f)));
    buffers.vertices.push_back(MakeVertex(bottomRight, normal, tangent, Math::Vector2(1.0f, 0.0f)));
    buffers.vertices.push_back(MakeVertex(topRight, normal, tangent, Math::Vector2(1.0f, 1.0f)));
    buffers.vertices.push_back(MakeVertex(topLeft, normal, tangent, Math::Vector2(0.0f, 1.0f)));

    buffers.indices.push_back(baseIndex + 0);
    buffers.indices.push_back(baseIndex + 1);
    buffers.indices.push_back(baseIndex + 2);
    buffers.indices.push_back(baseIndex + 0);
    buffers.indices.push_back(baseIndex + 2);
    buffers.indices.push_back(baseIndex + 3);
}

void FlipTriangleWinding(MeshBuffers& buffers) {
    for (size_t index = 0; index + 2 < buffers.indices.size(); index += 3) {
        std::swap(buffers.indices[index + 1], buffers.indices[index + 2]);
    }
}

MeshBuffers CreateCubeMeshBuffers() {
    MeshBuffers buffers;
    const float half = 0.5f;

    AppendQuad(
        buffers,
        Math::Vector3(-half, -half, half),
        Math::Vector3(half, -half, half),
        Math::Vector3(half, half, half),
        Math::Vector3(-half, half, half),
        Math::Vector3::Forward(),
        Math::Vector3::Right());
    AppendQuad(
        buffers,
        Math::Vector3(half, -half, -half),
        Math::Vector3(-half, -half, -half),
        Math::Vector3(-half, half, -half),
        Math::Vector3(half, half, -half),
        Math::Vector3::Back(),
        Math::Vector3::Left());
    AppendQuad(
        buffers,
        Math::Vector3(-half, -half, -half),
        Math::Vector3(-half, -half, half),
        Math::Vector3(-half, half, half),
        Math::Vector3(-half, half, -half),
        Math::Vector3::Left(),
        Math::Vector3::Forward());
    AppendQuad(
        buffers,
        Math::Vector3(half, -half, half),
        Math::Vector3(half, -half, -half),
        Math::Vector3(half, half, -half),
        Math::Vector3(half, half, half),
        Math::Vector3::Right(),
        Math::Vector3::Back());
    AppendQuad(
        buffers,
        Math::Vector3(-half, half, half),
        Math::Vector3(half, half, half),
        Math::Vector3(half, half, -half),
        Math::Vector3(-half, half, -half),
        Math::Vector3::Up(),
        Math::Vector3::Right());
    AppendQuad(
        buffers,
        Math::Vector3(-half, -half, -half),
        Math::Vector3(half, -half, -half),
        Math::Vector3(half, -half, half),
        Math::Vector3(-half, -half, half),
        Math::Vector3::Down(),
        Math::Vector3::Right());

    return buffers;
}

MeshBuffers CreateQuadMeshBuffers() {
    MeshBuffers buffers;
    AppendQuad(
        buffers,
        Math::Vector3(-0.5f, -0.5f, 0.0f),
        Math::Vector3(0.5f, -0.5f, 0.0f),
        Math::Vector3(0.5f, 0.5f, 0.0f),
        Math::Vector3(-0.5f, 0.5f, 0.0f),
        Math::Vector3::Forward(),
        Math::Vector3::Right());
    return buffers;
}

MeshBuffers CreatePlaneMeshBuffers() {
    MeshBuffers buffers;
    constexpr int kSegments = 10;
    constexpr float kSize = 10.0f;
    const float halfSize = kSize * 0.5f;
    const float step = kSize / static_cast<float>(kSegments);

    for (int z = 0; z <= kSegments; ++z) {
        for (int x = 0; x <= kSegments; ++x) {
            const float px = -halfSize + static_cast<float>(x) * step;
            const float pz = -halfSize + static_cast<float>(z) * step;
            const float u = static_cast<float>(x) / static_cast<float>(kSegments);
            const float v = static_cast<float>(z) / static_cast<float>(kSegments);
            buffers.vertices.push_back(MakeVertex(
                Math::Vector3(px, 0.0f, pz),
                Math::Vector3::Up(),
                Math::Vector3::Right(),
                Math::Vector2(u, v)));
        }
    }

    const int rowStride = kSegments + 1;
    for (int z = 0; z < kSegments; ++z) {
        for (int x = 0; x < kSegments; ++x) {
            const Core::uint32 i0 = static_cast<Core::uint32>(z * rowStride + x);
            const Core::uint32 i1 = i0 + 1;
            const Core::uint32 i2 = i0 + static_cast<Core::uint32>(rowStride);
            const Core::uint32 i3 = i2 + 1;

            buffers.indices.push_back(i0);
            buffers.indices.push_back(i3);
            buffers.indices.push_back(i1);
            buffers.indices.push_back(i0);
            buffers.indices.push_back(i2);
            buffers.indices.push_back(i3);
        }
    }

    return buffers;
}

MeshBuffers CreateUvSphereMeshBuffers() {
    MeshBuffers buffers;
    constexpr int kLongitudeSegments = 24;
    constexpr int kLatitudeSegments = 16;
    constexpr float kRadius = 0.5f;

    for (int latitude = 0; latitude <= kLatitudeSegments; ++latitude) {
        const float v = static_cast<float>(latitude) / static_cast<float>(kLatitudeSegments);
        const float theta = v * kPi;
        const float sinTheta = std::sin(theta);
        const float cosTheta = std::cos(theta);

        for (int longitude = 0; longitude <= kLongitudeSegments; ++longitude) {
            const float u = static_cast<float>(longitude) / static_cast<float>(kLongitudeSegments);
            const float phi = u * (2.0f * kPi);
            const float sinPhi = std::sin(phi);
            const float cosPhi = std::cos(phi);

            const Math::Vector3 normal(cosPhi * sinTheta, cosTheta, sinPhi * sinTheta);
            Math::Vector3 tangent(-sinPhi, 0.0f, cosPhi);
            if (tangent.SqrMagnitude() <= 0.000001f) {
                tangent = Math::Vector3::Right();
            }

            buffers.vertices.push_back(MakeVertex(
                normal * kRadius,
                normal,
                tangent,
                Math::Vector2(u, 1.0f - v)));
        }
    }

    const int stride = kLongitudeSegments + 1;
    for (int latitude = 0; latitude < kLatitudeSegments; ++latitude) {
        for (int longitude = 0; longitude < kLongitudeSegments; ++longitude) {
            const Core::uint32 i0 = static_cast<Core::uint32>(latitude * stride + longitude);
            const Core::uint32 i1 = i0 + 1;
            const Core::uint32 i2 = i0 + static_cast<Core::uint32>(stride);
            const Core::uint32 i3 = i2 + 1;

            buffers.indices.push_back(i0);
            buffers.indices.push_back(i2);
            buffers.indices.push_back(i1);
            buffers.indices.push_back(i1);
            buffers.indices.push_back(i2);
            buffers.indices.push_back(i3);
        }
    }

    return buffers;
}

MeshBuffers CreateCylinderMeshBuffers() {
    MeshBuffers buffers;
    constexpr int kRadialSegments = 24;
    constexpr float kRadius = 0.5f;
    constexpr float kHalfHeight = 1.0f;

    for (int ring = 0; ring <= 1; ++ring) {
        const float y = ring == 0 ? -kHalfHeight : kHalfHeight;
        const float v = static_cast<float>(ring);
        for (int segment = 0; segment <= kRadialSegments; ++segment) {
            const float u = static_cast<float>(segment) / static_cast<float>(kRadialSegments);
            const float angle = u * (2.0f * kPi);
            const float cosAngle = std::cos(angle);
            const float sinAngle = std::sin(angle);
            const Math::Vector3 normal(cosAngle, 0.0f, sinAngle);
            const Math::Vector3 tangent(-sinAngle, 0.0f, cosAngle);
            buffers.vertices.push_back(MakeVertex(
                Math::Vector3(cosAngle * kRadius, y, sinAngle * kRadius),
                normal,
                tangent,
                Math::Vector2(u, v)));
        }
    }

    const int sideStride = kRadialSegments + 1;
    for (int segment = 0; segment < kRadialSegments; ++segment) {
        const Core::uint32 i0 = static_cast<Core::uint32>(segment);
        const Core::uint32 i1 = i0 + 1;
        const Core::uint32 i2 = i0 + static_cast<Core::uint32>(sideStride);
        const Core::uint32 i3 = i2 + 1;

        buffers.indices.push_back(i0);
        buffers.indices.push_back(i2);
        buffers.indices.push_back(i1);
        buffers.indices.push_back(i1);
        buffers.indices.push_back(i2);
        buffers.indices.push_back(i3);
    }

    const auto appendCap = [&](bool topCap) {
        const float y = topCap ? kHalfHeight : -kHalfHeight;
        const Math::Vector3 normal = topCap ? Math::Vector3::Up() : Math::Vector3::Down();
        const Core::uint32 centerIndex = static_cast<Core::uint32>(buffers.vertices.size());
        buffers.vertices.push_back(MakeVertex(
            Math::Vector3(0.0f, y, 0.0f),
            normal,
            Math::Vector3::Right(),
            Math::Vector2(0.5f, 0.5f)));

        for (int segment = 0; segment <= kRadialSegments; ++segment) {
            const float u = static_cast<float>(segment) / static_cast<float>(kRadialSegments);
            const float angle = u * (2.0f * kPi);
            const float cosAngle = std::cos(angle);
            const float sinAngle = std::sin(angle);
            buffers.vertices.push_back(MakeVertex(
                Math::Vector3(cosAngle * kRadius, y, sinAngle * kRadius),
                normal,
                Math::Vector3::Right(),
                Math::Vector2(cosAngle * 0.5f + 0.5f, sinAngle * 0.5f + 0.5f)));
        }

        for (int segment = 0; segment < kRadialSegments; ++segment) {
            const Core::uint32 rim0 = centerIndex + 1 + static_cast<Core::uint32>(segment);
            const Core::uint32 rim1 = rim0 + 1;
            if (topCap) {
                buffers.indices.push_back(centerIndex);
                buffers.indices.push_back(rim0);
                buffers.indices.push_back(rim1);
            } else {
                buffers.indices.push_back(centerIndex);
                buffers.indices.push_back(rim1);
                buffers.indices.push_back(rim0);
            }
        }
    };

    appendCap(true);
    appendCap(false);
    return buffers;
}

MeshBuffers CreateCapsuleMeshBuffers() {
    MeshBuffers buffers;
    constexpr int kRadialSegments = 24;
    constexpr int kHemisphereSegments = 8;
    constexpr float kRadius = 0.5f;
    constexpr float kHalfCylinderHeight = 0.5f;

    struct RingDefinition {
        float y = 0.0f;
        float radius = 0.0f;
        Math::Vector3 normalBase = Math::Vector3::Zero();
    };

    std::vector<RingDefinition> rings;
    rings.reserve(static_cast<size_t>(kHemisphereSegments * 2 + 2));

    for (int step = 0; step <= kHemisphereSegments; ++step) {
        const float t = static_cast<float>(step) / static_cast<float>(kHemisphereSegments);
        const float angle = -0.5f * kPi + t * (0.5f * kPi);
        const float ringRadius = std::cos(angle) * kRadius;
        const float y = std::sin(angle) * kRadius - kHalfCylinderHeight;
        const Math::Vector3 normalBase(0.0f, std::sin(angle), 0.0f);
        rings.push_back({ y, ringRadius, normalBase });
    }

    for (int step = 0; step <= kHemisphereSegments; ++step) {
        const float t = static_cast<float>(step) / static_cast<float>(kHemisphereSegments);
        const float angle = t * (0.5f * kPi);
        const float ringRadius = std::cos(angle) * kRadius;
        const float y = std::sin(angle) * kRadius + kHalfCylinderHeight;
        const Math::Vector3 normalBase(0.0f, std::sin(angle), 0.0f);
        rings.push_back({ y, ringRadius, normalBase });
    }

    for (size_t ringIndex = 0; ringIndex < rings.size(); ++ringIndex) {
        const float v = rings.size() > 1
            ? static_cast<float>(ringIndex) / static_cast<float>(rings.size() - 1)
            : 0.0f;
        for (int segment = 0; segment <= kRadialSegments; ++segment) {
            const float u = static_cast<float>(segment) / static_cast<float>(kRadialSegments);
            const float angle = u * (2.0f * kPi);
            const float cosAngle = std::cos(angle);
            const float sinAngle = std::sin(angle);
            const Math::Vector3 radial(cosAngle, 0.0f, sinAngle);

            Math::Vector3 normal(
                radial.x * rings[ringIndex].radius,
                rings[ringIndex].normalBase.y * kRadius,
                radial.z * rings[ringIndex].radius);
            normal = normal.Normalized();
            if (normal.SqrMagnitude() <= 0.000001f) {
                normal = rings[ringIndex].y >= 0.0f ? Math::Vector3::Up() : Math::Vector3::Down();
            }

            const Math::Vector3 tangent(-sinAngle, 0.0f, cosAngle);
            buffers.vertices.push_back(MakeVertex(
                Math::Vector3(radial.x * rings[ringIndex].radius, rings[ringIndex].y, radial.z * rings[ringIndex].radius),
                normal,
                tangent,
                Math::Vector2(u, 1.0f - v)));
        }
    }

    const int stride = kRadialSegments + 1;
    for (size_t ringIndex = 0; ringIndex + 1 < rings.size(); ++ringIndex) {
        for (int segment = 0; segment < kRadialSegments; ++segment) {
            const Core::uint32 i0 = static_cast<Core::uint32>(ringIndex * stride + static_cast<size_t>(segment));
            const Core::uint32 i1 = i0 + 1;
            const Core::uint32 i2 = i0 + static_cast<Core::uint32>(stride);
            const Core::uint32 i3 = i2 + 1;

            buffers.indices.push_back(i0);
            buffers.indices.push_back(i2);
            buffers.indices.push_back(i1);
            buffers.indices.push_back(i1);
            buffers.indices.push_back(i2);
            buffers.indices.push_back(i3);
        }
    }

    return buffers;
}

Mesh* BuildMeshResource(
    const Containers::String& path,
    const char* displayName,
    MeshBuffers&& buffers) {
    if (buffers.vertices.empty() || buffers.indices.empty()) {
        return nullptr;
    }

    auto* mesh = new Mesh();
    IResource::ConstructParams params;
    params.name = Containers::String(displayName);
    params.path = path;
    params.guid = ResourceGUID::Generate(path);
    params.memorySize = 0;
    mesh->Initialize(params);

    mesh->SetVertexData(
        buffers.vertices.data(),
        buffers.vertices.size() * sizeof(StaticMeshVertex),
        static_cast<Core::uint32>(buffers.vertices.size()),
        sizeof(StaticMeshVertex),
        VertexAttribute::Position |
            VertexAttribute::Normal |
            VertexAttribute::Tangent |
            VertexAttribute::Bitangent |
            VertexAttribute::UV0);

    if (buffers.vertices.size() > 65535u) {
        mesh->SetIndexData(
            buffers.indices.data(),
            buffers.indices.size() * sizeof(Core::uint32),
            static_cast<Core::uint32>(buffers.indices.size()),
            true);
    } else {
        std::vector<Core::uint16> compactIndices;
        compactIndices.reserve(buffers.indices.size());
        for (Core::uint32 index : buffers.indices) {
            compactIndices.push_back(static_cast<Core::uint16>(index));
        }

        mesh->SetIndexData(
            compactIndices.data(),
            compactIndices.size() * sizeof(Core::uint16),
            static_cast<Core::uint32>(compactIndices.size()),
            false);
    }

    const Math::Bounds bounds = ComputeBounds(buffers.vertices);
    mesh->SetBounds(bounds);

    MeshSection section = {};
    section.baseVertex = 0;
    section.vertexCount = static_cast<Core::uint32>(buffers.vertices.size());
    section.startIndex = 0;
    section.indexCount = static_cast<Core::uint32>(buffers.indices.size());
    section.materialID = 0;
    section.bounds = bounds;
    mesh->AddSection(section);

    return mesh;
}

size_t CalculateBuiltinShaderMemorySize(const Shader& shader) {
    size_t memorySize = sizeof(Shader) + shader.GetName().Length() + shader.GetPath().Length();
    for (const ShaderPropertyDesc& property : shader.GetProperties()) {
        memorySize += property.name.Length();
        memorySize += property.displayName.Length();
        memorySize += property.defaultValue.Length();
        memorySize += property.semantic.Length();
    }
    for (const ShaderPass& pass : shader.GetPasses()) {
        memorySize += pass.name.Length();
        for (const ShaderPassTagEntry& tag : pass.tags) {
            memorySize += tag.name.Length();
            memorySize += tag.value.Length();
        }
        for (const ShaderResourceBindingDesc& binding : pass.resources) {
            memorySize += binding.name.Length();
            memorySize += binding.semantic.Length();
        }
        for (const ShaderStageVariant& variant : pass.variants) {
            memorySize += variant.entryPoint.Length();
            memorySize += variant.profile.Length();
            memorySize += variant.sourceCode.Length();
            memorySize += variant.compiledBinary.Size();
        }
    }

    return memorySize;
}

Shader* BuildBuiltinForwardLitShader(const Containers::String& path) {
    return TryLoadBuiltinShaderFromManifest(path);
}

Shader* BuildBuiltinUnlitShader(const Containers::String& path) {
    return TryLoadBuiltinShaderFromManifest(path);
}

Shader* BuildBuiltinDepthOnlyShader(const Containers::String& path) {
    return TryLoadBuiltinShaderFromManifest(path);
}

Shader* BuildBuiltinShadowCasterShader(const Containers::String& path) {
    return TryLoadBuiltinShaderFromManifest(path);
}

Shader* BuildBuiltinObjectIdShader(const Containers::String& path) {
    return TryLoadBuiltinShaderFromManifest(path);
}

Shader* BuildBuiltinSkyboxShader(const Containers::String& path) {
    return TryLoadBuiltinShaderFromManifest(path);
}

Shader* BuildBuiltinColorScalePostProcessShader(const Containers::String& path) {
    return TryLoadBuiltinShaderFromManifest(path);
}

Material* BuildDefaultPrimitiveMaterial(const Containers::String& path) {
    auto* material = new Material();
    IResource::ConstructParams params;
    params.name = Containers::String("Default Primitive Material");
    params.path = path;
    params.guid = ResourceGUID::Generate(path);
    params.memorySize = 0;
    material->Initialize(params);

    MaterialRenderState renderState = {};
    renderState.cullMode = MaterialCullMode::Back;
    material->SetRenderState(renderState);
    material->SetRenderQueue(MaterialRenderQueue::Geometry);
    material->SetShader(ResourceManager::Get().Load<Shader>(GetBuiltinForwardLitShaderPath()));
    material->SetTexture(
        Containers::String("baseColorTexture"),
        ResourceManager::Get().Load<Texture>(GetBuiltinDefaultPrimitiveTexturePath()));
    material->RecalculateMemorySize();
    return material;
}

Texture* BuildDefaultPrimitiveTexture(const Containers::String& path) {
    static const unsigned char kTexturePixels[4] = { 214, 214, 214, 255 };

    auto* texture = new Texture();
    IResource::ConstructParams params;
    params.name = Containers::String("Default Primitive Albedo");
    params.path = path;
    params.guid = ResourceGUID::Generate(path);
    params.memorySize = 0;
    texture->Initialize(params);

    if (!texture->Create(
            1,
            1,
            1,
            1,
            TextureType::Texture2D,
            TextureFormat::RGBA8_UNORM,
            kTexturePixels,
            sizeof(kTexturePixels))) {
        delete texture;
        return nullptr;
    }

    return texture;
}

} // namespace

bool IsBuiltinResourcePath(const Containers::String& path) {
    return path.StartsWith(kBuiltinPrefix);
}

bool IsBuiltinMeshPath(const Containers::String& path) {
    return path.StartsWith(kBuiltinMeshPrefix);
}

bool IsBuiltinMaterialPath(const Containers::String& path) {
    return path.StartsWith(kBuiltinMaterialPrefix);
}

bool IsBuiltinShaderPath(const Containers::String& path) {
    return path.StartsWith(kBuiltinShaderPrefix);
}

bool IsBuiltinTexturePath(const Containers::String& path) {
    return path.StartsWith(kBuiltinTexturePrefix);
}

const char* GetBuiltinPrimitiveDisplayName(BuiltinPrimitiveType primitiveType) {
    switch (primitiveType) {
        case BuiltinPrimitiveType::Cube: return "Cube";
        case BuiltinPrimitiveType::Sphere: return "Sphere";
        case BuiltinPrimitiveType::Capsule: return "Capsule";
        case BuiltinPrimitiveType::Cylinder: return "Cylinder";
        case BuiltinPrimitiveType::Plane: return "Plane";
        case BuiltinPrimitiveType::Quad: return "Quad";
        default: return "Primitive";
    }
}

Containers::String GetBuiltinPrimitiveMeshPath(BuiltinPrimitiveType primitiveType) {
    switch (primitiveType) {
        case BuiltinPrimitiveType::Cube: return Containers::String("builtin://meshes/cube");
        case BuiltinPrimitiveType::Sphere: return Containers::String("builtin://meshes/sphere");
        case BuiltinPrimitiveType::Capsule: return Containers::String("builtin://meshes/capsule");
        case BuiltinPrimitiveType::Cylinder: return Containers::String("builtin://meshes/cylinder");
        case BuiltinPrimitiveType::Plane: return Containers::String("builtin://meshes/plane");
        case BuiltinPrimitiveType::Quad: return Containers::String("builtin://meshes/quad");
        default: return Containers::String();
    }
}

Containers::String GetBuiltinDefaultPrimitiveMaterialPath() {
    return Containers::String(kBuiltinDefaultPrimitiveMaterialPath);
}

Containers::String GetBuiltinForwardLitShaderPath() {
    return Containers::String(kBuiltinForwardLitShaderPath);
}

Containers::String GetBuiltinUnlitShaderPath() {
    return Containers::String(kBuiltinUnlitShaderPath);
}

Containers::String GetBuiltinDepthOnlyShaderPath() {
    return Containers::String(kBuiltinDepthOnlyShaderPath);
}

Containers::String GetBuiltinShadowCasterShaderPath() {
    return Containers::String(kBuiltinShadowCasterShaderPath);
}

Containers::String GetBuiltinObjectIdShaderPath() {
    return Containers::String(kBuiltinObjectIdShaderPath);
}

Containers::String GetBuiltinSkyboxShaderPath() {
    return Containers::String(kBuiltinSkyboxShaderPath);
}

Containers::String GetBuiltinColorScalePostProcessShaderPath() {
    return Containers::String(kBuiltinColorScalePostProcessShaderPath);
}

Containers::String GetBuiltinDefaultPrimitiveTexturePath() {
    return Containers::String(kBuiltinDefaultPrimitiveTexturePath);
}

bool TryParseBuiltinPrimitiveType(const Containers::String& path, BuiltinPrimitiveType& outPrimitiveType) {
    if (path == GetBuiltinPrimitiveMeshPath(BuiltinPrimitiveType::Cube)) {
        outPrimitiveType = BuiltinPrimitiveType::Cube;
        return true;
    }
    if (path == GetBuiltinPrimitiveMeshPath(BuiltinPrimitiveType::Sphere)) {
        outPrimitiveType = BuiltinPrimitiveType::Sphere;
        return true;
    }
    if (path == GetBuiltinPrimitiveMeshPath(BuiltinPrimitiveType::Capsule)) {
        outPrimitiveType = BuiltinPrimitiveType::Capsule;
        return true;
    }
    if (path == GetBuiltinPrimitiveMeshPath(BuiltinPrimitiveType::Cylinder)) {
        outPrimitiveType = BuiltinPrimitiveType::Cylinder;
        return true;
    }
    if (path == GetBuiltinPrimitiveMeshPath(BuiltinPrimitiveType::Plane)) {
        outPrimitiveType = BuiltinPrimitiveType::Plane;
        return true;
    }
    if (path == GetBuiltinPrimitiveMeshPath(BuiltinPrimitiveType::Quad)) {
        outPrimitiveType = BuiltinPrimitiveType::Quad;
        return true;
    }

    return false;
}

LoadResult CreateBuiltinMeshResource(const Containers::String& path) {
    BuiltinPrimitiveType primitiveType = BuiltinPrimitiveType::Cube;
    if (!TryParseBuiltinPrimitiveType(path, primitiveType)) {
        return LoadResult(Containers::String("Unknown builtin mesh: ") + path);
    }

    MeshBuffers buffers;
    switch (primitiveType) {
        case BuiltinPrimitiveType::Cube:
            buffers = CreateCubeMeshBuffers();
            break;
        case BuiltinPrimitiveType::Sphere:
            buffers = CreateUvSphereMeshBuffers();
            break;
        case BuiltinPrimitiveType::Capsule:
            buffers = CreateCapsuleMeshBuffers();
            break;
        case BuiltinPrimitiveType::Cylinder:
            buffers = CreateCylinderMeshBuffers();
            break;
        case BuiltinPrimitiveType::Plane:
            buffers = CreatePlaneMeshBuffers();
            break;
        case BuiltinPrimitiveType::Quad:
            buffers = CreateQuadMeshBuffers();
            break;
        default:
            return LoadResult(Containers::String("Unsupported builtin mesh: ") + path);
    }

    // The UV sphere generator already emits triangles in the runtime's front-face convention.
    if (primitiveType != BuiltinPrimitiveType::Sphere) {
        FlipTriangleWinding(buffers);
    }

    Mesh* mesh = BuildMeshResource(path, GetBuiltinPrimitiveDisplayName(primitiveType), std::move(buffers));
    if (mesh == nullptr) {
        return LoadResult(Containers::String("Failed to create builtin mesh: ") + path);
    }

    return LoadResult(mesh);
}

LoadResult CreateBuiltinMaterialResource(const Containers::String& path) {
    if (path != GetBuiltinDefaultPrimitiveMaterialPath()) {
        return LoadResult(Containers::String("Unknown builtin material: ") + path);
    }

    Material* material = BuildDefaultPrimitiveMaterial(path);
    if (material == nullptr) {
        return LoadResult(Containers::String("Failed to create builtin material: ") + path);
    }

    return LoadResult(material);
}

LoadResult CreateBuiltinShaderResource(const Containers::String& path) {
    Shader* shader = nullptr;
    if (path == GetBuiltinForwardLitShaderPath()) {
        shader = BuildBuiltinForwardLitShader(path);
    } else if (path == GetBuiltinUnlitShaderPath()) {
        shader = BuildBuiltinUnlitShader(path);
    } else if (path == GetBuiltinDepthOnlyShaderPath()) {
        shader = BuildBuiltinDepthOnlyShader(path);
    } else if (path == GetBuiltinShadowCasterShaderPath()) {
        shader = BuildBuiltinShadowCasterShader(path);
    } else if (path == GetBuiltinObjectIdShaderPath()) {
        shader = BuildBuiltinObjectIdShader(path);
    } else if (path == GetBuiltinSkyboxShaderPath()) {
        shader = BuildBuiltinSkyboxShader(path);
    } else if (path == GetBuiltinColorScalePostProcessShaderPath()) {
        shader = BuildBuiltinColorScalePostProcessShader(path);
    } else {
        return LoadResult(Containers::String("Unknown builtin shader: ") + path);
    }

    if (shader == nullptr) {
        return LoadResult(Containers::String("Failed to create builtin shader: ") + path);
    }

    return LoadResult(shader);
}

LoadResult CreateBuiltinTextureResource(const Containers::String& path) {
    if (path != GetBuiltinDefaultPrimitiveTexturePath()) {
        return LoadResult(Containers::String("Unknown builtin texture: ") + path);
    }

    Texture* texture = BuildDefaultPrimitiveTexture(path);
    if (texture == nullptr) {
        return LoadResult(Containers::String("Failed to create builtin texture: ") + path);
    }

    return LoadResult(texture);
}

} // namespace Resources
} // namespace XCEngine