#include <gtest/gtest.h>

#include "Viewport/SceneViewportResourcePaths.h"
#include "Viewport/SceneViewportShaderPaths.h"

#include <XCEngine/Core/Asset/ResourceManager.h>
#include <XCEngine/Resources/Shader/ShaderLoader.h>

#include <filesystem>
#include <string>

namespace {

using XCEngine::Editor::GetSceneViewportCameraGizmoIconPath;
using XCEngine::Editor::GetSceneViewportInfiniteGridShaderPath;
using XCEngine::Editor::GetSceneViewportMainLightGizmoIconPath;
using XCEngine::Editor::GetSceneViewportObjectIdOutlineShaderPath;
using XCEngine::Resources::LoadResult;
using XCEngine::Resources::ResourceHandle;
using XCEngine::Resources::ResourceManager;
using XCEngine::Resources::Shader;
using XCEngine::Resources::ShaderBackend;
using XCEngine::Resources::ShaderLoader;
using XCEngine::Resources::ShaderPass;
using XCEngine::Resources::ShaderStageVariant;
using XCEngine::Resources::ShaderType;

TEST(SceneViewportShaderPathsTest, ResolvePathsUnderEditorResources) {
    const std::filesystem::path gridPath(GetSceneViewportInfiniteGridShaderPath().CStr());
    const std::filesystem::path outlinePath(GetSceneViewportObjectIdOutlineShaderPath().CStr());
    const std::filesystem::path cameraIconPath(GetSceneViewportCameraGizmoIconPath().CStr());
    const std::filesystem::path lightIconPath(GetSceneViewportMainLightGizmoIconPath().CStr());

    EXPECT_TRUE(gridPath.is_absolute());
    EXPECT_TRUE(outlinePath.is_absolute());
    EXPECT_TRUE(cameraIconPath.is_absolute());
    EXPECT_TRUE(lightIconPath.is_absolute());
    EXPECT_TRUE(std::filesystem::exists(gridPath));
    EXPECT_TRUE(std::filesystem::exists(outlinePath));
    EXPECT_TRUE(std::filesystem::exists(cameraIconPath));
    EXPECT_TRUE(std::filesystem::exists(lightIconPath));
    EXPECT_NE(gridPath.generic_string().find("editor/resources/shaders/scene-viewport"), std::string::npos);
    EXPECT_NE(outlinePath.generic_string().find("editor/resources/shaders/scene-viewport"), std::string::npos);
    EXPECT_NE(cameraIconPath.generic_string().find("editor/resources/Icons"), std::string::npos);
    EXPECT_NE(lightIconPath.generic_string().find("editor/resources/Icons"), std::string::npos);
}

TEST(SceneViewportShaderPathsTest, ShaderLoaderLoadsSceneViewportInfiniteGridShader) {
    ShaderLoader loader;
    const auto shaderPath = GetSceneViewportInfiniteGridShaderPath();
    EXPECT_TRUE(loader.CanLoad(shaderPath));

    LoadResult result = loader.Load(shaderPath);
    ASSERT_TRUE(result);
    ASSERT_NE(result.resource, nullptr);

    auto* shader = static_cast<Shader*>(result.resource);
    ASSERT_NE(shader, nullptr);
    ASSERT_TRUE(shader->IsValid());

    const ShaderPass* pass = shader->FindPass("InfiniteGrid");
    ASSERT_NE(pass, nullptr);
    ASSERT_EQ(pass->variants.Size(), 2u);
    ASSERT_EQ(pass->tags.Size(), 1u);
    EXPECT_EQ(pass->tags[0].name, "LightMode");
    EXPECT_EQ(pass->tags[0].value, "InfiniteGrid");

    const ShaderStageVariant* fragment = shader->FindVariant(
        "InfiniteGrid",
        ShaderType::Fragment,
        ShaderBackend::D3D12);
    ASSERT_NE(fragment, nullptr);
    EXPECT_NE(
        std::string(fragment->sourceCode.CStr()).find("XC_EDITOR_SCENE_VIEW_INFINITE_GRID_D3D12_PS"),
        std::string::npos);

    delete shader;
}

TEST(SceneViewportShaderPathsTest, ResourceManagerLoadsSceneViewportOutlineShaderByResolvedPath) {
    ResourceManager& manager = ResourceManager::Get();
    manager.Shutdown();

    const ResourceHandle<Shader> shaderHandle = manager.Load<Shader>(GetSceneViewportObjectIdOutlineShaderPath());
    ASSERT_TRUE(shaderHandle.IsValid());

    const ShaderPass* pass = shaderHandle->FindPass("ObjectIdOutline");
    ASSERT_NE(pass, nullptr);
    ASSERT_EQ(pass->variants.Size(), 2u);

    const ShaderStageVariant* fragment = shaderHandle->FindVariant(
        "ObjectIdOutline",
        ShaderType::Fragment,
        ShaderBackend::D3D12);
    ASSERT_NE(fragment, nullptr);
    EXPECT_NE(
        std::string(fragment->sourceCode.CStr()).find("XC_EDITOR_SCENE_VIEW_OBJECT_ID_OUTLINE_D3D12_PS"),
        std::string::npos);

    manager.Shutdown();
}

} // namespace