#define NOMINMAX
#include <windows.h>

#include <gtest/gtest.h>

#include "../RenderingIntegrationMain.h"

#include <XCEngine/Components/CameraComponent.h>
#include <XCEngine/Components/GameObject.h>
#include <XCEngine/Components/MeshFilterComponent.h>
#include <XCEngine/Components/MeshRendererComponent.h>
#include <XCEngine/Core/Asset/IResource.h>
#include <XCEngine/Core/Math/Color.h>
#include <XCEngine/Core/Math/Quaternion.h>
#include <XCEngine/Core/Math/Vector2.h>
#include <XCEngine/Core/Math/Vector3.h>
#include <XCEngine/Debug/ConsoleLogSink.h>
#include <XCEngine/Debug/Logger.h>
#include <XCEngine/Rendering/RenderContext.h>
#include <XCEngine/Rendering/RenderSurface.h>
#include <XCEngine/Rendering/Execution/SceneRenderer.h>
#include <XCEngine/Resources/Material/Material.h>
#include <XCEngine/Resources/Mesh/Mesh.h>
#include <XCEngine/Resources/Mesh/MeshImportSettings.h>
#include <XCEngine/Resources/Mesh/MeshLoader.h>
#include <XCEngine/Resources/Texture/Texture.h>
#include <XCEngine/RHI/RHITexture.h>
#include <XCEngine/Scene/Scene.h>

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

#include <algorithm>
#include <filesystem>
#include <memory>
#include <vector>

using namespace XCEngine::Components;
using namespace XCEngine::Debug;
using namespace XCEngine::Math;
using namespace XCEngine::Rendering;
using namespace XCEngine::Resources;
using namespace XCEngine::RHI;
using namespace XCEngine::RHI::Integration;

namespace {

constexpr const char* kD3D12Screenshot = "camera_stack_scene_d3d12.ppm";
constexpr const char* kOpenGLScreenshot = "camera_stack_scene_opengl.ppm";
constexpr const char* kVulkanScreenshot = "camera_stack_scene_vulkan.ppm";
constexpr uint32_t kFrameWidth = 1280;
constexpr uint32_t kFrameHeight = 720;
constexpr uint8_t kBaseLayer = 0;
constexpr uint8_t kOverlayLayer = 1;

std::filesystem::path GetExecutableDirectory() {
    char exePath[MAX_PATH] = {};
    const DWORD length = GetModuleFileNameA(nullptr, exePath, MAX_PATH);
    if (length == 0 || length >= MAX_PATH) {
        return std::filesystem::current_path();
    }

    return std::filesystem::path(exePath).parent_path();
}

std::filesystem::path ResolveRuntimePath(const char* relativePath) {
    return GetExecutableDirectory() / relativePath;
}

Mesh* CreateQuadMesh() {
    auto* mesh = new Mesh();
    IResource::ConstructParams params = {};
    params.name = "CameraStackQuad";
    params.path = "Tests/Rendering/CameraStackQuad.mesh";
    params.guid = ResourceGUID::Generate(params.path);
    mesh->Initialize(params);

    StaticMeshVertex vertices[4] = {};
    vertices[0].position = Vector3(-1.0f, -1.0f, 0.0f);
    vertices[0].uv0 = Vector2(0.0f, 1.0f);
    vertices[1].position = Vector3(-1.0f, 1.0f, 0.0f);
    vertices[1].uv0 = Vector2(0.0f, 0.0f);
    vertices[2].position = Vector3(1.0f, -1.0f, 0.0f);
    vertices[2].uv0 = Vector2(1.0f, 1.0f);
    vertices[3].position = Vector3(1.0f, 1.0f, 0.0f);
    vertices[3].uv0 = Vector2(1.0f, 0.0f);

    const uint32_t indices[6] = { 0, 1, 2, 2, 1, 3 };
    mesh->SetVertexData(
        vertices,
        sizeof(vertices),
        4,
        sizeof(StaticMeshVertex),
        VertexAttribute::Position | VertexAttribute::UV0);
    mesh->SetIndexData(indices, sizeof(indices), 6, true);

    MeshSection section = {};
    section.baseVertex = 0;
    section.vertexCount = 4;
    section.startIndex = 0;
    section.indexCount = 6;
    section.materialID = 0;
    mesh->AddSection(section);

    return mesh;
}

Texture* CreateCheckerTexture() {
    auto* texture = new Texture();
    IResource::ConstructParams params = {};
    params.name = "CameraStackChecker";
    params.path = "Tests/Rendering/CameraStackChecker.texture";
    params.guid = ResourceGUID::Generate(params.path);
    texture->Initialize(params);

    const unsigned char pixels[16] = {
        250, 120,  32, 255,
         24,  36, 220, 255,
         32, 200, 120, 255,
        250, 240,  80, 255
    };
    texture->Create(
        2,
        2,
        1,
        1,
        XCEngine::Resources::TextureType::Texture2D,
        XCEngine::Resources::TextureFormat::RGBA8_UNORM,
        pixels,
        sizeof(pixels));
    return texture;
}

Material* CreateQuadMaterial(Texture* texture) {
    auto* material = new Material();
    IResource::ConstructParams params = {};
    params.name = "CameraStackQuadMaterial";
    params.path = "Tests/Rendering/CameraStackQuad.material";
    params.guid = ResourceGUID::Generate(params.path);
    material->Initialize(params);
    material->SetTexture("_BaseColorTexture", ResourceHandle<Texture>(texture));
    return material;
}

const char* GetScreenshotFilename(RHIType backendType) {
    switch (backendType) {
        case RHIType::D3D12:
            return kD3D12Screenshot;
        case RHIType::Vulkan:
            return kVulkanScreenshot;
        case RHIType::OpenGL:
        default:
            return kOpenGLScreenshot;
    }
}

int GetComparisonThreshold(RHIType backendType) {
    return backendType == RHIType::D3D12 ? 8 : 8;
}

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

private:
    void LoadBackpackMesh();
    void BuildScene();
    RHIResourceView* GetCurrentBackBufferView();

