#include "render_3D/Render_Scene_3D.h"
#include <gtest/gtest.h>
#include <memory>
#include <vector>

namespace renderive::render_3d {
namespace {

std::unique_ptr<Render_Scene_3D> make_scene(
    Render_Scene_3D::State state,
    const std::shared_ptr<Point_Visual>& visual) {
    return Render_Scene_3D::Builder{state}.build(
        visual, std::make_shared<Low_Latency_Render_Scene_3D_Strategy>());
}

TEST(PointRenderIntegration, BuilderConstructsSceneFromStateAndStrategy) {
    auto visual = Point_Visual::Builder{}.build(std::vector<Point>{
        {{0.0F, 0.0F, 0.0F}, {255, 0, 0, 255}, 8.0F}});
    Render_Scene_3D::State state;
    state.viewport = {320, 200};
    try {
        auto scene = make_scene(state, visual);
        ASSERT_TRUE(scene);
        EXPECT_EQ(scene->renderable_count(), 1U);
    }
    catch (const std::exception& error) {
        GTEST_SKIP() << "Vulkan/Datoviz unavailable: " << error.what();
    }
}

TEST(PointRenderIntegration, ObserverPublishesSceneAndVisualState) {
    std::vector<Point> points(3);
    for (auto& point : points) point.diameter_px = 1.0F;
    auto visual = Point_Visual::Builder{}.build(std::move(points));
    Render_Scene_3D::State state;
    state.viewport = {160, 90};
    try {
        auto scene = make_scene(state, visual);
        scene->publish_frame_state();
        ASSERT_EQ(scene->render(), Scene_Render_Result::none);
        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_EQ(observation.point_count, visual->point_count());
        EXPECT_EQ(observation.point_count, 3U);
    }
    catch (const std::exception& error) {
        GTEST_SKIP() << "Vulkan/Datoviz unavailable: " << error.what();
    }
}

TEST(PointRenderIntegration, FrameStrategyIsReplacedInsideRenderableEdit) {
    auto visual = Point_Visual::Builder{}.build(std::vector<Point>{
        {{0.0F, 0.0F, 0.0F}, {255, 0, 0, 255}, 8.0F}});
    Render_Scene_3D::State state;
    state.viewport = {64, 48};
    try {
        auto scene = make_scene(state, visual);
        const auto operation = scene->edit_renderables(
            [](Scene_3D_Base::Renderable_Editor& editor) {
                editor.replace_frame_control_strategy(
                    std::make_shared<Manual_Render_Scene_3D_Strategy>());
            });
        ASSERT_EQ(operation.wait(), Scene_Edit_Error::none);
        EXPECT_NE(std::dynamic_pointer_cast<Manual_Render_Scene_3D_Strategy>(
                      scene->frame_control_strategy()),
                  nullptr);
    }
    catch (const std::exception& error) {
        GTEST_SKIP() << "Vulkan/Datoviz unavailable: " << error.what();
    }
}

} // namespace
} // namespace renderive::render_3d