#include <gtest/gtest.h>

#include <XCEngine/Rendering/GraphicsSettingsState.h>

#include <memory>
#include <utility>

using namespace XCEngine::Rendering;

namespace {

class DummyManagedRenderPipelineBridge final
    : public Pipelines::ManagedRenderPipelineBridge {
};

class GraphicsSettingsStateScope final {
public:
    GraphicsSettingsStateScope()
        : m_savedDescriptor(
            GetGraphicsSettingsState().GetRenderPipelineAssetDescriptor())
        , m_savedBridge(
            GetGraphicsSettingsState().GetManagedRenderPipelineBridge()) {
    }

    ~GraphicsSettingsStateScope() {
        GraphicsSettingsState& state = GetGraphicsSettingsState();
        if (m_savedBridge != nullptr) {
            state.SetManagedRenderPipelineBridge(m_savedBridge);
        } else {
            state.ClearManagedRenderPipelineBridge();
        }

        if (m_savedDescriptor.IsValid() ||
            m_savedDescriptor.managedAssetHandle != 0u) {
            state.SetRenderPipelineAssetDescriptor(m_savedDescriptor);
        } else {
            state.ClearRenderPipelineAssetDescriptor();
        }
    }

private:
    Pipelines::ManagedRenderPipelineAssetDescriptor m_savedDescriptor = {};
    std::shared_ptr<const Pipelines::ManagedRenderPipelineBridge> m_savedBridge =
        nullptr;
};

} // namespace

TEST(GraphicsSettingsState_Test, StoresRenderPipelineAssetDescriptorAndBumpsEnvironmentGeneration) {
    GraphicsSettingsStateScope scope;
    GraphicsSettingsState& state = GetGraphicsSettingsState();
    state.ClearRenderPipelineAssetDescriptor();

    const size_t generationBefore = state.GetEnvironmentGeneration();
    const Pipelines::ManagedRenderPipelineAssetDescriptor descriptor = {
        "XCEngine.GameScripts",
        "Gameplay",
        "ManagedForwardRenderPipelineProbeAsset",
        42u
    };

    state.SetRenderPipelineAssetDescriptor(descriptor);

    const Pipelines::ManagedRenderPipelineAssetDescriptor resolved =
        state.GetRenderPipelineAssetDescriptor();
    EXPECT_EQ(resolved.assemblyName, descriptor.assemblyName);
    EXPECT_EQ(resolved.namespaceName, descriptor.namespaceName);
    EXPECT_EQ(resolved.className, descriptor.className);
    EXPECT_EQ(resolved.managedAssetHandle, descriptor.managedAssetHandle);
    EXPECT_GT(state.GetEnvironmentGeneration(), generationBefore);
}

TEST(GraphicsSettingsState_Test, StoresManagedBridgeAndBumpsBridgeAndEnvironmentGenerations) {
    GraphicsSettingsStateScope scope;
    GraphicsSettingsState& state = GetGraphicsSettingsState();
    state.ClearManagedRenderPipelineBridge();

    const size_t environmentGenerationBefore =
        state.GetEnvironmentGeneration();
    const size_t bridgeGenerationBefore =
        state.GetManagedRenderPipelineBridgeGeneration();
    const auto bridge =
        std::make_shared<DummyManagedRenderPipelineBridge>();

    state.SetManagedRenderPipelineBridge(bridge);

    EXPECT_EQ(state.GetManagedRenderPipelineBridge(), bridge);
    EXPECT_GT(state.GetManagedRenderPipelineBridgeGeneration(),
              bridgeGenerationBefore);
    EXPECT_GT(state.GetEnvironmentGeneration(),
              environmentGenerationBefore);
}