GECSManager.h

#pragma once
 
#include "GECS.h"
#include "../../Grid/Grid.h"
//#include "../../DataManager/DataManager.h"
 
#include "../../Threader/Threader.h"
 
#include "./SimulationStep.h"
 
#include <regex>
#include <filesystem>
#include <shared_mutex>
#include "Command.h"
 
namespace fs = std::filesystem;
 
 
class Manager
{
private:
    mutable std::shared_mutex entities_mtx;
    std::mutex refresh_mtx;
 
    Threader* _threader = nullptr;
    int lastEntityId = 0;
    int negativeEntityId = -1;
    std::unordered_map<EntityID, std::unique_ptr<Entity>> entities;
 
    std::array<std::vector<Entity*>, maxGroups> groupedEmptyEntities;
    std::array<std::vector<Entity*>, maxGroups> groupedNodeEntities;
    std::array<std::vector<Entity*>, maxGroups> groupedLinkEntities;
 
    std::vector<Entity*> visible_emptyEntities;
    std::vector<Entity*> visible_nodes;
    std::vector<Entity*> visible_links;
 
    std::array<std::vector<Entity*>, maxGroups> visible_groupedEmptyEntities;
    std::array<std::vector<Entity*>, maxGroups> visible_groupedNodeEntities;
    std::array<std::vector<Entity*>, maxGroups> visible_groupedLinkEntities;
 
    bool _update_active_entities = false;
public:
    // Simdump
    std::list<SimulationStep> steps;
    int currentStep = 0;
 
    // Command Pattern
    std::stack<std::unique_ptr<Command>> undoStack;
 
    std::vector<EntityID> movedNodes;
    std::mutex movedNodesMutex;
 
    bool idTextEnabled = false;
 
    bool arrowheadsEnabled = false;
    bool last_arrowheadsEnabled = false;
 
    std::unordered_map<std::string, std::vector<std::string>> componentNames;
 
    std::unique_ptr<Grid> grid;
 
    Manager() {}
 
    ~Manager() { _threader = nullptr; }
 
    void setThreader(Threader& mthreader) {
        _threader = &mthreader;
    }
 
