#include "CEntitiesManager.h"
#include "CEngine.h"
#include "CGame.h"
#include "CServer.h"
#include "CClient.h"

#include <limits>
#include <algorithm>

CEntitiesManager::CEntitiesManager(worldid_t worldid) : WorldID(worldid) {}

bool CEntitiesManager::m_isValidWorld(worldid_t worldid)
{
    auto game = CEngine::GetInstance()->Components.GetComponentTyped<CGame>();
    auto world = game->Worlds.GetWorld(GetWorldID());

    return world;
}

worldid_t CEntitiesManager::GetWorldID() const
{
    return WorldID;
}

size_t CEntitiesManager::Count() const
{
    return Items.size();
}

CEntityHandle CEntitiesManager::CreateEntity(const std::string& type, bool sync)
{
    auto game = CEngine::GetInstance()->Components.GetComponentTyped<CGame>();
    auto world = game->Worlds.GetWorld(GetWorldID());

    if(!world) { return CEntityHandle(); }

    std::unique_ptr<CEntity> ent = CEngine::GetInstance()->EntitiesFactory.create<std::unique_ptr<CEntity>>(type);
    if(!ent) { return CEntityHandle(); }

    return m_addEntity(std::move(ent), sync);
}

CEntityHandle CEntitiesManager::m_addEntity(std::unique_ptr<CEntity>&& ent, bool sync)
{
    entityid_t id = GetNextFreeID();
    Items.insert({ id, std::move(ent) });

    Items[id]->OverridePersistent(random::random_static::get<serial_t>(), id, GetWorldID());
    Items[id]->SetNetSync(sync, false);

    for(auto& kv : initParams)
    {
        Items[id]->AddInitParam(kv.first, kv.second);
        Log::Instance() << "Passing " << kv.first << " to entity " << Items[id]->GetType() << Log::Endl;
    }
    ClearNextEntityParams();

    Items[id]->Init();

    auto server = CEngine::GetInstance()->Components.GetComponentTyped<CServer>();
    if(server && sync)
    {
        auto msg = std::make_shared<CNetEntityStart>();

        msg->Entity = CEntityHandle(Items[id].get());
        server->SendReliableMessageToAll(msg); //TODO should be reliable
    }

    Items[id]->PostInit();
    return CEntityHandle(Items[id].get());
}

void CEntitiesManager::DeleteEntity(const CEntityHandle& handle)
{
    auto it = std::find_if(Items.begin(), Items.end(), [&handle](auto& kv)
    {
        return handle == kv.second.get();
    });

    if(it != Items.end())
    {
        auto server = CEngine::GetInstance()->Components.GetComponentTyped<CServer>();
        if(server && handle.Get()->IsNetSync())
        {
            auto msg = std::make_shared<CNetEntityStop>();

            msg->Entity = CEntityHandle(it->second.get());
            server->SendReliableMessageToAll(msg); //TODO should be reliable
        }
        Items.erase(it);
    }
}

void CEntitiesManager::Trace(const std::function<void(CEntity* ent)>& func)
{
    for(auto& kv : Items)
    {
        func(kv.second.get());
    }
}

entityid_t CEntitiesManager::GetNextFreeID() const
{
    for(entityid_t i = 0; i < std::numeric_limits<entityid_t>::max(); i++)
    {
        if (Items.find(i) == Items.end())
        {
            return i;
        }
    }
    return std::numeric_limits<entityid_t>::max();
}

void CNetEntityStart::V_Write(CBufferWrapper& wrapper)
{
    auto entity = Entity.Get();
    auto& entfactory = CEngine::GetInstance()->EntitiesFactory;
    auto& cmpfactory = CEngine::GetInstance()->EntityComponentsFactory;
    
    auto entityType = entfactory.GetIndex(entity->GetType());

    wrapper.Write<std::uint16_t>(entity->GetUUID());
    wrapper.Write<std::uint16_t>(entityType);

    std::vector<std::uint8_t> _ent_data;
    CBufferWrapper _ent_wrapper(_ent_data);

    entity->FullPack(_ent_wrapper);

    wrapper.Write<std::uint16_t>(_ent_data.size());
    wrapper.WriteData(_ent_data.data(), _ent_data.size());

    std::vector<CEntityComponent*> toWrite;
    for(auto& kv : entity->Components.Items)
    {
        if(kv.second->NetSync)
        {
            toWrite.push_back(kv.second.get());
        }
    }

    wrapper.Write<std::uint16_t>(toWrite.size());

    for(auto comp : toWrite)
    {
        auto compType = cmpfactory.GetIndex(comp->GetType());

        wrapper.Write<std::uint16_t>(compType);

        std::vector<std::uint8_t> _comp_data;
        CBufferWrapper _comp_wrapper(_comp_data);

        comp->FullPack(_comp_wrapper);

        wrapper.Write<std::uint16_t>(_comp_data.size());
        wrapper.WriteData(_comp_data.data(), _comp_data.size());
    }
}