    std::unique_ptr<Scene> mScene;
    std::unique_ptr<SceneRenderer> mSceneRenderer;
    std::vector<RHIResourceView*> mBackBufferViews;
    RHITexture* mDepthTexture = nullptr;
    RHIResourceView* mDepthView = nullptr;
    Mesh* mBackpackMesh = nullptr;
    Mesh* mQuadMesh = nullptr;
    Material* mQuadMaterial = nullptr;
    Texture* mQuadTexture = nullptr;
};

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

    mSceneRenderer = std::make_unique<SceneRenderer>();
    mScene = std::make_unique<Scene>("CameraStackScene");

    LoadBackpackMesh();
    mQuadMesh = CreateQuadMesh();
    mQuadTexture = CreateCheckerTexture();
    mQuadMaterial = CreateQuadMaterial(mQuadTexture);
    BuildScene();

    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;
    mDepthTexture = GetDevice()->CreateTexture(depthDesc);
    ASSERT_NE(mDepthTexture, nullptr);

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

    mBackBufferViews.resize(2, nullptr);
}

void CameraStackSceneTest::TearDown() {
    mSceneRenderer.reset();

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

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

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

    mScene.reset();

    delete mQuadMaterial;
    mQuadMaterial = nullptr;
    delete mQuadTexture;
    mQuadTexture = nullptr;
    delete mQuadMesh;
    mQuadMesh = nullptr;

    if (mBackpackMesh != nullptr) {
        delete mBackpackMesh;
        mBackpackMesh = nullptr;
    }

    RHIIntegrationFixture::TearDown();
}

void CameraStackSceneTest::LoadBackpackMesh() {
    const std::filesystem::path meshPath = ResolveRuntimePath("Res/models/backpack/backpack.obj");

    MeshLoader loader;
    MeshImportSettings settings;
    LoadResult result = loader.Load(meshPath.string().c_str(), &settings);
    ASSERT_TRUE(result);
    ASSERT_NE(result.resource, nullptr);

    mBackpackMesh = static_cast<Mesh*>(result.resource);
    ASSERT_NE(mBackpackMesh, nullptr);
    ASSERT_TRUE(mBackpackMesh->IsValid());
    ASSERT_GT(mBackpackMesh->GetVertexCount(), 0u);
    ASSERT_GT(mBackpackMesh->GetSections().Size(), 0u);
}

