#define NOMINMAX
#include <windows.h>

#include <gtest/gtest.h>

#include "../RenderingIntegrationImageAssert.h"
#include "../RenderingIntegrationMain.h"

#include <XCEngine/Components/MeshFilterComponent.h>
#include <XCEngine/Components/MeshRendererComponent.h>
#include <XCEngine/Components/LightComponent.h>
#include <XCEngine/Core/Asset/ResourceManager.h>
#include <XCEngine/Rendering/Extraction/RenderSceneExtractor.h>
#include <XCEngine/Rendering/Execution/SceneRenderer.h>
#include <XCEngine/Rendering/RenderContext.h>
#include <XCEngine/Rendering/RenderSurface.h>
#include <XCEngine/Resources/Material/Material.h>
#include <XCEngine/Resources/Mesh/Mesh.h>
#include <XCEngine/RHI/RHITexture.h>
#include <XCEngine/Scene/Scene.h>

#include "../../../RHI/integration/fixtures/RHIIntegrationFixture.h"

#include <chrono>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <filesystem>
#include <memory>
#include <limits>
#include <sstream>
#include <string>
#include <thread>
#include <unordered_map>
#include <unordered_set>
#include <vector>

using namespace XCEngine::Components;
using namespace XCEngine::Rendering;
using namespace XCEngine::Resources;
using namespace XCEngine::RHI;
using namespace XCEngine::RHI::Integration;
using namespace RenderingIntegrationTestUtils;

