#include "render_2D/scene/Render_Scene_2D.h"
#include <gtest/gtest.h>
#include <memory>

namespace renderive {
namespace {

std::unique_ptr<Render_Scene_2D> make_scene(
    Render_Scene_2D::State state = {}) {
    auto strategy =
        std::make_shared<Low_Latency_Render_Scene_2D_Strategy>();
    return Render_Scene_2D::Builder{state}.build(std::move(strategy));
}

TEST(RenderScene2DFramePipeline, BuilderOwnsConstructionAndState) {
    Render_Scene_2D::State state;
    state.viewport = {96, 54};
    state.background = Color{8, 16, 24, 255};
    auto scene = make_scene(state);
    ASSERT_TRUE(scene);
    EXPECT_EQ(scene->root_renderable()->object_name(), "root");
}

TEST(RenderScene2DFramePipeline, ActiveDirtyAndForceGatesAreOrthogonal) {
    Render_Scene_2D::State state;
    state.viewport = {80, 45};
    auto scene = make_scene(state);
    scene->publish_frame_state();
    EXPECT_EQ(scene->observer().state, state);
    EXPECT_EQ(scene->render_frame().value(), Plot_Render_Status::view_inactive);
    scene->activate_view();
    EXPECT_EQ(scene->render_frame().value(), Plot_Render_Status::rendered);
    EXPECT_EQ(scene->render_frame().value(), Plot_Render_Status::model_unchanged);
    EXPECT_EQ(scene->render_frame(true).value(), Plot_Render_Status::rendered);
    EXPECT_EQ(scene->wait_for_render(), Scene_Render_Result::none);
}

TEST(RenderScene2DFramePipeline, ObserverReadsPublishedDoubleBufferedState) {
    Render_Scene_2D::State state;
    state.viewport = {32, 24};
    auto scene = make_scene(state);
    scene->activate_view();
    ASSERT_EQ(scene->render_frame(true).value(), Plot_Render_Status::rendered);
    ASSERT_EQ(scene->wait_for_render(), Scene_Render_Result::none);
    const auto observation = scene->observer();
    EXPECT_EQ(observation.state, state);
    EXPECT_EQ(observation.renderable_count, 1U);
    EXPECT_TRUE(observation.view_active);
    EXPECT_GT(observation.frequency_hz, 0.0);
}

} // namespace
} // namespace renderive