void CameraStackSceneTest::BuildScene() {
    ASSERT_NE(mScene, nullptr);
    ASSERT_NE(mBackpackMesh, nullptr);
    ASSERT_NE(mQuadMesh, nullptr);
    ASSERT_NE(mQuadMaterial, nullptr);

    GameObject* baseCameraObject = mScene->CreateGameObject("BaseCamera");
    auto* baseCamera = baseCameraObject->AddComponent<CameraComponent>();
    baseCamera->SetPrimary(true);
    baseCamera->SetDepth(0.0f);
    baseCamera->SetFieldOfView(45.0f);
    baseCamera->SetNearClipPlane(0.1f);
    baseCamera->SetFarClipPlane(100.0f);
    baseCamera->SetStackType(CameraStackType::Base);
    baseCamera->SetCullingMask(1u << kBaseLayer);
    baseCamera->SetClearColor(XCEngine::Math::Color(0.03f, 0.05f, 0.09f, 1.0f));

    GameObject* overlayCameraObject = mScene->CreateGameObject("OverlayCamera");
    auto* overlayCamera = overlayCameraObject->AddComponent<CameraComponent>();
    overlayCamera->SetPrimary(false);
    overlayCamera->SetDepth(1.0f);
    overlayCamera->SetProjectionType(CameraProjectionType::Orthographic);
    overlayCamera->SetOrthographicSize(1.0f);
    overlayCamera->SetNearClipPlane(0.1f);
    overlayCamera->SetFarClipPlane(10.0f);
    overlayCamera->SetStackType(CameraStackType::Overlay);
    overlayCamera->SetCullingMask(1u << kOverlayLayer);
    overlayCamera->SetClearMode(CameraClearMode::ColorAndDepth);
    overlayCamera->SetViewportRect(XCEngine::Math::Rect(0.60f, 0.10f, 0.28f, 0.32f));
    overlayCamera->SetClearColor(XCEngine::Math::Color(0.11f, 0.16f, 0.24f, 1.0f));

    const Vector3 boundsMin = mBackpackMesh->GetBounds().GetMin();
    const Vector3 boundsMax = mBackpackMesh->GetBounds().GetMax();
    const Vector3 center(
        (boundsMin.x + boundsMax.x) * 0.5f,
        (boundsMin.y + boundsMax.y) * 0.5f,
        (boundsMin.z + boundsMax.z) * 0.5f);
    const float sizeX = std::max(boundsMax.x - boundsMin.x, 0.001f);
    const float sizeY = std::max(boundsMax.y - boundsMin.y, 0.001f);
    const float sizeZ = std::max(boundsMax.z - boundsMin.z, 0.001f);
    const float maxExtent = std::max(sizeX, std::max(sizeY, sizeZ));
    const float uniformScale = 1.8f / maxExtent;

    GameObject* root = mScene->CreateGameObject("BackpackRoot");
    root->GetTransform()->SetLocalPosition(Vector3(0.0f, 0.08f, 3.0f));

    GameObject* rotateY = mScene->CreateGameObject("BackpackRotateY");
    rotateY->SetParent(root, false);
    rotateY->GetTransform()->SetLocalRotation(Quaternion::FromAxisAngle(Vector3::Up(), -0.35f));

    GameObject* rotateX = mScene->CreateGameObject("BackpackRotateX");
    rotateX->SetParent(rotateY, false);
    rotateX->GetTransform()->SetLocalRotation(Quaternion::FromAxisAngle(Vector3::Right(), -0.18f));

    GameObject* scale = mScene->CreateGameObject("BackpackScale");
    scale->SetParent(rotateX, false);
    scale->GetTransform()->SetLocalScale(Vector3(uniformScale, uniformScale, uniformScale));

    GameObject* backpackObject = mScene->CreateGameObject("BackpackMesh");
    backpackObject->SetParent(scale, false);
    backpackObject->SetLayer(kBaseLayer);
    backpackObject->GetTransform()->SetLocalPosition(Vector3(-center.x, -center.y, -center.z));

    auto* backpackMeshFilter = backpackObject->AddComponent<MeshFilterComponent>();
    auto* backpackMeshRenderer = backpackObject->AddComponent<MeshRendererComponent>();
    backpackMeshFilter->SetMesh(ResourceHandle<Mesh>(mBackpackMesh));
    backpackMeshRenderer->ClearMaterials();

    GameObject* overlayQuadObject = mScene->CreateGameObject("OverlayQuad");
    overlayQuadObject->SetLayer(kOverlayLayer);
    overlayQuadObject->GetTransform()->SetLocalPosition(Vector3(0.0f, 0.0f, 2.0f));
    overlayQuadObject->GetTransform()->SetLocalScale(Vector3(0.70f, 0.70f, 1.0f));

    auto* overlayMeshFilter = overlayQuadObject->AddComponent<MeshFilterComponent>();
    auto* overlayMeshRenderer = overlayQuadObject->AddComponent<MeshRendererComponent>();
    overlayMeshFilter->SetMesh(ResourceHandle<Mesh>(mQuadMesh));
    overlayMeshRenderer->SetMaterial(0, ResourceHandle<Material>(mQuadMaterial));
}

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

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

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

    return mBackBufferViews[backBufferIndex];
}

void CameraStackSceneTest::RenderFrame() {
    ASSERT_NE(mScene, nullptr);
    ASSERT_NE(mSceneRenderer, nullptr);

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

    commandList->Reset();

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

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

    ASSERT_TRUE(mSceneRenderer->Render(*mScene, nullptr, renderContext, surface));

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

TEST_P(CameraStackSceneTest, RenderCameraStackScene) {
    RHICommandQueue* commandQueue = GetCommandQueue();
    RHISwapChain* swapChain = GetSwapChain();
    const int targetFrameCount = 30;
    const char* screenshotFilename = GetScreenshotFilename(GetBackendType());
    const int comparisonThreshold = GetComparisonThreshold(GetBackendType());

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

        BeginRender();
        RenderFrame();

        if (frameCount >= targetFrameCount) {
            commandQueue->WaitForIdle();
            ASSERT_TRUE(TakeScreenshot(screenshotFilename));
            ASSERT_TRUE(CompareWithGoldenTemplate(
                screenshotFilename,
                "GT.ppm",
                static_cast<float>(comparisonThreshold)));
            break;
        }

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

} // namespace

INSTANTIATE_TEST_SUITE_P(D3D12, CameraStackSceneTest, ::testing::Values(RHIType::D3D12));
INSTANTIATE_TEST_SUITE_P(OpenGL, CameraStackSceneTest, ::testing::Values(RHIType::OpenGL));
#if defined(XCENGINE_SUPPORT_VULKAN)
INSTANTIATE_TEST_SUITE_P(Vulkan, CameraStackSceneTest, ::testing::Values(RHIType::Vulkan));
#endif

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