    void update(float deltaTime = 1.0f)
    {
 
        if (_threader && !_threader->t_queue.shuttingDown) {
 
            //? THIS MAY CAUSE ERRORS, IF REMOVE LINK FROM CELL AND OTHER LINK THAT HAS THAT CELL IN SEARCH
            //? WILL PUMP IN AN EMPTY ELEMENT OR THE SIZE WILL BE SMALLER FOR THAT LINK TO FIND ELEMENT
            for (auto& e : movedNodes) {
                auto* ent = dynamic_cast<NodeEntity*>(getEntityFromId(e));
 
                for (auto& linkId : ent->getInLinks()) {
                    auto* linkEntity = dynamic_cast<LinkEntity*>(getEntityFromId(linkId));
 
                    linkEntity->cellUpdate();
                }
                for (auto& link : ent->getOutLinks()) {
                    auto* linkEntity = dynamic_cast<LinkEntity*>(getEntityFromId(link));
 
                    linkEntity->cellUpdate();
                }
            }
 
            _threader->parallel(movedNodes.size(), [&](int start, int end) {
                for (int i = start; i < end; i++) {
                    auto* ent = dynamic_cast<NodeEntity*>(getEntityFromId(movedNodes[i]));
 
                    for (auto& link : ent->getInLinks()) {
                        auto* linkEntity = dynamic_cast<LinkEntity*>(getEntityFromId(link));
 
                        linkEntity->updateConnection();
                    }
                }
                });
 
            _threader->parallel(movedNodes.size(), [&](int start, int end) {
                for (int i = start; i < end; i++) {
                    auto* ent = dynamic_cast<NodeEntity*>(getEntityFromId(movedNodes[i]));
 
                    for (auto& link : ent->getOutLinks()) {
                        auto* linkEntity = dynamic_cast<LinkEntity*>(getEntityFromId(link));
 
                        // skip inner links for now
                        if (arrowheadsEnabled &&
                            linkEntity->type == LinkEntity::ConnectionType::GHOST_PORT_TO_PORT)
                            continue;
 
                        linkEntity->updateConnection();
                    }
                }
                });
 
            _threader->parallel(movedNodes.size(), [&](int start, int end) {
                for (int i = start; i < end; i++) {
                    auto* ent = dynamic_cast<NodeEntity*>(getEntityFromId(movedNodes[i]));
 
                    if (arrowheadsEnabled) {
                        // loop through inner links
                        // also loop through innner links of adjacent nodes
                        for (auto& link : ent->getOutLinks()) {
                            auto* linkEntity = dynamic_cast<LinkEntity*>(getEntityFromId(link));
 
                            if (
                                linkEntity->type == LinkEntity::ConnectionType::GHOST_PORT_TO_PORT)
                            {
                                linkEntity->updateConnection();
                            }
                            else {
                                NodeEntity* toNode = dynamic_cast<NodeEntity*>(getEntityFromId(linkEntity->toId));
 
                                for (auto& link : toNode->getOutLinks()) {
                                    auto* adjacent_linkEntity = dynamic_cast<LinkEntity*>(getEntityFromId(link));
 
                                    if (
                                        adjacent_linkEntity->type == LinkEntity::ConnectionType::GHOST_PORT_TO_PORT)
                                    {
                                        adjacent_linkEntity->updateConnection();
                                    }
                                }
                            }
                        }
                        // also loop through innner links of adjacent nodes
                        for (auto& link : ent->getInLinks()) {
                            auto* linkEntity = dynamic_cast<LinkEntity*>(getEntityFromId(link));
 
                            if (
                                linkEntity->type != LinkEntity::ConnectionType::GHOST_PORT_TO_PORT)
                            {
                                NodeEntity* fromNode = dynamic_cast<NodeEntity*>(getEntityFromId(linkEntity->fromId));
 
                                for (auto& link : fromNode->getOutLinks()) {
                                    auto* adjacent_linkEntity = dynamic_cast<LinkEntity*>(getEntityFromId(link));
 
                                    if (
                                        adjacent_linkEntity->type == LinkEntity::ConnectionType::GHOST_PORT_TO_PORT)
                                    {
                                        adjacent_linkEntity->updateConnection();
                                    }
                                }
                            }
                        }
                    }
                }
                });
 
            movedNodes.clear();
 
            _threader->parallel(visible_emptyEntities.size(), [&](int start, int end) {
                for (int i = start; i < end; i++) {
                    if (visible_emptyEntities[i]) {
                        visible_emptyEntities[i]->update(deltaTime);
                    }
                }
                });
 
 
            _threader->parallel(visible_nodes.size(), [&](int start, int end) {
                for (int i = start; i < end; i++) {
                    if (visible_nodes[i]) {
                        visible_nodes[i]->update(deltaTime);
                    }
                }
 
                });
 
 
            _threader->parallel(visible_links.size(), [&](int start, int end) {
 
                for (int i = start; i < end; i++) {
                    if (visible_links[i]) {
                        visible_links[i]->update(deltaTime);
                    }
                }
                });
        }
 
        else {
 
            for (auto& e : visible_emptyEntities) {
                if (!e->isActive()) continue;
 
                e->update(deltaTime);
            }
 
            for (auto& e : visible_nodes) {
                if (!e->isActive()) continue;
 
                e->update(deltaTime);
 
            }
 
 
            for (auto& e : visible_links) {
                if (!e->isActive()) continue;
 
                e->update(deltaTime);
            }
        }
    }
 
    // update fully will update all nodes and links in the world
    void updateFully(float deltaTime = 1.0f)
    {
        // the links are updating once since after first update we check wether the nodes are aligned with the ownerCells
        for (auto& e : entities) {
            if (!e.second || !e.second->isActive()) continue;
 
            e.second->update(deltaTime);
        }
        update(deltaTime);
    }
 
    void refresh(ICamera* camera = nullptr)
    {
 
        if (grid && (camera->hasChanged() || grid->gridLevelChanged())) {
            bool interceptedCellsChanged = grid->setIntersectedCameraCells(*camera);
 
            if (interceptedCellsChanged) {
                aboutTo_updateActiveEntities();
            }
            camera->refreshCamera();
        }
 
        if (_update_active_entities) {
            std::scoped_lock lock(refresh_mtx);
 
            _update_active_entities = false;
 
            updateVisibleEntities();
            updateActiveEntities();
        }
 
    }
 
    void aboutTo_updateActiveEntities() {
        std::scoped_lock lock(refresh_mtx);
        _update_active_entities = true;
    }
 
    void updateActiveEntities();
 
    void updateVisibleEntities();
 
