#include "renderive/renderable/Inheritance.hpp"
#include <gtest/gtest.h>
#include <type_traits>
#include <vector>

namespace {
namespace chain = renderive::renderable_inheritance;

enum class Visit { parent, child };
struct Event {};
struct Impl_Base : renderive::inheritance::Type_Root {
    explicit Impl_Base(std::vector<Visit>& visits) : visits(&visits) {}
    std::vector<Visit>* visits;
};
struct Parent_Impl : chain::Impl_Root<Parent_Impl, Impl_Base, Event> {
    using Impl_Root::Impl_Root;
    void handle_observation(const Event&) {
        visits->push_back(Visit::parent);
    }
};
struct Child_Impl : chain::Impl_Node<Child_Impl, Parent_Impl> {
    using Impl_Node::Impl_Node;
    void handle_observation(const Event&) {
        visits->push_back(Visit::child);
    }
};
struct Parent_State : chain::State_Root<Parent_State> {};
struct Child_State : chain::State_Node<Child_State, Parent_State> {};
struct Parent_Builder : chain::Builder_Root<Parent_Builder> {};
struct Child_Builder : chain::Builder_Node<Child_Builder, Parent_Builder> {};
struct Parent_Observer : chain::Observer_Root<Parent_Observer> {};
struct Child_Observer : chain::Observer_Node<Child_Observer, Parent_Observer> {};

TEST(renderable_inheritance_test, dispatches_parent_before_child) {
    std::vector<Visit> visits;
    Child_Impl impl(visits);
    impl.dispatch(Event{});
    EXPECT_EQ(visits, (std::vector{Visit::parent, Visit::child}));
}

TEST(renderable_inheritance_test, every_chain_registers_its_own_layer) {
    static_assert(renderive::inheritance::Chain_Registration_Count_V<
        typename Child_State::Inheritance_Registry, chain::State_Chain> == 2);
    static_assert(renderive::inheritance::Chain_Registration_Count_V<
        typename Child_Builder::Inheritance_Registry, chain::Builder_Chain> == 2);
    static_assert(renderive::inheritance::Chain_Registration_Count_V<
        typename Child_Observer::Inheritance_Registry, chain::Observer_Chain> == 2);
    SUCCEED();
}
} // namespace