ht_gameobject.h

#pragma once

#include <vector>
#include <unordered_map>
#include <tuple>
#include <utility>

#include <ht_platform.h>
#include <ht_transform.h>
#include <ht_guid.h>

#ifdef HT_SYS_LINUX
    #include <cstdlib>
#endif

#include <ht_component.h>

namespace Hatchit {

    namespace Game {
        class Scene;

        class HT_API GameObject
        {
        friend class Scene;
        public:
            GameObject(const GameObject& rhs) = default;
            GameObject(GameObject&& rhs) = default;
            GameObject& operator=(const GameObject& rhs) = default;
            GameObject& operator=(GameObject&& rhs) = default;

            const Core::Guid& GetGuid(void) const;

            const std::string& GetName(void) const;

            Transform& GetTransform(void);

            bool GetEnabled(void) const;

            void SetEnabled(bool value);

            inline void Enable(void)
            {
                SetEnabled(true);
            }

            inline void Disable(void)
            {
                SetEnabled(false);
            }

            GameObject* GetParent(void);

            void SetParent(GameObject *parent);

            GameObject* GetChildAtIndex(std::size_t index);

            void AddChild(GameObject *child);

            void RemoveChildAtIndex(std::size_t index);

            void RemoveChild(GameObject *child);

            void OnInit(void);

            void Update(void);


            void MarkForDestroy(void);


            template <typename T>
            bool AddComponent(T *component);

            template <typename T, typename... Args>
            bool AddComponent(Args&&... args);

            template <typename T>
            bool RemoveComponent(void);

            template <typename T>
            bool HasComponent(void) const;

            template <typename T1, typename T2, typename... Args>
            bool HasComponent(void) const;

            template <typename T>
            T* GetComponent(void);

            template <typename... Args>
            std::tuple<Args*...> GetComponents(void);

            template <typename T>
            bool EnableComponent(void);

            template <typename... Args>
            auto EnableComponents(void) -> decltype(std::make_tuple(EnableComponent<Args>()...))
            {
                return std::make_tuple(EnableComponent<Args>()...);
            }

            template <typename T>
            bool DisableComponent(void);

            template <typename... Args>
            auto DisableComponents(void) -> decltype(std::make_tuple(DisableComponent<Args>()...))
            {
                return std::make_tuple(DisableComponent<Args>()...);
            }

        private:


            GameObject(void);

            GameObject(const Core::Guid guid, const std::string name, Transform t, bool enabled);


            ~GameObject(void);


            void OnEnabled(void);


            void OnDisabled(void);


            template<typename T>
            bool AddUninitializedComponent(T *component);

            template <typename T, typename... Args>
            bool AddUninitializedComponent(Args&&... args);

            bool m_enabled; 
            bool m_destroyed;//* < bool indicating that this object is to be destroyed on the next update call*/
            std::string m_name; 
            Core::Guid m_guid; 
            Transform m_transform; 
            GameObject *m_parent; 
            std::vector<GameObject*> m_children; 
            std::vector<Game::Component*> m_components; 
            std::unordered_map<Core::Guid, std::vector<Component*>::size_type> m_componentMap; 
        };


        template <typename T>
        bool GameObject::AddComponent(T *component)
        {
            static_assert(std::is_base_of<Component, T>::value, "Must be a sub-class of Hatchit::Game::Component!");

            Core::Guid component_id = Game::Component::template GetComponentId<T>();
            std::unordered_map<Core::Guid, std::vector<Component*>::size_type>::const_iterator iter = m_componentMap.find(component_id);
            if (iter != m_componentMap.cend())
                return false;

            m_componentMap.insert(std::make_pair(component_id, m_components.size()));
            m_components.push_back(component);

            component->SetOwner(this);

            component->VOnInit();

            if(m_enabled)
                component->VOnEnable();

            return true;
        }

        template <>
        inline bool GameObject::AddComponent<Component>(Component *component)
        {
            Core::Guid component_id = component->VGetComponentId();
            std::unordered_map<Core::Guid, std::vector<Component*>::size_type>::const_iterator iter = m_componentMap.find(component_id);
            if (iter != m_componentMap.cend())
                return false;

            m_componentMap.insert(std::make_pair(component_id, m_components.size()));
            m_components.push_back(component);

            component->SetOwner(this);

            component->VOnInit();

            if (m_enabled)
                component->SetEnabled(true);

            return true;
        }

        template <typename T, typename... Args>
        bool GameObject::AddComponent(Args&&... args)
        {
            static_assert(std::is_base_of<Component, T>::value && !std::is_same<Component, T>::value, "Must be a sub-class of Hatchit::Game::Component!");

            Core::Guid component_id = Game::Component:: template GetComponentId<T>();
            std::unordered_map<Core::Guid, std::vector<Component*>::size_type>::const_iterator iter = m_componentMap.find(component_id);
            if (iter != m_componentMap.cend())
                return false;

            T *component = new T(std::forward<Args>(args)...);
            m_componentMap.insert(std::make_pair(component_id, m_components.size()));
            m_components.push_back(component);

            component->SetOwner(this);

            component->VOnInit();

            if (m_enabled)
                component->VOnEnable();

            return true;
        }