namespace {

constexpr const char* kD3D12Screenshot = "nahida_preview_scene_d3d12.ppm";
constexpr uint32_t kFrameWidth = 1280;
constexpr uint32_t kFrameHeight = 720;
constexpr int kWarmupFrames = 45;

enum class DiagnosticMode {
    Toon,
    NoShadows,
    ForwardLit,
    Unlit
};

DiagnosticMode GetDiagnosticMode() {
    const char* value = std::getenv("XC_NAHIDA_DIAG_MODE");
    if (value == nullptr) {
        return DiagnosticMode::Toon;
    }

    const std::string mode(value);
    if (mode == "toon" || mode == "original") {
        return DiagnosticMode::Toon;
    }
    if (mode == "no_shadows") {
        return DiagnosticMode::NoShadows;
    }
    if (mode == "forward_lit") {
        return DiagnosticMode::ForwardLit;
    }
    if (mode == "unlit") {
        return DiagnosticMode::Unlit;
    }

    return DiagnosticMode::Toon;
}

const char* GetDiagnosticModeName(DiagnosticMode mode) {
    switch (mode) {
    case DiagnosticMode::Toon: return "toon";
    case DiagnosticMode::NoShadows: return "no_shadows";
    case DiagnosticMode::ForwardLit: return "forward_lit";
    case DiagnosticMode::Unlit: return "unlit";
    default: return "unknown";
    }
}

const char* GetGoldenFileName(DiagnosticMode mode) {
    switch (mode) {
    case DiagnosticMode::Toon: return "GT.ppm";
    case DiagnosticMode::NoShadows: return "GT.no_shadows.ppm";
    case DiagnosticMode::ForwardLit: return "GT.forward_lit.ppm";
    case DiagnosticMode::Unlit: return "GT.unlit.ppm";
    default: return "GT.ppm";
    }
}

constexpr const char* kToonShaderPath = "Assets/Shaders/Toon.shader";
constexpr const char* kNahidaTextureRoot = "Assets/Models/nahida/";

XCEngine::Containers::String RemapMaterialPropertyName(
    const Material& targetMaterial,
    const XCEngine::Containers::String& sourceName) {
    if (targetMaterial.HasProperty(sourceName)) {
        return sourceName;
    }
    if (sourceName == XCEngine::Containers::String("_BaseMap") && targetMaterial.HasProperty("_MainTex")) {
        return XCEngine::Containers::String("_MainTex");
    }
    if (sourceName == XCEngine::Containers::String("_MainTex") && targetMaterial.HasProperty("_BaseMap")) {
        return XCEngine::Containers::String("_BaseMap");
    }
    if (sourceName == XCEngine::Containers::String("_Color") && targetMaterial.HasProperty("_BaseColor")) {
        return XCEngine::Containers::String("_BaseColor");
    }
    if (sourceName == XCEngine::Containers::String("_BaseColor") && targetMaterial.HasProperty("_Color")) {
        return XCEngine::Containers::String("_Color");
    }

    return XCEngine::Containers::String();
}

bool IsNahidaCharacterRenderable(const GameObject* gameObject) {
    if (gameObject == nullptr) {
        return false;
    }

    const std::string& name = gameObject->GetName();
    return name.rfind("Body_Mesh", 0) == 0 ||
           name == "Brow" ||
           name == "EyeStar" ||
           name == "Face" ||
           name == "Face_Eye";
}

std::string BuildNahidaTextureAssetPath(const char* fileName) {
    return std::string(kNahidaTextureRoot) + fileName;
}

void SetMaterialFloatIfPresent(Material* material, const char* name, float value) {
    if (material == nullptr || name == nullptr || !material->HasProperty(name)) {
        return;
    }

    material->SetFloat(name, value);
}

void SetMaterialFloat4IfPresent(Material* material, const char* name, const XCEngine::Math::Vector4& value) {
    if (material == nullptr || name == nullptr || !material->HasProperty(name)) {
        return;
    }

    material->SetFloat4(name, value);
}

void SetMaterialTexturePath(Material* material, const char* name, const char* fileName) {
    if (material == nullptr || name == nullptr || fileName == nullptr || !material->HasProperty(name)) {
        return;
    }

    const std::string assetPath = BuildNahidaTextureAssetPath(fileName);
    const ResourceHandle<Texture> texture = ResourceManager::Get().Load<Texture>(assetPath.c_str());
    if (texture.Get() != nullptr) {
        material->SetTexture(name, texture);
        return;
    }

    material->SetTextureAssetRef(name, AssetRef(), XCEngine::Containers::String(assetPath.c_str()));
}

void ApplyNahidaSharedToonDefaults(Material* material) {
    if (material == nullptr) {
        return;
    }

    material->ClearKeywords();
    material->ClearTags();
    material->SetRenderStateOverrideEnabled(false);

    SetMaterialFloat4IfPresent(material, "_BaseColor", XCEngine::Math::Vector4(1.0f, 1.0f, 1.0f, 1.0f));
    SetMaterialFloatIfPresent(material, "_Cutoff", 0.5f);
    SetMaterialFloatIfPresent(material, "_IsDay", 1.0f);
    SetMaterialFloatIfPresent(material, "_DoubleSided", 0.0f);
    SetMaterialFloat4IfPresent(material, "_LightDirectionMultiplier", XCEngine::Math::Vector4(1.0f, 0.5f, 1.0f, 0.0f));
    SetMaterialFloatIfPresent(material, "_ShadowOffset", 0.1f);
    SetMaterialFloatIfPresent(material, "_ShadowSmoothness", 0.4f);
    SetMaterialFloat4IfPresent(material, "_ShadowColor", XCEngine::Math::Vector4(1.1f, 1.1f, 1.1f, 1.0f));
    SetMaterialFloatIfPresent(material, "_UseCustomMaterialType", 0.0f);
    SetMaterialFloatIfPresent(material, "_CustomMaterialType", 1.0f);
    SetMaterialFloatIfPresent(material, "_UseEmission", 0.0f);
    SetMaterialFloatIfPresent(material, "_EmissionIntensity", 0.2f);
    SetMaterialFloatIfPresent(material, "_UseNormalMap", 0.0f);
    SetMaterialFloatIfPresent(material, "_IsFace", 0.0f);
    SetMaterialFloat4IfPresent(material, "_FaceDirection", XCEngine::Math::Vector4(0.0f, 0.0f, 1.0f, 0.0f));
    SetMaterialFloatIfPresent(material, "_FaceShadowOffset", 0.0f);
    SetMaterialFloat4IfPresent(material, "_FaceBlushColor", XCEngine::Math::Vector4(1.0f, 0.72156864f, 0.69803923f, 1.0f));
    SetMaterialFloatIfPresent(material, "_FaceBlushStrength", 0.0f);
    SetMaterialFloatIfPresent(material, "_UseSpecular", 0.0f);
    SetMaterialFloatIfPresent(material, "_SpecularSmoothness", 5.0f);
    SetMaterialFloatIfPresent(material, "_NonmetallicIntensity", 0.3f);
    SetMaterialFloatIfPresent(material, "_MetallicIntensity", 8.0f);
    SetMaterialFloatIfPresent(material, "_UseRim", 0.0f);
    SetMaterialFloatIfPresent(material, "_RimOffset", 5.0f);
    SetMaterialFloatIfPresent(material, "_RimThreshold", 0.5f);
    SetMaterialFloatIfPresent(material, "_RimIntensity", 0.5f);
    SetMaterialFloatIfPresent(material, "_UseSmoothNormal", 0.0f);
    SetMaterialFloatIfPresent(material, "_OutlineWidth", 1.6f);
    SetMaterialFloat4IfPresent(material, "_OutlineWidthParams", XCEngine::Math::Vector4(0.0f, 6.0f, 0.1f, 0.6f));
    SetMaterialFloatIfPresent(material, "_OutlineZOffset", 0.1f);
    SetMaterialFloat4IfPresent(material, "_ScreenOffset", XCEngine::Math::Vector4(0.0f, 0.0f, 0.0f, 0.0f));
    SetMaterialFloat4IfPresent(material, "_OutlineColor", XCEngine::Math::Vector4(0.5176471f, 0.35686275f, 0.34117648f, 1.0f));
    SetMaterialFloat4IfPresent(material, "_OutlineColor2", XCEngine::Math::Vector4(0.3529412f, 0.3529412f, 0.3529412f, 1.0f));
    SetMaterialFloat4IfPresent(material, "_OutlineColor3", XCEngine::Math::Vector4(0.47058824f, 0.47058824f, 0.5647059f, 1.0f));
    SetMaterialFloat4IfPresent(material, "_OutlineColor4", XCEngine::Math::Vector4(0.5176471f, 0.35686275f, 0.34117648f, 1.0f));
    SetMaterialFloat4IfPresent(material, "_OutlineColor5", XCEngine::Math::Vector4(0.35f, 0.35f, 0.35f, 1.0f));
}

void ApplyNahidaSurfaceRecipe(
    Material* material,
    const char* baseMapFile,
    const char* lightMapFile,
    const char* normalMapFile,
    const char* shadowRampFile,
    bool doubleSided,
    bool useSmoothNormal,
    float outlineZOffset,
    const XCEngine::Math::Vector4* outlineColor = nullptr) {
    if (material == nullptr) {
        return;
    }

    ApplyNahidaSharedToonDefaults(material);

    SetMaterialTexturePath(material, "_BaseMap", baseMapFile);
    SetMaterialTexturePath(material, "_LightMap", lightMapFile);
    SetMaterialTexturePath(material, "_NormalMap", normalMapFile);
    SetMaterialTexturePath(material, "_ShadowRamp", shadowRampFile);
    SetMaterialTexturePath(material, "_MetalMap", "Avatar_Tex_MetalMap.png");

    SetMaterialFloatIfPresent(material, "_UseEmission", 1.0f);
    SetMaterialFloatIfPresent(material, "_UseNormalMap", 1.0f);
    SetMaterialFloatIfPresent(material, "_UseRim", 1.0f);
    SetMaterialFloatIfPresent(material, "_UseSpecular", 1.0f);
    SetMaterialFloatIfPresent(material, "_UseSmoothNormal", useSmoothNormal ? 1.0f : 0.0f);
    SetMaterialFloatIfPresent(material, "_DoubleSided", doubleSided ? 1.0f : 0.0f);
    if (outlineZOffset != 0.0f) {
        SetMaterialFloatIfPresent(material, "_OutlineZOffset", outlineZOffset);
    }
    if (outlineColor != nullptr) {
        SetMaterialFloat4IfPresent(material, "_OutlineColor", *outlineColor);
    }

    material->EnableKeyword("_EMISSION");
    material->EnableKeyword("_NORMAL_MAP");
    material->EnableKeyword("_SPECULAR");
    material->EnableKeyword("_RIM");

    if (doubleSided) {
        MaterialRenderState renderState = material->GetRenderState();
        renderState.cullMode = MaterialCullMode::None;
        material->SetRenderState(renderState);
    }
}

void ApplyNahidaFaceRecipe(Material* material, bool eyebrowVariant) {
    if (material == nullptr) {
        return;
    }

    ApplyNahidaSharedToonDefaults(material);

    SetMaterialTexturePath(material, "_BaseMap", "Avatar_Loli_Catalyst_Nahida_Tex_Face_Diffuse.png");
    SetMaterialTexturePath(material, "_FaceLightMap", "Avatar_Loli_Tex_FaceLightmap.png");
    SetMaterialTexturePath(material, "_FaceShadow", "Avatar_Tex_Face_Shadow.png");
    SetMaterialTexturePath(material, "_ShadowRamp", "Avatar_Loli_Catalyst_Nahida_Tex_Body_Shadow_Ramp.png");

    SetMaterialFloatIfPresent(material, "_IsFace", 1.0f);
    SetMaterialFloatIfPresent(material, "_UseCustomMaterialType", 1.0f);
    SetMaterialFloatIfPresent(material, "_UseRim", 1.0f);
    SetMaterialFloat4IfPresent(
        material,
        "_FaceDirection",
        XCEngine::Math::Vector4(-0.0051237254f, -0.11509954f, -0.99334073f, 0.0f));

    if (eyebrowVariant) {
        SetMaterialFloatIfPresent(material, "_OutlineWidth", 0.0f);
        SetMaterialFloat4IfPresent(
            material,
            "_BaseColor",
            XCEngine::Math::Vector4(0.9764706f, 0.80103135f, 0.76164705f, 1.0f));
    } else {
        SetMaterialFloatIfPresent(material, "_FaceBlushStrength", 0.3f);
        SetMaterialFloatIfPresent(material, "_OutlineZOffset", 0.5f);
    }

    material->EnableKeyword("_IS_FACE");
    material->EnableKeyword("_RIM");
}

void ApplyNahidaToonRecipe(Material* material, const GameObject* owner) {
    if (material == nullptr || owner == nullptr) {
        return;
    }

    const std::string& name = owner->GetName();
    if (name == "Body_Mesh0") {
        const XCEngine::Math::Vector4 outlineColor(0.2784314f, 0.18039216f, 0.14901961f, 1.0f);
        ApplyNahidaSurfaceRecipe(
            material,
            "Avatar_Loli_Catalyst_Nahida_Tex_Hair_Diffuse.png",
            "Avatar_Loli_Catalyst_Nahida_Tex_Hair_Lightmap.png",
            "Avatar_Loli_Catalyst_Nahida_Tex_Hair_Normalmap.png",
            "Avatar_Loli_Catalyst_Nahida_Tex_Hair_Shadow_Ramp.png",
            false,
            true,
            0.0f,
            &outlineColor);
        return;
    }

    if (name == "Body_Mesh1") {
        ApplyNahidaSurfaceRecipe(
            material,
            "Avatar_Loli_Catalyst_Nahida_Tex_Body_Diffuse.png",
            "Avatar_Loli_Catalyst_Nahida_Tex_Body_Lightmap.png",
            "Avatar_Loli_Catalyst_Nahida_Tex_Body_Normalmap.png",
            "Avatar_Loli_Catalyst_Nahida_Tex_Body_Shadow_Ramp.png",
            false,
            true,
            0.0f);
        return;
    }

    if (name == "Body_Mesh2") {
        ApplyNahidaSurfaceRecipe(
            material,
            "Avatar_Loli_Catalyst_Nahida_Tex_Body_Diffuse.png",
            "Avatar_Loli_Catalyst_Nahida_Tex_Body_Lightmap.png",
            "Avatar_Loli_Catalyst_Nahida_Tex_Body_Normalmap.png",
            "Avatar_Loli_Catalyst_Nahida_Tex_Body_Shadow_Ramp.png",
            true,
            true,
            0.5f);
        return;
    }

    if (name == "Body_Mesh3") {
        ApplyNahidaSurfaceRecipe(
            material,
            "Avatar_Loli_Catalyst_Nahida_Tex_Hair_Diffuse.png",
            "Avatar_Loli_Catalyst_Nahida_Tex_Hair_Lightmap.png",
            "Avatar_Loli_Catalyst_Nahida_Tex_Hair_Normalmap.png",
            "Avatar_Loli_Catalyst_Nahida_Tex_Hair_Shadow_Ramp.png",
            true,
            false,
            0.5f);
        return;
    }

    if (name == "Brow") {
        ApplyNahidaFaceRecipe(material, true);
        return;
    }

    if (name == "EyeStar" || name == "Face" || name == "Face_Eye") {
        ApplyNahidaFaceRecipe(material, false);
    }
}

std::unordered_set<std::string> GetIsolationObjectNames() {
    std::unordered_set<std::string> result;
    const char* value = std::getenv("XC_NAHIDA_DIAG_ONLY");
    if (value == nullptr) {
        return result;
    }

    std::stringstream stream(value);
    std::string token;
    while (std::getline(stream, token, ',')) {
        const size_t first = token.find_first_not_of(" \t\r\n");
        if (first == std::string::npos) {
            continue;
        }

        const size_t last = token.find_last_not_of(" \t\r\n");
        result.emplace(token.substr(first, last - first + 1));
    }

    return result;
}

std::string DescribeVertexAttributes(VertexAttribute attributes) {
    std::string result;
    const auto appendFlag = [&result](const char* name) {
        if (!result.empty()) {
            result += "|";
        }
        result += name;
    };

    if (HasVertexAttribute(attributes, VertexAttribute::Position)) {
        appendFlag("Position");
    }
    if (HasVertexAttribute(attributes, VertexAttribute::Normal)) {
        appendFlag("Normal");
    }
    if (HasVertexAttribute(attributes, VertexAttribute::Tangent)) {
        appendFlag("Tangent");
    }
    if (HasVertexAttribute(attributes, VertexAttribute::Bitangent)) {
        appendFlag("Bitangent");
    }
    if (HasVertexAttribute(attributes, VertexAttribute::Color)) {
        appendFlag("Color");
    }
    if (HasVertexAttribute(attributes, VertexAttribute::UV0)) {
        appendFlag("UV0");
    }
    if (HasVertexAttribute(attributes, VertexAttribute::UV1)) {
        appendFlag("UV1");
    }

    return result;
}

void DumpMeshDiagnostics(const char* label, const Mesh* mesh) {
    if (mesh == nullptr) {
        std::printf("[NahidaDiag] %s mesh=null\n", label);
        return;
    }

    const XCEngine::Math::Bounds& bounds = mesh->GetBounds();
    std::printf(
        "[NahidaDiag] %s meshPath=%s vertices=%u indices=%u stride=%u attrs=%s center=(%.4f, %.4f, %.4f) extents=(%.4f, %.4f, %.4f) sections=%zu\n",
        label,
        mesh->GetPath().CStr(),
        mesh->GetVertexCount(),
        mesh->GetIndexCount(),
        mesh->GetVertexStride(),
        DescribeVertexAttributes(mesh->GetVertexAttributes()).c_str(),
        bounds.center.x,
        bounds.center.y,
        bounds.center.z,
        bounds.extents.x,
        bounds.extents.y,
        bounds.extents.z,
        mesh->GetSections().Size());

    if (mesh->GetVertexStride() != sizeof(StaticMeshVertex) || mesh->GetVertexCount() == 0) {
        return;
    }

    const auto* vertices = static_cast<const StaticMeshVertex*>(mesh->GetVertexData());
    XCEngine::Math::Vector2 uvMin(
        std::numeric_limits<float>::max(),
        std::numeric_limits<float>::max());
    XCEngine::Math::Vector2 uvMax(
        std::numeric_limits<float>::lowest(),
        std::numeric_limits<float>::lowest());
    for (uint32_t vertexIndex = 0; vertexIndex < mesh->GetVertexCount(); ++vertexIndex) {
        uvMin.x = std::min(uvMin.x, vertices[vertexIndex].uv0.x);
        uvMin.y = std::min(uvMin.y, vertices[vertexIndex].uv0.y);
        uvMax.x = std::max(uvMax.x, vertices[vertexIndex].uv0.x);
        uvMax.y = std::max(uvMax.y, vertices[vertexIndex].uv0.y);
    }

    const StaticMeshVertex& firstVertex = vertices[0];
    std::printf(
        "[NahidaDiag] %s firstVertex pos=(%.4f, %.4f, %.4f) normal=(%.4f, %.4f, %.4f) tangent=(%.4f, %.4f, %.4f) bitangent=(%.4f, %.4f, %.4f) uv0=(%.4f, %.4f) uv1=(%.4f, %.4f) color=(%.4f, %.4f, %.4f, %.4f)\n",
        label,
        firstVertex.position.x,
        firstVertex.position.y,
        firstVertex.position.z,
        firstVertex.normal.x,
        firstVertex.normal.y,
        firstVertex.normal.z,
        firstVertex.tangent.x,
        firstVertex.tangent.y,
        firstVertex.tangent.z,
        firstVertex.bitangent.x,
        firstVertex.bitangent.y,
        firstVertex.bitangent.z,
        firstVertex.uv0.x,
        firstVertex.uv0.y,
        firstVertex.uv1.x,
        firstVertex.uv1.y,
        firstVertex.color.x,
        firstVertex.color.y,
        firstVertex.color.z,
        firstVertex.color.w);
    std::printf(
        "[NahidaDiag] %s uvRange min=(%.4f, %.4f) max=(%.4f, %.4f)\n",
        label,
        uvMin.x,
        uvMin.y,
        uvMax.x,
        uvMax.y);
}

void DumpMaterialDiagnostics(const char* label, Material* material) {
    if (material == nullptr) {
        std::printf("[NahidaDiag] %s material=null\n", label);
        return;
    }

    std::printf(
        "[NahidaDiag] %s materialPath=%s shader=%s constants=%zu textures=%u keywords=%u renderQueue=%d\n",
        label,
        material->GetPath().CStr(),
        material->GetShader() != nullptr ? material->GetShader()->GetPath().CStr() : "<null>",
        material->GetConstantLayout().Size(),
        material->GetTextureBindingCount(),
        material->GetKeywordCount(),
        material->GetRenderQueue());

    std::printf(
        "[NahidaDiag] %s props _BaseColor=(%.3f, %.3f, %.3f, %.3f) _ShadowColor=(%.3f, %.3f, %.3f, %.3f) _UseNormalMap=%.3f _UseSpecular=%.3f _UseEmission=%.3f _UseRim=%.3f _IsFace=%.3f _UseCustomMaterialType=%.3f\n",
        label,
        material->GetFloat4("_BaseColor").x,
        material->GetFloat4("_BaseColor").y,
        material->GetFloat4("_BaseColor").z,
        material->GetFloat4("_BaseColor").w,
        material->GetFloat4("_ShadowColor").x,
        material->GetFloat4("_ShadowColor").y,
        material->GetFloat4("_ShadowColor").z,
        material->GetFloat4("_ShadowColor").w,
        material->GetFloat("_UseNormalMap"),
        material->GetFloat("_UseSpecular"),
        material->GetFloat("_UseEmission"),
        material->GetFloat("_UseRim"),
        material->GetFloat("_IsFace"),
        material->GetFloat("_UseCustomMaterialType"));

    for (uint32_t keywordIndex = 0; keywordIndex < material->GetKeywordCount(); ++keywordIndex) {
        std::printf("[NahidaDiag] %s keyword[%u]=%s\n", label, keywordIndex, material->GetKeyword(keywordIndex).CStr());
    }

    for (uint32_t bindingIndex = 0; bindingIndex < material->GetTextureBindingCount(); ++bindingIndex) {
        const ResourceHandle<Texture> textureHandle = material->GetTextureBindingTexture(bindingIndex);
        Texture* texture = textureHandle.Get();
        std::printf(
            "[NahidaDiag] %s texture[%u] name=%s path=%s loaded=%d resolved=%s\n",
            label,
            bindingIndex,
            material->GetTextureBindingName(bindingIndex).CStr(),
            material->GetTextureBindingPath(bindingIndex).CStr(),
            texture != nullptr ? 1 : 0,
            texture != nullptr ? texture->GetPath().CStr() : "<null>");
    }
}

void DumpSceneDiagnostics(Scene& scene) {
    RenderSceneExtractor extractor;
    RenderSceneData sceneData = extractor.Extract(scene, nullptr, kFrameWidth, kFrameHeight);
    std::printf(
        "[NahidaDiag] extracted cameraPos=(%.3f, %.3f, %.3f) visibleItems=%zu additionalLights=%u\n",
        sceneData.cameraData.worldPosition.x,
        sceneData.cameraData.worldPosition.y,
        sceneData.cameraData.worldPosition.z,
        sceneData.visibleItems.size(),
        sceneData.lighting.additionalLightCount);

    for (size_t visibleIndex = 0; visibleIndex < sceneData.visibleItems.size(); ++visibleIndex) {
        const VisibleRenderItem& item = sceneData.visibleItems[visibleIndex];
        const char* objectName = item.gameObject != nullptr ? item.gameObject->GetName().c_str() : "<null>";
        const char* meshPath = item.mesh != nullptr ? item.mesh->GetPath().CStr() : "<null>";
        const char* materialPath = item.material != nullptr ? item.material->GetPath().CStr() : "<null>";
        std::printf(
            "[NahidaDiag] visible[%zu] object=%s section=%u hasSection=%d materialIndex=%u queue=%d mesh=%s material=%s\n",
            visibleIndex,
            objectName,
            item.sectionIndex,
            item.hasSection ? 1 : 0,
            item.materialIndex,
            item.renderQueue,
            meshPath,
            materialPath);
    }
}

std::filesystem::path GetRepositoryRoot() {
    return std::filesystem::path(__FILE__).parent_path().parent_path().parent_path().parent_path().parent_path();
}

std::filesystem::path GetProjectRoot() {
    return GetRepositoryRoot() / "project";
}

std::filesystem::path GetScenePath() {
    return GetProjectRoot() / "Assets" / "Scenes" / "NahidaPreview.xc";
}

std::filesystem::path GetAssimpDllPath() {
    return GetRepositoryRoot() / "engine" / "third_party" / "assimp" / "bin" / "assimp-vc143-mt.dll";
}

class NahidaPreviewSceneTest : public RHIIntegrationFixture {
protected:
    void SetUp() override;
    void TearDown() override;
    void RenderFrame() override;

private:
    void InitializeProjectResources();
    void PreloadSceneResources();
    void PumpSceneLoads(std::chrono::milliseconds timeout);
    void TouchSceneMaterialsAndTextures();
    void ApplyIsolationFilter();
    void ApplyDiagnosticOverrides();
    void DumpTargetDiagnostics();
    RHIResourceView* GetCurrentBackBufferView();
    Material* CreateOverrideMaterial(const Material* sourceMaterial, const char* shaderPath, const GameObject* owner);

