#include <gtest/gtest.h>

#include <XCEngine/Rendering/RenderPass.h>
#include <XCEngine/Rendering/Extraction/RenderSceneExtractor.h>
#include <XCEngine/Rendering/RenderSurface.h>

#include <memory>
#include <string>
#include <vector>

using namespace XCEngine::Rendering;

namespace {

struct TrackingPassState {
    std::vector<std::string> initializeOrder;
    std::vector<std::string> executeOrder;
    std::vector<std::string> shutdownOrder;
};

class TrackingPass final : public RenderPass {
public:
    TrackingPass(
        std::string name,
        TrackingPassState& state,
        bool initializeResult = true,
        bool executeResult = true)
        : m_name(std::move(name))
        , m_state(state)
        , m_initializeResult(initializeResult)
        , m_executeResult(executeResult) {
    }

    const char* GetName() const override {
        return m_name.c_str();
    }

    bool Initialize(const RenderContext&) override {
        m_state.initializeOrder.push_back(m_name);
        return m_initializeResult;
    }

    void Shutdown() override {
        m_state.shutdownOrder.push_back(m_name);
    }

    bool Execute(const RenderPassContext&) override {
        m_state.executeOrder.push_back(m_name);
        return m_executeResult;
    }

private:
    std::string m_name;
    TrackingPassState& m_state;
    bool m_initializeResult = true;
    bool m_executeResult = true;
};

RenderContext CreateValidContext() {
    RenderContext context;
    context.device = reinterpret_cast<XCEngine::RHI::RHIDevice*>(1);
    context.commandList = reinterpret_cast<XCEngine::RHI::RHICommandList*>(1);
    context.commandQueue = reinterpret_cast<XCEngine::RHI::RHICommandQueue*>(1);
    return context;
}

} // namespace

TEST(RenderPassSequence_Test, InitializesAndExecutesInInsertionOrderThenShutsDownInReverse) {
    TrackingPassState state;
    RenderPassSequence sequence;
    sequence.AddPass(std::make_unique<TrackingPass>("SceneColor", state));
    sequence.AddPass(std::make_unique<TrackingPass>("GridOverlay", state));
    sequence.AddPass(std::make_unique<TrackingPass>("Outline", state));

    ASSERT_EQ(sequence.GetPassCount(), 3u);

    const RenderContext context = CreateValidContext();
    ASSERT_TRUE(sequence.Initialize(context));

    RenderSceneData sceneData;
    const RenderSurface surface(1280, 720);
    const RenderPassContext passContext = {
        context,
        surface,
        sceneData
    };

    ASSERT_TRUE(sequence.Execute(passContext));
    sequence.Shutdown();

    EXPECT_EQ(
        state.initializeOrder,
        (std::vector<std::string>{ "SceneColor", "GridOverlay", "Outline" }));
    EXPECT_EQ(
        state.executeOrder,
        (std::vector<std::string>{ "SceneColor", "GridOverlay", "Outline" }));
    EXPECT_EQ(
        state.shutdownOrder,
        (std::vector<std::string>{ "Outline", "GridOverlay", "SceneColor" }));
}

TEST(RenderPassSequence_Test, StopsExecutingWhenAPassFails) {
    TrackingPassState state;
    RenderPassSequence sequence;
    sequence.AddPass(std::make_unique<TrackingPass>("SceneColor", state));
    sequence.AddPass(std::make_unique<TrackingPass>("SelectionMask", state, true, false));
    sequence.AddPass(std::make_unique<TrackingPass>("Outline", state));

    const RenderContext context = CreateValidContext();
    ASSERT_TRUE(sequence.Initialize(context));

    RenderSceneData sceneData;
    const RenderSurface surface(640, 360);
    const RenderPassContext passContext = {
        context,
        surface,
        sceneData
    };

    EXPECT_FALSE(sequence.Execute(passContext));
    EXPECT_EQ(
        state.executeOrder,
        (std::vector<std::string>{ "SceneColor", "SelectionMask" }));
}