    void AddToGroup(EmptyEntity* mEntity, Group mGroup)
    {
        groupedEmptyEntities[mGroup].emplace_back(mEntity);
        aboutTo_updateActiveEntities();
    }
 
    void AddToGroup(NodeEntity* mEntity, Group mGroup)
    {
        groupedNodeEntities[mGroup].emplace_back(mEntity);
        aboutTo_updateActiveEntities();
    }
 
    void AddLinkToGroup(LinkEntity* mEntity, Group mGroup)
    {
        groupedLinkEntities[mGroup].emplace_back(mEntity);
        aboutTo_updateActiveEntities();
    }
 
    const std::unordered_map<EntityID, std::unique_ptr<Entity>>& getEntities() const {
        return entities;
    }
 
    template <typename T>
    std::vector<Entity*> getVisible() {
        if constexpr (std::is_same_v<T, EmptyEntity>) {
            return visible_emptyEntities;
        }
        else if constexpr (std::is_same_v<T, NodeEntity>) {
            return visible_nodes;
        }
        else if constexpr (std::is_same_v<T, LinkEntity>) {
            return visible_links;
        }
        else {
            static_assert(sizeof(T) == 0, "Unsupported entity type.");
        }
    }
 
    template <typename T>
    std::vector<Entity*>& getVisibleGroup(Group mGroup) {
        if constexpr (std::is_same_v<T, EmptyEntity>) {
            return visible_groupedEmptyEntities[mGroup];
        }
        else if constexpr (std::is_same_v<T, NodeEntity>) {
            return visible_groupedNodeEntities[mGroup];
        }
        else if constexpr (std::is_same_v<T, LinkEntity>) {
            return visible_groupedLinkEntities[mGroup];
        }
        else {
            static_assert(sizeof(T) == 0, "Unsupported entity type.");
        }
    }
 
    template <typename T>
    void getAllTypeEntities(std::vector<Entity*>& output) {
        output.clear();
 
        if constexpr (std::is_same_v<T, EmptyEntity>) {
            for (auto& groupPair : groupedEmptyEntities) {
                output.insert(output.end(), groupPair.begin(), groupPair.end());
            }
        }
        else if constexpr (std::is_same_v<T, NodeEntity>) {
            for (auto& groupPair : groupedNodeEntities) {
                output.insert(output.end(), groupPair.begin(), groupPair.end());
            }
        }
        else if constexpr (std::is_same_v<T, LinkEntity>) {
            for (auto& groupPair : groupedLinkEntities) {
                output.insert(output.end(), groupPair.begin(), groupPair.end());
            }
        }
        else {
            static_assert(sizeof(T) == 0, "Unsupported entity type.");
        }
    }
 
    template <typename T>
    std::vector<Entity*>& getGroup(Group mGroup) {
        if constexpr (std::is_same_v<T, EmptyEntity>) {
            return groupedEmptyEntities[mGroup];
        }
        else if constexpr (std::is_same_v<T, NodeEntity>) {
            return groupedNodeEntities[mGroup];
        }
        else if constexpr (std::is_same_v<T, LinkEntity>) {
            return groupedLinkEntities[mGroup];
        }
        else if constexpr (std::is_same_v<T, Entity>) {
            return groupedLinkEntities[mGroup];
        }
        else {
            static_assert(sizeof(T) == 0, "Unsupported entity type.");
        }
    }
 
    inline std::vector<Entity*> getGroup_All(Group mGroup) {
        std::vector<Entity*> result;
 
        auto& empties = groupedEmptyEntities[mGroup];
        auto& nodes = groupedNodeEntities[mGroup];
        auto& links = groupedLinkEntities[mGroup];
 
        result.reserve(empties.size() + nodes.size() + links.size());
 
        result.insert(result.end(), empties.begin(), empties.end());
        result.insert(result.end(), nodes.begin(), nodes.end());
        result.insert(result.end(), links.begin(), links.end());
 
        return result;
    }
 
    template <typename T, typename... TArgs>
    T& addEntityNoId(TArgs&&... mArgs)
    {
        T* e(new T(*this, std::forward<TArgs>(mArgs)...));
        {
            std::unique_lock lock(entities_mtx);
            e->setId(negativeEntityId--);
            std::unique_ptr<T> uPtr{ e };
            entities.emplace(e->getId(), std::move(uPtr));
        }
 
        e->onCreation(); //? dont change its position, huge loading times
 
        aboutTo_updateActiveEntities();
 
        return *e;
    }
 