    HMODULE m_assimpModule = nullptr;
    std::unique_ptr<Scene> m_scene;
    std::unique_ptr<SceneRenderer> m_sceneRenderer;
    std::vector<std::unique_ptr<Material>> m_overrideMaterials;
    std::vector<RHIResourceView*> m_backBufferViews;
    RHITexture* m_depthTexture = nullptr;
    RHIResourceView* m_depthView = nullptr;
};

void NahidaPreviewSceneTest::SetUp() {
    RHIIntegrationFixture::SetUp();

    const std::filesystem::path assimpDllPath = GetAssimpDllPath();
    ASSERT_TRUE(std::filesystem::exists(assimpDllPath)) << assimpDllPath.string();
    m_assimpModule = LoadLibraryW(assimpDllPath.wstring().c_str());
    ASSERT_NE(m_assimpModule, nullptr);

    InitializeProjectResources();

    const std::filesystem::path scenePath = GetScenePath();
    ASSERT_TRUE(std::filesystem::exists(scenePath)) << scenePath.string();

    m_sceneRenderer = std::make_unique<SceneRenderer>();
    m_scene = std::make_unique<Scene>("NahidaPreview");
    m_scene->Load(scenePath.string());

    ASSERT_NE(m_scene->Find("Preview Camera"), nullptr);
    ASSERT_NE(m_scene->Find("NahidaUnityModel"), nullptr);
    ASSERT_NE(m_scene->Find("Body_Mesh0"), nullptr);
    ASSERT_NE(m_scene->Find("Face"), nullptr);

    PreloadSceneResources();

    auto* bodyMeshObject = m_scene->Find("Body_Mesh0");
    ASSERT_NE(bodyMeshObject, nullptr);
    auto* bodyMeshFilter = bodyMeshObject->GetComponent<MeshFilterComponent>();
    ASSERT_NE(bodyMeshFilter, nullptr);
    Mesh* bodyMesh = bodyMeshFilter->GetMesh();
    ASSERT_NE(bodyMesh, nullptr);
    EXPECT_TRUE(HasVertexAttribute(bodyMesh->GetVertexAttributes(), VertexAttribute::Color));
    EXPECT_TRUE(HasVertexAttribute(bodyMesh->GetVertexAttributes(), VertexAttribute::UV1));

    ApplyIsolationFilter();
    ApplyDiagnosticOverrides();
    DumpTargetDiagnostics();

    TextureDesc depthDesc = {};
    depthDesc.width = kFrameWidth;
    depthDesc.height = kFrameHeight;
    depthDesc.depth = 1;
    depthDesc.mipLevels = 1;
    depthDesc.arraySize = 1;
    depthDesc.format = static_cast<uint32_t>(Format::D24_UNorm_S8_UInt);
    depthDesc.textureType = static_cast<uint32_t>(XCEngine::RHI::TextureType::Texture2D);
    depthDesc.sampleCount = 1;
    depthDesc.sampleQuality = 0;
    depthDesc.flags = 0;
    m_depthTexture = GetDevice()->CreateTexture(depthDesc);
    ASSERT_NE(m_depthTexture, nullptr);

    ResourceViewDesc depthViewDesc = {};
    depthViewDesc.format = static_cast<uint32_t>(Format::D24_UNorm_S8_UInt);
    depthViewDesc.dimension = ResourceViewDimension::Texture2D;
    depthViewDesc.mipLevel = 0;
    m_depthView = GetDevice()->CreateDepthStencilView(m_depthTexture, depthViewDesc);
    ASSERT_NE(m_depthView, nullptr);

    m_backBufferViews.resize(2, nullptr);
}

void NahidaPreviewSceneTest::TearDown() {
    m_sceneRenderer.reset();

    if (m_depthView != nullptr) {
        m_depthView->Shutdown();
        delete m_depthView;
        m_depthView = nullptr;
    }

    if (m_depthTexture != nullptr) {
        m_depthTexture->Shutdown();
        delete m_depthTexture;
        m_depthTexture = nullptr;
    }

    for (RHIResourceView*& backBufferView : m_backBufferViews) {
        if (backBufferView != nullptr) {
            backBufferView->Shutdown();
            delete backBufferView;
            backBufferView = nullptr;
        }
    }
    m_backBufferViews.clear();

    m_scene.reset();

    ResourceManager& manager = ResourceManager::Get();
    manager.UnloadAll();
    manager.SetResourceRoot("");
    manager.Shutdown();

    if (m_assimpModule != nullptr) {
        FreeLibrary(m_assimpModule);
        m_assimpModule = nullptr;
    }

    RHIIntegrationFixture::TearDown();
}

void NahidaPreviewSceneTest::InitializeProjectResources() {
    ResourceManager& manager = ResourceManager::Get();
    manager.Initialize();
    manager.SetResourceRoot(GetProjectRoot().string().c_str());
}

void NahidaPreviewSceneTest::PreloadSceneResources() {
    ASSERT_NE(m_scene, nullptr);
    PumpSceneLoads(std::chrono::milliseconds(4000));
}

void NahidaPreviewSceneTest::PumpSceneLoads(std::chrono::milliseconds timeout) {
    ResourceManager& manager = ResourceManager::Get();
    const auto deadline = std::chrono::steady_clock::now() + timeout;

    do {
        TouchSceneMaterialsAndTextures();
        manager.UpdateAsyncLoads();

        if (!manager.IsAsyncLoading()) {
            TouchSceneMaterialsAndTextures();
            manager.UpdateAsyncLoads();
            if (!manager.IsAsyncLoading()) {
                break;
            }
        }

        std::this_thread::sleep_for(std::chrono::milliseconds(5));
    } while (std::chrono::steady_clock::now() < deadline);
}

void NahidaPreviewSceneTest::TouchSceneMaterialsAndTextures() {
    ASSERT_NE(m_scene, nullptr);

    const std::vector<MeshFilterComponent*> meshFilters = m_scene->FindObjectsOfType<MeshFilterComponent>();
    for (MeshFilterComponent* meshFilter : meshFilters) {
        if (meshFilter == nullptr) {
            continue;
        }

        Mesh* mesh = meshFilter->GetMesh();
        if (mesh == nullptr) {
            continue;
        }

        for (Material* material : mesh->GetMaterials()) {
            if (material == nullptr) {
                continue;
            }

            for (uint32_t bindingIndex = 0; bindingIndex < material->GetTextureBindingCount(); ++bindingIndex) {
                material->GetTextureBindingTexture(bindingIndex);
            }
        }
    }

    const std::vector<MeshRendererComponent*> meshRenderers = m_scene->FindObjectsOfType<MeshRendererComponent>();
    for (MeshRendererComponent* meshRenderer : meshRenderers) {
        if (meshRenderer == nullptr) {
            continue;
        }

        for (size_t materialIndex = 0; materialIndex < meshRenderer->GetMaterialCount(); ++materialIndex) {
            Material* material = meshRenderer->GetMaterial(materialIndex);
            if (material == nullptr) {
                continue;
            }

            for (uint32_t bindingIndex = 0; bindingIndex < material->GetTextureBindingCount(); ++bindingIndex) {
                material->GetTextureBindingTexture(bindingIndex);
            }
        }
    }
}

void NahidaPreviewSceneTest::ApplyIsolationFilter() {
    ASSERT_NE(m_scene, nullptr);

    const std::unordered_set<std::string> isolatedObjects = GetIsolationObjectNames();
    if (isolatedObjects.empty()) {
        return;
    }

    std::printf("[NahidaDiag] isolation=");
    bool first = true;
    for (const std::string& name : isolatedObjects) {
        std::printf("%s%s", first ? "" : ",", name.c_str());
        first = false;
    }
    std::printf("\n");

    const std::vector<MeshRendererComponent*> meshRenderers = m_scene->FindObjectsOfType<MeshRendererComponent>();
    for (MeshRendererComponent* meshRenderer : meshRenderers) {
        if (meshRenderer == nullptr || meshRenderer->GetGameObject() == nullptr) {
            continue;
        }

        GameObject* gameObject = meshRenderer->GetGameObject();
        const bool keep = isolatedObjects.find(gameObject->GetName()) != isolatedObjects.end();
        gameObject->SetActive(keep);
    }
}

Material* NahidaPreviewSceneTest::CreateOverrideMaterial(
    const Material* sourceMaterial,
    const char* shaderPath,
    const GameObject* owner) {
    if (sourceMaterial == nullptr || shaderPath == nullptr) {
        return nullptr;
    }

    const ResourceHandle<Shader> shader = ResourceManager::Get().Load<Shader>(shaderPath);
    if (shader.Get() == nullptr) {
        return nullptr;
    }

    auto material = std::make_unique<Material>();
    IResource::ConstructParams params = {};
    params.name = XCEngine::Containers::String("NahidaDiagnosticMaterial");
    params.path = XCEngine::Containers::String(("memory://nahida/" + std::string(shaderPath)).c_str());
    params.guid = ResourceGUID::Generate(params.path);
    material->Initialize(params);
    material->SetShader(shader);
    material->SetRenderQueue(sourceMaterial->GetRenderQueue());
    if (std::string(shaderPath) == kToonShaderPath) {
        ApplyNahidaToonRecipe(material.get(), owner);
    } else {
        if (sourceMaterial->HasRenderStateOverride()) {
            material->SetRenderState(sourceMaterial->GetRenderState());
        }

        for (uint32_t tagIndex = 0; tagIndex < sourceMaterial->GetTagCount(); ++tagIndex) {
            material->SetTag(sourceMaterial->GetTagName(tagIndex), sourceMaterial->GetTagValue(tagIndex));
        }

        for (uint32_t keywordIndex = 0; keywordIndex < sourceMaterial->GetKeywordCount(); ++keywordIndex) {
            material->EnableKeyword(sourceMaterial->GetKeyword(keywordIndex));
        }

        for (const MaterialProperty& property : sourceMaterial->GetProperties()) {
            const XCEngine::Containers::String targetName = RemapMaterialPropertyName(*material, property.name);
            if (targetName.Empty()) {
                continue;
            }

            switch (property.type) {
            case MaterialPropertyType::Float:
                material->SetFloat(targetName, property.value.floatValue[0]);
                break;
            case MaterialPropertyType::Float2:
                material->SetFloat2(
                    targetName,
                    XCEngine::Math::Vector2(property.value.floatValue[0], property.value.floatValue[1]));
                break;
            case MaterialPropertyType::Float3:
                material->SetFloat3(
                    targetName,
                    XCEngine::Math::Vector3(
                        property.value.floatValue[0],
                        property.value.floatValue[1],
                        property.value.floatValue[2]));
                break;
            case MaterialPropertyType::Float4:
                material->SetFloat4(
                    targetName,
                    XCEngine::Math::Vector4(
                        property.value.floatValue[0],
                        property.value.floatValue[1],
                        property.value.floatValue[2],
                        property.value.floatValue[3]));
                break;
            case MaterialPropertyType::Int:
                material->SetInt(targetName, property.value.intValue[0]);
                break;
            case MaterialPropertyType::Bool:
                material->SetBool(targetName, property.value.boolValue);
                break;
            case MaterialPropertyType::Texture:
            case MaterialPropertyType::Cubemap:
            case MaterialPropertyType::Int2:
            case MaterialPropertyType::Int3:
            case MaterialPropertyType::Int4:
            default:
                break;
            }
        }

        for (uint32_t bindingIndex = 0; bindingIndex < sourceMaterial->GetTextureBindingCount(); ++bindingIndex) {
            const XCEngine::Containers::String sourceName = sourceMaterial->GetTextureBindingName(bindingIndex);
            const XCEngine::Containers::String targetName = RemapMaterialPropertyName(*material, sourceName);
            if (targetName.Empty()) {
                continue;
            }

            const ResourceHandle<Texture> texture = sourceMaterial->GetTextureBindingTexture(bindingIndex);
            if (texture.Get() != nullptr) {
                material->SetTexture(targetName, texture);
                continue;
            }

            const AssetRef textureRef = sourceMaterial->GetTextureBindingAssetRef(bindingIndex);
            const XCEngine::Containers::String texturePath = sourceMaterial->GetTextureBindingPath(bindingIndex);
            if (textureRef.IsValid() || !texturePath.Empty()) {
                material->SetTextureAssetRef(targetName, textureRef, texturePath);
            }
        }
    }

    m_overrideMaterials.push_back(std::move(material));
    return m_overrideMaterials.back().get();
}

void NahidaPreviewSceneTest::ApplyDiagnosticOverrides() {
    ASSERT_NE(m_scene, nullptr);

    const DiagnosticMode mode = GetDiagnosticMode();
    std::printf("[NahidaDiag] diagnosticMode=%s\n", GetDiagnosticModeName(mode));

    if (mode == DiagnosticMode::NoShadows) {
        const std::vector<LightComponent*> lights = m_scene->FindObjectsOfType<LightComponent>();
        for (LightComponent* light : lights) {
            if (light != nullptr) {
                light->SetCastsShadows(false);
            }
        }
        return;
    }

    const char* shaderPath = nullptr;
    switch (mode) {
    case DiagnosticMode::Toon:
        shaderPath = "Assets/Shaders/Toon.shader";
        break;
    case DiagnosticMode::ForwardLit:
        shaderPath = "builtin://shaders/forward-lit";
        break;
    case DiagnosticMode::Unlit:
        shaderPath = "builtin://shaders/unlit";
        break;
    case DiagnosticMode::NoShadows:
    default:
        return;
    }

    const std::vector<MeshRendererComponent*> meshRenderers = m_scene->FindObjectsOfType<MeshRendererComponent>();
    for (MeshRendererComponent* meshRenderer : meshRenderers) {
        if (meshRenderer == nullptr || !IsNahidaCharacterRenderable(meshRenderer->GetGameObject())) {
            continue;
        }

        auto* meshFilter = meshRenderer->GetGameObject()->GetComponent<MeshFilterComponent>();
        Mesh* mesh = meshFilter != nullptr ? meshFilter->GetMesh() : nullptr;
        const size_t materialCount = std::max(
            meshRenderer->GetMaterialCount(),
            mesh != nullptr ? static_cast<size_t>(mesh->GetMaterials().Size()) : 0u);
        for (size_t materialIndex = 0; materialIndex < materialCount; ++materialIndex) {
            const Material* sourceMaterial = nullptr;
            if (materialIndex < meshRenderer->GetMaterialCount()) {
                sourceMaterial = meshRenderer->GetMaterial(materialIndex);
            }
            if (sourceMaterial == nullptr && mesh != nullptr && materialIndex < mesh->GetMaterials().Size()) {
                sourceMaterial = mesh->GetMaterial(static_cast<uint32_t>(materialIndex));
            }
            if (sourceMaterial == nullptr || sourceMaterial->GetShader() == nullptr) {
                continue;
            }

            Material* overrideMaterial = CreateOverrideMaterial(sourceMaterial, shaderPath, meshRenderer->GetGameObject());
            if (overrideMaterial != nullptr) {
                meshRenderer->SetMaterial(materialIndex, overrideMaterial);
            }
        }
    }
}

void NahidaPreviewSceneTest::DumpTargetDiagnostics() {
    ASSERT_NE(m_scene, nullptr);

    DumpSceneDiagnostics(*m_scene);

    const char* const targetObjects[] = {
        "Body_Mesh0",
        "Body_Mesh1",
        "Body_Mesh2",
        "Body_Mesh3",
        "Brow",
        "EyeStar",
        "Face",
        "Face_Eye"
    };

    for (const char* objectName : targetObjects) {
        GameObject* gameObject = m_scene->Find(objectName);
        if (gameObject == nullptr) {
            std::printf("[NahidaDiag] object=%s missing\n", objectName);
            continue;
        }

        auto* meshFilter = gameObject->GetComponent<MeshFilterComponent>();
        auto* meshRenderer = gameObject->GetComponent<MeshRendererComponent>();
        std::printf(
            "[NahidaDiag] object=%s materialCount=%zu active=%d\n",
            objectName,
            meshRenderer != nullptr ? meshRenderer->GetMaterialCount() : 0u,
            gameObject->IsActiveInHierarchy() ? 1 : 0);

        DumpMeshDiagnostics(objectName, meshFilter != nullptr ? meshFilter->GetMesh() : nullptr);

        if (meshRenderer == nullptr) {
            continue;
        }

        for (size_t materialIndex = 0; materialIndex < meshRenderer->GetMaterialCount(); ++materialIndex) {
            std::string label = std::string(objectName) + "#mat" + std::to_string(materialIndex);
            DumpMaterialDiagnostics(label.c_str(), meshRenderer->GetMaterial(materialIndex));
        }
    }
}

RHIResourceView* NahidaPreviewSceneTest::GetCurrentBackBufferView() {
    const int backBufferIndex = GetCurrentBackBufferIndex();
    if (backBufferIndex < 0) {
        return nullptr;
    }

    if (static_cast<size_t>(backBufferIndex) >= m_backBufferViews.size()) {
        m_backBufferViews.resize(static_cast<size_t>(backBufferIndex) + 1, nullptr);
    }

    if (m_backBufferViews[backBufferIndex] == nullptr) {
        ResourceViewDesc viewDesc = {};
        viewDesc.format = static_cast<uint32_t>(Format::R8G8B8A8_UNorm);
        viewDesc.dimension = ResourceViewDimension::Texture2D;
        viewDesc.mipLevel = 0;
        m_backBufferViews[backBufferIndex] = GetDevice()->CreateRenderTargetView(GetCurrentBackBuffer(), viewDesc);
    }

    return m_backBufferViews[backBufferIndex];
}

void NahidaPreviewSceneTest::RenderFrame() {
    ASSERT_NE(m_scene, nullptr);
    ASSERT_NE(m_sceneRenderer, nullptr);

    TouchSceneMaterialsAndTextures();
    ResourceManager::Get().UpdateAsyncLoads();

    RHICommandList* commandList = GetCommandList();
    ASSERT_NE(commandList, nullptr);

    commandList->Reset();

    RenderSurface surface(kFrameWidth, kFrameHeight);
    surface.SetColorAttachment(GetCurrentBackBufferView());
    surface.SetDepthAttachment(m_depthView);

    RenderContext renderContext = {};
    renderContext.device = GetDevice();
    renderContext.commandList = commandList;
    renderContext.commandQueue = GetCommandQueue();
    renderContext.backendType = GetBackendType();

    ASSERT_TRUE(m_sceneRenderer->Render(*m_scene, nullptr, renderContext, surface));

    commandList->Close();
    void* commandLists[] = { commandList };
    GetCommandQueue()->ExecuteCommandLists(1, commandLists);
}

TEST_P(NahidaPreviewSceneTest, RenderNahidaPreviewScene) {
    RHICommandQueue* commandQueue = GetCommandQueue();
    RHISwapChain* swapChain = GetSwapChain();
    ASSERT_NE(commandQueue, nullptr);
    ASSERT_NE(swapChain, nullptr);
    const DiagnosticMode diagnosticMode = GetDiagnosticMode();
    const char* goldenFileName = GetGoldenFileName(diagnosticMode);

    for (int frameIndex = 0; frameIndex <= kWarmupFrames; ++frameIndex) {
        if (frameIndex > 0) {
            commandQueue->WaitForPreviousFrame();
        }

        BeginRender();
        RenderFrame();

        if (frameIndex >= kWarmupFrames) {
            commandQueue->WaitForIdle();
            ASSERT_TRUE(TakeScreenshot(kD3D12Screenshot));

            const PpmImage image = LoadPpmImage(kD3D12Screenshot);
            ASSERT_EQ(image.width, kFrameWidth);
            ASSERT_EQ(image.height, kFrameHeight);

            const std::filesystem::path gtPath = ResolveRuntimePath(goldenFileName);
            if (!std::filesystem::exists(gtPath)) {
                GTEST_SKIP() << goldenFileName << " missing, screenshot captured for manual review: " << kD3D12Screenshot;
            }

            ASSERT_TRUE(CompareWithGoldenTemplate(kD3D12Screenshot, goldenFileName, 10.0f));
            break;
        }

        swapChain->Present(0, 0);
    }
}

} // namespace

INSTANTIATE_TEST_SUITE_P(D3D12, NahidaPreviewSceneTest, ::testing::Values(RHIType::D3D12));

GTEST_API_ int main(int argc, char** argv) {
    return RunRenderingIntegrationTestMain(argc, argv);
}