#include "render_2D/scene/Scene_Context.hpp"
#include <gtest/gtest.h>

#include <string>
#include <type_traits>
#include <vector>

#include "renderive/inheritance/Registry.hpp"
#include "renderive/scene/Inheritance.hpp"

namespace {

struct Lifecycle_Event {
    std::vector<std::string>& handled_by;
};

struct Scene_Impl
    : renderive::scene_inheritance::Impl_Root<Scene_Impl,
                                                Lifecycle_Event> {
    struct Observer :
        renderive::scene_inheritance::Observer_Root<Scene_Impl> {
        static void handle(Scene_Impl&, const Lifecycle_Event& event) {
            event.handled_by.emplace_back("scene");
        }
    };
};

struct Scene2D_Impl
    : renderive::scene_inheritance::Impl_Node<Scene2D_Impl, Scene_Impl> {
    struct Observer
        : renderive::scene_inheritance::Observer_Node<
              Scene2D_Impl, Scene_Impl::Observer> {
        static void handle(Scene2D_Impl&, const Lifecycle_Event& event) {
            event.handled_by.emplace_back("scene_2d");
        }
    };
};

struct Plot_Scene_Impl
    : renderive::scene_inheritance::Impl_Node<Plot_Scene_Impl,
                                                Scene2D_Impl> {
    struct Observer
        : renderive::scene_inheritance::Observer_Node<
              Plot_Scene_Impl, Scene2D_Impl::Observer> {
        static void handle(Plot_Scene_Impl&, const Lifecycle_Event& event) {
            event.handled_by.emplace_back("plot_scene");
        }
    };
};

struct Scene_Editor
    : renderive::scene_inheritance::Editor_Root<Scene_Editor> {};
struct Scene2D_Editor
    : renderive::scene_inheritance::Editor_Node<Scene2D_Editor,
                                                  Scene_Editor> {};
struct Plot_Scene_Editor
    : renderive::scene_inheritance::Editor_Node<Plot_Scene_Editor,
                                                  Scene2D_Editor> {};

struct Scene_Builder
    : renderive::scene_inheritance::Builder_Root<Scene_Builder> {};
struct Scene2D_Builder
    : renderive::scene_inheritance::Builder_Node<Scene2D_Builder,
                                                   Scene_Builder> {};
struct Plot_Scene_Builder
    : renderive::scene_inheritance::Builder_Node<Plot_Scene_Builder,
                                                   Scene2D_Builder> {};

struct Scene_State
    : renderive::scene_inheritance::State_Root<Scene_State> {};
struct Scene2D_State
    : renderive::scene_inheritance::State_Node<Scene2D_State,
                                                 Scene_State> {};
struct Plot_Scene_State
    : renderive::scene_inheritance::State_Node<Plot_Scene_State,
                                                 Scene2D_State> {};

TEST(scene_inheritance_test,
     observer_dispatch_follows_the_scene_chain_parent_before_child) {
    Plot_Scene_Impl impl;
    std::vector<std::string> handled_by;
    impl.dispatch({handled_by});
    EXPECT_EQ(handled_by,
              (std::vector<std::string>{"scene", "scene_2d", "plot_scene"}));
}

TEST(scene_inheritance_test,
     editor_chain_registers_each_semantic_layer_at_its_own_position) {
    using Registry = Plot_Scene_Editor::Inheritance_Registry;
    using Chain = renderive::scene_inheritance::Editor_Chain;
    static_assert(renderive::inheritance::Chain_Registration_Count_V<
                      Registry, Chain> == 3);
    static_assert(std::same_as<
                  renderive::inheritance::Type_At_Position_T<Registry, Chain,
                                                               0>,
                  Scene_Editor>);
    static_assert(std::same_as<
                  renderive::inheritance::Type_At_Position_T<Registry, Chain,
                                                               2>,
                  Plot_Scene_Editor>);
    SUCCEED();
}

TEST(scene_inheritance_test,
     builder_and_state_chains_extend_without_sharing_registrations) {
    using Builder_Registry = Plot_Scene_Builder::Inheritance_Registry;
    using State_Registry = Plot_Scene_State::Inheritance_Registry;
    using Builder_Chain = renderive::scene_inheritance::Builder_Chain;
    using State_Chain = renderive::scene_inheritance::State_Chain;
    static_assert(renderive::inheritance::Chain_Registration_Count_V<
                      Builder_Registry, Builder_Chain> == 3);
    static_assert(renderive::inheritance::Chain_Registration_Count_V<
                      Builder_Registry, State_Chain> == 0);
    static_assert(renderive::inheritance::Chain_Registration_Count_V<
                      State_Registry, State_Chain> == 3);
    static_assert(renderive::inheritance::Chain_Registration_Count_V<
                      State_Registry, Builder_Chain> == 0);
    static_assert(std::same_as<
                  renderive::inheritance::Type_At_Position_T<
                      Builder_Registry, Builder_Chain, 2>,
                  Plot_Scene_Builder>);
    static_assert(std::same_as<
                  renderive::inheritance::Type_At_Position_T<
                      State_Registry, State_Chain, 2>,
                  Plot_Scene_State>);
    SUCCEED();
}

} // namespace