void CNetEntityStart::V_Read(CBufferWrapper& wrapper)
{
    std::uint16_t entid = wrapper.Read<std::uint16_t>();
    std::uint16_t enttype = wrapper.Read<std::uint16_t>();

    ServerEntityID = entid;

    auto& entfactory = CEngine::GetInstance()->EntitiesFactory;
    auto& cmpfactory = CEngine::GetInstance()->EntityComponentsFactory;

    auto game = CEngine::GetInstance()->Components.GetComponentTyped<CGame>();
    auto world = game->Worlds.GetWorld();

    auto it = std::find_if(world->Entities.Items.begin(), world->Entities.Items.end(), [entid](auto& kv) -> bool
    {
        return kv.second->GetUUID() == entid;
    });

    if(it != world->Entities.Items.end())
    {
        Log::ErrInstance() << "Entity ID duplicate\n"; //TODO disconnect -- fatal!
    }

    auto entstype = entfactory.GetByID(enttype);
    if(entstype.empty())
    {
        Log::ErrInstance() << "Entity invalid type\n"; //TODO disconnect -- fatal!
    }

    auto entSize = wrapper.Read<std::uint16_t>();
    auto _entData = wrapper.ReadData(entSize);

    std::vector<std::uint8_t> entData(_entData.get(), _entData.get() + entSize);

    EntityData.Type = entstype;
    EntityData.Data = std::move(entData);

    std::uint16_t compsCount = wrapper.Read<std::uint16_t>();

    for(std::uint16_t i = 0; i < compsCount; i++)
    {
        std::uint16_t compType = wrapper.Read<std::uint16_t>();

        auto compstype = cmpfactory.GetByID(compType);
        if(compstype.empty())
        {
            Log::ErrInstance() << "Component invalid type\n"; //TODO disconnect -- fatal!
        }

        auto compSize = wrapper.Read<std::uint16_t>();
        auto _compData = wrapper.ReadData(compSize);

        std::vector<std::uint8_t> compData(_compData.get(), _compData.get() + compSize);
        CData ccompData;

        ccompData.Type = compstype;
        ccompData.Data = std::move(compData);

        ComponentsData.push_back(std::move(ccompData));
    }
}

void CNetEntityStart::Process()
{
    auto client = CEngine::GetInstance()->Components.GetComponentTyped<CClient>();
    if(!client) { return; }

    auto game = CEngine::GetInstance()->Components.GetComponentTyped<CGame>();
    auto world = game->Worlds.GetWorld();

    auto enth = world->Entities.CreateEntity(EntityData.Type);
    auto ent = enth.Get();

    client->ServerEntityMap.emplace(ServerEntityID, ent->GetUUID());

    CBufferWrapper entData(EntityData.Data);
    ent->FullUnpack(entData);

    for(auto& _comp : ComponentsData)
    {
        ent->Components.CreateComponent(_comp.Type, false);
        auto& comp = ent->Components.GetComponent(_comp.Type);

        CBufferWrapper compData(_comp.Data);
        comp->FullUnpack(compData);
        
        comp->Init();
    }
}

void CNetEntityStop::V_Write(CBufferWrapper& wrapper)
{
    auto entity = Entity.Get();
    auto& entfactory = CEngine::GetInstance()->EntitiesFactory;
    auto& cmpfactory = CEngine::GetInstance()->EntityComponentsFactory;
    
    auto entityType = entfactory.GetIndex(entity->GetType());

    wrapper.Write<std::uint16_t>(entity->GetUUID());
    wrapper.Write<std::uint16_t>(entityType);
}

void CNetEntityStop::V_Read(CBufferWrapper& wrapper)
{
    auto client = CEngine::GetInstance()->Components.GetComponentTyped<CClient>();
    if(!client) { return; }

    std::uint16_t _entid = wrapper.Read<std::uint16_t>();
    std::uint16_t enttype = wrapper.Read<std::uint16_t>();

    std::uint16_t entid = client->ServerEntityMap[_entid];

    auto& entfactory = CEngine::GetInstance()->EntitiesFactory;
    auto& cmpfactory = CEngine::GetInstance()->EntityComponentsFactory;

    auto game = CEngine::GetInstance()->Components.GetComponentTyped<CGame>();
    auto world = game->Worlds.GetWorld();

    auto it = std::find_if(world->Entities.Items.begin(), world->Entities.Items.end(), [entid](auto& kv) -> bool
    {
        return kv.second->GetUUID() == entid;
    });

    if(it == world->Entities.Items.end())
    {
        Log::ErrInstance() << "No such entity\n"; //TODO disconnect -- fatal!
    }

    auto entstype = entfactory.GetByID(enttype);
    if(entstype.empty())
    {
        Log::ErrInstance() << "Entity invalid type\n"; //TODO disconnect -- fatal!
    }

    auto& entity = it->second;
    if(entity->GetType() != entstype)
    {
        Log::ErrInstance() << "Entity type mismatch\n"; //TODO disconnect -- fatal!
    }

    Entity = CEntityHandle(entity.get());
}

void CNetEntityStop::Process()
{
    if(!Entity.IsValid()) { return; }

    auto game = CEngine::GetInstance()->Components.GetComponentTyped<CGame>();
    auto world = game->Worlds.GetWorld();

    world->Entities.DeleteEntity(Entity);
}

void CEntitiesManager::SetNextEntityInitParam(const std::string& name, CWrapableBase* wrapable)
{
    initParams.emplace(name, wrapable);
}

void CEntitiesManager::ClearNextEntityParams()
{
    initParams.clear();
}

CEntityHandle CEntitiesManager::GetEntityByID(entityid_t id)
{
    auto it = std::find_if(Items.begin(), Items.end(), [id](auto& kv) { return kv.first == id && kv.second && kv.second->GetUUID() == id; });
    if(it == Items.end()) { return CEntityHandle(); }
    return CEntityHandle(it->second.get());
}

LINK_NET_MESSAGE_TO_CLASS(CNetEntityStart, entitystart);
LINK_NET_MESSAGE_TO_CLASS(CNetEntityStop, entitystop);