#include "CComponentsManager.h"
#include "CEngine.h"
#include "CScriptingManager.h"

CComponentsManager::~CComponentsManager()
{
    //Trace([](CComponent* comp) { comp->DeInit(); });
}

void CComponentsManager::Add(std::unique_ptr<CComponent>&& comp)
{
    std::string type = comp->GetType();
    AddCache(type, comp->GetTypeInfo(), comp.get());

    Items[type] = std::move(comp);
    OnComponentAdd(type);

    auto man = CEngine::GetInstance()->Components.GetComponentTyped<CScriptingManager>();
	if(man)
	{
		man->CallHook(type + "_add");
	}
}

bool CComponentsManager::IsComponentPresent(const std::string& type) const
{
    return Items.find(type) != Items.end();
}

void CComponentsManager::AddCache(const std::string& name, std::type_index _type, CComponent* _component)
{
    hashCache.emplace(_type.hash_code(), _component);
    nameCache.emplace(name, _component);
}

void CComponentsManager::RemoveCache(CComponent* component)
{
    auto it_h = std::find_if(hashCache.begin(), hashCache.end(), [component](auto& kv) -> bool { return kv.second == component; });
    auto it_n = std::find_if(nameCache.begin(), nameCache.end(), [component](auto& kv) -> bool { return kv.second == component; });

    if(it_h != hashCache.end()) { hashCache.erase(it_h); }
    if(it_n != nameCache.end()) { nameCache.erase(it_n); }
}

void CComponentsManager::DeleteComponent(const std::string& type)
{
    auto it = Items.find(type);
    if(it != Items.end())
    {
        it->second->DeInit();

        RemoveCache(it->second.get());
        Items.erase(it);
    }
}

std::unique_ptr<CComponent>& CComponentsManager::GetComponent(const std::string& type)
{
    auto it = Items.find(type);
    if (it == Items.end()) { throw std::runtime_error("No such component"); }
    return it->second;
}

CComponent* CComponentsManager::GetComponentRaw(const std::string& type)
{
    auto it = Items.find(type);
    if (it == Items.end()) { return nullptr; }
    return it->second.get();
}

void CComponentsManager::CreateComponent(const std::string& type, bool instantInit)
{
    std::unique_ptr<CComponent> comp = CEngine::GetInstance()->ComponentsFactory.create<std::unique_ptr<CComponent>>(type);
    if(!comp) { return; }

    Add(std::move(comp));
    if(instantInit)
    {
        GetComponent(type)->Init();
        GetComponent(type)->PostInit();
    }
}

std::vector<CComponent*> CComponentsManager::getComponentsOrder()
{
    std::vector<CComponent*> components;
    for (auto& [id, comp] : Items)
    {
        components.push_back(comp.get());
    }

    auto comparator = [](CComponent* a, CComponent* b)
    {
        const auto getPriority = [](CComponent* comp) -> CComponentPriority*
        {
            return comp ? comp->GetPriority() : nullptr;
        };

        CComponentPriority* prioA = getPriority(a);
        CComponentPriority* prioB = getPriority(b);

        if (prioB && prioB->ShouldExecuteAfter(a->GetType()))
        {
            return true;
        }

        if (prioA && prioA->ShouldExecuteAfter(b->GetType()))
        {
            return false;
        }

        int keyA = prioA ? prioA->GetSortingKey() : 0;
        int keyB = prioB ? prioB->GetSortingKey() : 0;

        if (keyA != keyB)
        {
            return keyA > keyB;
        }

        return false;
    };

    std::stable_sort(components.begin(), components.end(), comparator);
    return components;
}

void CComponentsManager::Trace(const std::function<void(CComponent* nod)>& func)
{
    auto components = getComponentsOrder();
    
    for (auto comp : components)
    {
        func(comp);
    }
}

void CComponentsManager::ReverseTrace(const std::function<void(CComponent* nod)>& func)
{
    auto components = getComponentsOrder();

    for (auto it = components.rbegin(); it != components.rend(); ++it)
    {
        func(*it);
    }
}