    template <typename T, typename... TArgs>
    T& addEntity(TArgs&&... mArgs)
    {
        T* e(new T(*this, std::forward<TArgs>(mArgs)...));
        {
            std::unique_lock lock(entities_mtx);
            e->setId(lastEntityId++);
            std::unique_ptr<T> uPtr{ e };
            entities.emplace(e->getId(), std::move(uPtr));
        }
 
        e->onCreation();
 
        aboutTo_updateActiveEntities();
 
        return *e;
    }
 
    template <typename T, typename... TArgs>
    T& addEntityWithId(EntityID customId, TArgs&&... mArgs)
    {
        T* e(new T(*this, std::forward<TArgs>(mArgs)...));
 
        {
            std::unique_lock lock(entities_mtx);
            e->setId(customId);
            std::unique_ptr<T> uPtr{ e };
            entities.emplace(customId, std::move(uPtr));
        }
 
        e->onCreation();
 
        aboutTo_updateActiveEntities();
        return *e;
    }
 
    template <typename T, typename... TArgs>
    T& addEntityFromParent(Entity* pEntity, const char* newID = "", TArgs&&... mArgs)
    {
        T* e(new T(*this, std::forward<TArgs>(mArgs)...));
        {
            std::unique_lock lock(entities_mtx);
 
            if ((newID != NULL) && (newID[0] != '\0')) {
                e->setId((pEntity ?
                    EntityIDUtils::toString(pEntity->getId())
                    : "")
                    + "-" + newID
                );
            }
            else {
                e->setId((pEntity ?
                    EntityIDUtils::toString(pEntity->getId())
                    : "")
                    + "-" + EntityIDUtils::toString(negativeEntityId--)
                );
            }
 
            std::unique_ptr<T> uPtr{ e };
            entities.emplace(e->getId(), std::move(uPtr));
        }
 
        aboutTo_updateActiveEntities();
 
        return *e;
    }
 
    void resetEntityId() {
        lastEntityId = 0;
    }
 
    void setNewLastEntityId() {
        std::unique_lock lock(entities_mtx);
 
        int maxIntId = std::numeric_limits<int>::min();
        bool foundInt = false;
 
        for (const auto& [id, ptr] : entities)
        {
            if (std::holds_alternative<int>(id)) {
                int value = std::get<int>(id);
                if (value > maxIntId) {
                    maxIntId = value;
                    foundInt = true;
                }
            }
        }
 
        if (foundInt)
            lastEntityId = maxIntId + 1;
        else
            lastEntityId = 0;   // or whatever default you want
    }
 
    inline Entity* getEntityFromId(EntityID mId) {
        std::shared_lock lock(entities_mtx);
        return entities[mId].get();
    }
 
    inline std::vector<Entity*> getEntities_FromIds(std::vector<EntityID> mIds) {
        std::shared_lock lock(entities_mtx);
 
        std::vector<Entity*> result;
        result.reserve(mIds.size());
 
        for (EntityID id : mIds) {
            if (entities.contains(id)) {
                result.push_back(entities[id].get());
            }
        }
 
        return result;
    }
 
    //? Probably dont need this
    //inline std::vector<EntityID> getIds_FromEntities(std::vector<Entity*> mEntities) {
    //  std::shared_lock lock(entities_mtx);
 
    //  std::vector<EntityID> result;
    //  result.reserve(mEntities.size());
 
    //  for (Entity* e : mEntities) {
    //      result.push_back(e->getId());
    //  }
 
    //  return result;
    //}
 
    bool hasEntity(EntityID mId) {
        std::shared_lock lock(entities_mtx);
        return entities.contains(mId);
    }
 
    void clearAllEntities() {
        for (auto& group : groupedNodeEntities) {
            group.clear();
        }
        for (auto& group : groupedLinkEntities) {
            group.clear();
        }
        {
            std::unique_lock lock(entities_mtx);
            entities.clear();
        }
    }
 
    void removeAllEntites() {
        for (auto group : groupNames) {
            removeAllEntitiesFromGroup(group.first);
            removeAllEntitiesFromLinkGroup(group.first);
        }
    }
 
    void removeAllEntitiesFromGroup(Group mGroup) {
        auto& entitiesInGroup = groupedNodeEntities[mGroup];
 
        for (auto& entity : entitiesInGroup) {
            entity->destroy();
        }
    }
 