        template <typename T>
        bool GameObject::RemoveComponent(void)
        {
            static_assert(std::is_base_of<Component, T>::value && !std::is_same<Component, T>::value, "Must be a sub-class of Hatchit::Game::Component!");

            Core::Guid component_id = Game::Component:: template GetComponentId<T>();
            std::unordered_map<Core::Guid, std::vector<Component*>::size_type>::const_iterator iter = m_componentMap.find(component_id);
            if (iter == m_componentMap.cend())
                return false;

            std::vector<Component*>::size_type index = m_componentMap[component_id];
            Component *component = m_components[index];
            if(component->GetEnabled())
                component->SetEnabled(false);
            component->VOnDestroy();

            m_components[index] = nullptr;
            m_componentMap.erase(component_id);
            delete component;

            return true;
        }

        template <typename T>
        bool GameObject::HasComponent(void) const
        {
            static_assert(std::is_base_of<Component, T>::value && !std::is_same<Component, T>::value, "Must be a sub-class of Hatchit::Game::Component!");
            Core::Guid component_id = Component:: template GetComponentId<T>();
            return (m_componentMap.find(component_id) != m_componentMap.cend());
        }

        template <typename T1, typename T2, typename... Args>
        bool GameObject::HasComponent(void) const
        {
            static_assert(std::is_base_of<Component, T1>::value && !std::is_same<Component, T1>::value, "Must be a sub-class of Hatchit::Game::Component!");
            return HasComponent<T1>() && HasComponent<T2, Args...>();
        }

        template <typename T>
        T* GameObject::GetComponent(void)
        {
            static_assert(std::is_base_of<Component, T>::value && !std::is_same<Component, T>::value, "Must be a sub-class of Hatchit::Game::Component!");

            Core::Guid component_id = Component::GetComponentId<T>();
            std::unordered_map<Core::Guid, std::vector<Component*>::size_type>::const_iterator iter = m_componentMap.find(component_id);
            if (iter == m_componentMap.cend())
                return nullptr;

            std::vector<Component*>::size_type index = m_componentMap[component_id];
            return dynamic_cast<T*>(m_components[index]);
        }

        template <typename... Args>
        std::tuple<Args*...> GameObject::GetComponents(void)
        {
            return std::make_tuple(GetComponent<Args>()...);
        }

        template <typename T>
        bool GameObject::EnableComponent(void)
        {
            static_assert(std::is_base_of<Component, T>::value && !std::is_same<Component, T>::value, "Must be a sub-class of Hatchit::Game::Component!");

            if (!HasComponent<T>())
                return false;

            Core::Guid component_id = Component::GetComponentId<T>();
            std::vector<Component*>::size_type index = m_componentMap[component_id];
            Component *component = m_components[index];
            if (component->GetEnabled())
                return false;

            component->SetEnabled(true);

            return true;
        }

        template <typename T>
        bool GameObject::DisableComponent(void)
        {
            static_assert(std::is_base_of<Component, T>::value && !std::is_same<Component, T>::value, "Must be a sub-class of Hatchit::Game::Component!");

            if (!HasComponent<T>())
                return false;

            Core::Guid component_id = Component::GetComponentId<T>();
            std::vector<Component*>::size_type index = m_componentMap[component_id];
            Component *component = m_components[index];
            if (!component->GetEnabled())
                return false;

            component->SetEnabled(false);

            return true;
        }

        template<typename T>
        inline bool GameObject::AddUninitializedComponent(T* component)
        {
            static_assert(std::is_base_of<Component, T>::value, "Must be a sub-class of Hatchit::Game::Component!");

            Core::Guid component_id = Component::GetComponentId<T>();
            std::unordered_map<Core::Guid, std::vector<Component*>::size_type>::const_iterator iter = m_componentMap.find(component_id);
            if (iter != m_componentMap.cend())
                return false;

            m_componentMap.insert(std::make_pair(component_id, m_components.size()));
            m_components.push_back(component);

            component->SetOwner(this);

            return true;
        }

        template<>
        inline bool GameObject::AddUninitializedComponent<Component>(Component* component)
        {
            Core::Guid component_id = component->VGetComponentId();
            std::unordered_map<Core::Guid, std::vector<Component*>::size_type>::const_iterator iter = m_componentMap.find(component_id);
            if (iter != m_componentMap.cend())
                return false;

            m_componentMap.insert(std::make_pair(component_id, m_components.size()));
            m_components.push_back(component);

            component->SetOwner(this);

            return true;
        }

        template<typename T, typename ...Args>
        inline bool GameObject::AddUninitializedComponent(Args && ...args)
        {
            static_assert(std::is_base_of<Component, T>::value && !std::is_same<Component, T>::value, "Must be a sub-class of Hatchit::Game::Component!");

            Core::Guid component_id = Game::Component:: template GetComponentId<T>();
            std::unordered_map<Core::Guid, std::vector<Component*>::size_type>::const_iterator iter = m_componentMap.find(component_id);
            if (iter != m_componentMap.cend())
                return false;

            T *component = new T(std::forward<Args>(args)...);
            m_componentMap.insert(std::make_pair(component_id, m_components.size()));
            m_components.push_back(component);

            component->SetOwner(this);

            return true;
        }
    }
}