Entity.h

#pragma once
#include <Engine/Core/Tick.h>
#include <vector>
#include <memory>
#include <algorithm>
#include <cstdint>
#include <type_traits>
#include <plog/Log.h>
#include <entt/entt.hpp>
#include "Engine/Component/LogicComponent.h"
 
namespace Engine::Entities{
    class EntityContainer;

    class Entity : public Core::ITickable, protected std::enable_shared_from_this<Entity> {
    public:
        Entity();

        ~Entity() override;

        void enableTick(bool enable);

        void setTickPriority(int32_t priority);

        [[nodiscard]] int32_t getTickPriority() const { return tickPriority_; }

        void tick(double deltaTime) override;

        void destroy();

        void destroyImmediate();

        [[nodiscard]] EntityContainer * getOwningContainer() const;

        [[nodiscard]] bool isPendingDestroy() const;

        [[nodiscard]] bool isPlaying() const;

        template<typename T, typename... Args>
        requires std::is_base_of_v<Components::Logic, T> && std::is_constructible_v<T, Args...>
        T* addComponent(Args&&... args) {
 
            if constexpr (T::IsUnique) {
                T* existing = getComponent<T>();
                if (existing) {
                    PLOGW << "Attempted to add unique component " << typeid(T).name() << " which already exists on entity.";
                    return existing;
                }
            }
 
            auto component = std::make_unique<T>(std::forward<Args>(args)...);
            component->setOwningEntity(this);
            T* rawComponent = component.get();
            components_.push_back(std::move(component));
 
            if ( isPlaying() && !rawComponent->hasBegunPlay() ) {
                rawComponent->beginPlay();
            }
 
            return rawComponent;
        }

        template<typename T>
        requires std::is_base_of_v<Components::Logic, T>
        T* getComponent() const {
            for (const auto& component : components_) {
                if (auto typed = dynamic_cast<T*>(component.get())) {
                    return typed;
                }
            }
            return nullptr;
        }

        template<typename T>
        requires std::is_base_of_v<Components::Logic, T>
        std::vector<T*> getComponents() const {
            std::vector<T*> result;
            for (const auto& component : components_) {
                if (auto typed = dynamic_cast<T*>(component.get())) {
                    result.push_back(typed);
                }
            }
            return result;
        }

        void removeComponent(Components::Logic* component) {
            auto it = std::ranges::find_if(components_, [component](const auto& ptr) {
                return ptr.get() == component;
            });
 
            if (it != components_.end()) {
                (*it)->endPlay(); // Ensure cleanup
                components_.erase(it);
            }
        }

        template<typename T>
        requires std::is_base_of_v<Components::Logic, T>
        bool removeFirstComponent() {
            auto it = std::ranges::find_if(components_, [](const auto& ptr) {
                return dynamic_cast<T*>(ptr.get()) != nullptr;
            });
 
            if (it != components_.end()) {
                (*it)->endPlay();
                components_.erase(it);
                return true;
            }
            return false;
        }

        template<typename T>
        requires std::is_base_of_v<Components::Logic, T>
        bool hasComponent() const {
            return getComponent<T>() != nullptr;
        }

        [[nodiscard]] const std::vector<std::unique_ptr<Components::Logic>>& getAllComponents() const {
            return components_;
        }

        [[nodiscard]] bool canTick() const;

        [[nodiscard]] bool canEverTick() const;

        [[nodiscard]] entt::entity getEcsEntity() const { return data_; }
 
    protected:
        std::vector<std::unique_ptr<Components::Logic>> components_;
 
        entt::entity data_ = entt::null;  
 
        bool allowTicking_ = false;  
        int32_t tickPriority_ = 0;  

        virtual void onEngineBeginPlay();

        virtual void onEngineEndPlay();

        virtual void onEngineDestroyed();
    private:
        friend class EntityContainer;
 
        enum class LifecycleState
        {
            Constructed,
            Playing,
            PendingDestroy,
            Destroying,
            Destroyed,
        };
 
        void engineBeginPlay();
        void engineEndPlay();
 
        [[nodiscard]] bool isDestroyingOrDestroyed() const;
 
        EntityContainer * owningContainer_ = nullptr;
        LifecycleState    lifecycleState_  = LifecycleState::Constructed;
    };
 
}