    void removeAllEntitiesFromEmptyGroup(Group mGroup) {
        auto& entitiesInGroup = groupedEmptyEntities[mGroup];
 
        for (auto& entity : entitiesInGroup) {
            entity->destroy();
        }
    }
 
    void removeAllEntitiesFromLinkGroup(Group mGroup) {
        auto& entitiesInGroup = groupedLinkEntities[mGroup];
 
        for (auto& entity : entitiesInGroup) {
            entity->destroy();
        }
    }
 
    std::vector<EntityID> adjacentEntities(Entity* mainEntity, Group group) {
        std::vector<EntityID> nearbyEntities;
 
        auto adjacentCells = grid->getAdjacentCells(*mainEntity, grid->getGridLevel());
 
        for (Cell* adjCell : adjacentCells) {
            for (auto& neighbor : adjCell->nodes) {
                if (getEntityFromId(neighbor)->hasGroup(group) && (getEntityFromId(neighbor) != mainEntity)) {
                    nearbyEntities.push_back(neighbor);
                }
            }
        }
 
        return nearbyEntities;
    }
 
    enum groupLabels : std::size_t
    {
        //back
        groupBackgroundLayer,
        panelBackground,
 
        groupGridLinks,
 
        groupSelectedEntities,
 
        groupDebugBoxEntities,
        groupDebugRectangleEntities,
        //action
        groupLinks_0,
        groupGroupLinks_0,
        groupGroupLinks_1,
 
        groupPathLinks,
 
        groupPathInnerLinks,
 
        groupPathLinksHolder,
 
        groupArrowHeads_0,
 
        groupNodes_0,
        groupGroupNodes_0,
        groupGroupNodes_1,
 
        groupMinimapNodes,
 
        groupColliders,
 
        groupEmpties,
        groupSphereEmpties,
 
        groupWireframeSphereEmpties,
 
        groupRenderSprites,
 
        groupPorts,
        groupPortSlots,
 
        //fore
        textLabels,
        __COUNT__
    };
 
 
    std::unordered_map<Group, std::string> groupNames = {
        {groupBackgroundLayer, "groupBackgroundLayer" },
        {panelBackground, "panelBackground"},
 
        { groupGridLinks,"groupGridLinks" },
 
        { groupSelectedEntities, "groupSelectedEntities" },
 
        {groupDebugBoxEntities, "groupDebugBoxEntities"},
        {groupDebugRectangleEntities, "groupDebugRectangleEntities"},
        //action
        { groupLinks_0,"groupLinks_0" },
        {groupGroupLinks_0, "groupGroupLinks_0"},
        {groupGroupLinks_1, "groupGroupLinks_1"},
 
        {groupPathLinks, "groupPathLinks"},
 
        {groupPathInnerLinks, "groupPathInnerLinks"},
 
        {groupPathLinksHolder, "groupPathLinksHolder"},
 
        {groupArrowHeads_0, "groupArrowHeads_0"},
 
        { groupNodes_0,"groupNodes_0" },
        { groupGroupNodes_0, "groupGroupNodes_0"},
        { groupGroupNodes_1, "groupGroupNodes_1"},
 
        { groupMinimapNodes,"groupMinimapNodes" },
 
        { groupEmpties,"groupEmpties" },
        { groupSphereEmpties,"groupSphereEmpties" },
 
        { groupWireframeSphereEmpties,"groupWireframeSphereEmpties" },
 
        { groupColliders,"groupColliders" },
        { groupRenderSprites,"groupRenderSprites" },
        { groupPorts,"groupPorts" },
        { groupPortSlots,"groupPortSlots" },
 
        //fore
        { textLabels,"textLabels" },
    };
 
    std::size_t nextGroup = groupLabels::__COUNT__;
 
    void addGroup(std::string groupName) {
        auto newGroup = nextGroup++;
        groupNames.insert(std::make_pair(newGroup, groupName));
    }
 
    std::string getGroupName(Group mGroup) const;
 
    void scanComponentNames(const std::string& folderPath);
 
    void setComponentNames();
 
    std::vector<Entity*> collectVisibleEntities(
        std::initializer_list<Manager::groupLabels> groupNames,
        Taz::EntityType type);
 
    std::vector<Entity*> collectEntities(
        std::initializer_list<Manager::groupLabels> groupNames,
        Taz::EntityType type);
 
    bool entities_AllSameType(std::vector<Entity*> entities);
 
};