#define IMPORT_CORE
#include "core/Components.h"

void initComponents(Components* c, size_t componentSize) {
    initHashMap(&c->entityToIndex, sizeof(Entity), sizeof(size_t));
    initList(&c->indexToEntity, sizeof(Entity));
    initList(&c->components, componentSize);
}

void destroyComponents(Components* c) {
    destroyHashMap(&c->entityToIndex);
    destroyList(&c->indexToEntity);
    destroyList(&c->components);
}

void* getOrAddComponent(Components* c, Entity e) {
    void* component = searchComponent(c, e);
    if(component != nullptr) {
        return component;
    }
    size_t index = c->components.length;
    putHashMapPair(&c->entityToIndex, &e, &index);
    addListData(&c->indexToEntity, &e);
    return addEmptyListData(&c->components);
}

void* searchComponent(Components* c, Entity e) {
    size_t* index = searchHashMapKey(&c->entityToIndex, &e);
    if(index == nullptr) {
        return nullptr;
    }
    return getListIndex(&c->components, *index);
}

bool removeComponent(Components* c, Entity e) {
    size_t* indexP = searchHashMapKey(&c->entityToIndex, &e);
    if(indexP == nullptr) {
        return false;
    }
    size_t lastIndex = c->components.length - 1;
    size_t index = *indexP;
    removeHashMapKey(&c->entityToIndex, &e);
    removeListIndexBySwap(&c->components, index);
    if(index == lastIndex) {
        removeListIndexBySwap(&c->indexToEntity, index);
        return true;
    }
    Entity other = getTypedListIndex(&c->indexToEntity, lastIndex, Entity);
    removeListIndexBySwap(&c->indexToEntity, index);
    putHashMapPair(&c->entityToIndex, &other, &index);
    return true;
}

void initComponentIterator(ComponentIterator* ci, Components* c) {
    ci->indexToEntity = getListStart(&c->indexToEntity);
    ci->indexToEntityEnd = getListEnd(&c->indexToEntity);
    ci->component = getListStart(&c->components);
    ci->componentEnd = getListEnd(&c->components);
    ci->componentSize = c->components.dataSize;
    ci->node = (ComponentNode){0};
}

bool hasNextComponentNode(ComponentIterator* ci) {
    return ci->indexToEntity != ci->indexToEntityEnd;
}

ComponentNode* nextComponentNode(ComponentIterator* ci) {
    ci->node.component = ci->component;
    ci->node.entity = *ci->indexToEntity;
    ci->indexToEntity++;
    ci->component = (char*)ci->component + ci->componentSize;
    return &ci->node;
}

void* getComponentsStart(Components* c) {
    return getListStart(&c->components);
}

void* getComponentsEnd(Components* c) {
    return getListEnd(&c->components);
}