#pragma once
#include <map>
#include <unordered_map>
#include <memory>
#include <vector>
#include <mutex>
#include <limits>
#include "CCallbackHandler.h"

#include <iostream>

template <class Base>
class AbstractCreator
{
public:
    virtual ~AbstractCreator() = default;
    virtual Base* create() const = 0;
};

template <class C, class Base>
class Creator : public AbstractCreator<Base>
{
public:
    Base* create() const override { return new C(); }
};

template <class IdType>
class CObjectFactoryBase
{
public:
    virtual ~CObjectFactoryBase() = default;
    virtual std::vector<IdType> GetRegisteredIds() const { return {}; }
    virtual std::vector<IdType> GetRegisteredIdsNative() const { return {}; }

    virtual size_t GetIndexNative(const IdType& id) const { return 0; }
    virtual size_t GetIndex(const IdType& id) const { return 0; }

    IdType GetByID(size_t id) const
    {
        auto it = IdCache.find(id);
        if(it == IdCache.end()) { return {}; }
        return it->second;
    }

    void RecacheIds()
    {
        IdCache.clear();
        auto ids = GetRegisteredIds();

        for(auto& id : ids)
        {
            IdCache.emplace(GetIndex(id), id);
        }
    }

    void AddScriptClass(const IdType& id)
    {
        ScriptClasses.push_back(id);
        RecacheIds();
    }

    void RemoveScriptClass(const IdType& id)
    {
        std::erase(ScriptClasses, id);
        RecacheIds();
    }

    std::vector<IdType> ScriptClasses;
    std::unordered_map<size_t, IdType> IdCache;
};

template <class Base, class IdType>
class CObjectFactory : public CObjectFactoryBase<IdType> //TODO exists && getcount aren't interacting with custom creation funcs
{
public:
    using PBase = CObjectFactoryBase<IdType>; //as in Parent Base

    using AbstractFactory = std::unique_ptr<AbstractCreator<Base>>;
    using FactoryMap = std::unordered_map<IdType, AbstractFactory>;

    CObjectFactory() = default;
    virtual ~CObjectFactory() = default;

    template <class C>
    void add(const IdType& id)
    {
        //std::lock_guard<std::mutex> lock(factoryMutex);
        if (Factory.find(id) == Factory.end())
        {
            Factory[id] = std::make_unique<Creator<C, Base>>();
            PBase::RecacheIds();
        }
    }

    template <class C>
    void replace(const IdType& id) //TODO script classes support
    {
        auto it = Factory.find(id);
        if(it != Factory.end())
        {
            Factory.erase(it);
        }

        Factory[id] = std::make_unique<Creator<C, Base>>();
        PBase::RecacheIds();
    }

    Base* createRaw(const IdType& id) const
    {
        //std::lock_guard<std::mutex> lock(factoryMutex);

        if(!OnTryCreateHandler.IsEmpty())
        {
            Base* bs = nullptr;
            for(auto& func : OnTryCreateHandler.Functions)
            {
                bs = static_cast<Base*>(func(id));
                if(bs) { break; }
            }

            if(bs)
            {
                OnCreate(bs);
                return bs;
            }
        }

        auto it = Factory.find(id);
        if (it != Factory.end())
        {
            Base* obj = it->second->create();
            OnCreate(obj);

            return obj;
        }
        return nullptr;
    }

    template <typename PtrType = std::shared_ptr<Base>>
    PtrType create(const IdType& id) const
    {
        //std::lock_guard<std::mutex> lock(factoryMutex);

        if(!OnTryCreateHandler.IsEmpty())
        {
            Base* bs = nullptr;
            for(auto& func : OnTryCreateHandler.Functions)
            {
                bs = static_cast<Base*>((*func)(id));
                if(bs) { break; }
            }

            if(bs)
            {
                std::unique_ptr<Base> obj(bs);
                OnCreate(obj.get());
                
                if constexpr (std::is_same_v<PtrType, std::shared_ptr<Base>>)
                {
                    return std::shared_ptr<Base>(std::move(obj));
                }
                return obj;
            }
        }

        auto it = Factory.find(id);
        
        if (it != Factory.end())
        {
            std::unique_ptr<Base> obj(it->second->create());
            OnCreate(obj.get());

            if constexpr (std::is_same_v<PtrType, std::shared_ptr<Base>>)
            {
                return std::shared_ptr<Base>(std::move(obj));
            }
            return obj;
        }
        return nullptr;
    }

    bool remove(const IdType& id)
    {
        //std::lock_guard<std::mutex> lock(factoryMutex);
        return Factory.erase(id) > 0;
    }

    size_t GetCount() const
    {
        //std::lock_guard<std::mutex> lock(factoryMutex);
        return Factory.size() + PBase::ScriptClasses.size();
    }

    size_t GetCountNative() const
    {
        //std::lock_guard<std::mutex> lock(factoryMutex);
        return Factory.size();
    }

    size_t GetIndexNative(const IdType& id) const override
    {
        //std::lock_guard<std::mutex> lock(factoryMutex);
        auto it = Factory.find(id);
        if (it != Factory.end())
        {
            return std::distance(Factory.begin(), it);
        }
        return std::numeric_limits<size_t>::max();
    }

    size_t GetIndex(const IdType& id) const override
    {
        //std::lock_guard<std::mutex> lock(factoryMutex);
        auto it = Factory.find(id);
        if (it != Factory.end())
        {
            return std::distance(Factory.begin(), it);
        }
        else
        {
            auto it2 = std::find(PBase::ScriptClasses.begin(), PBase::ScriptClasses.end(), id);
            if(it2 != PBase::ScriptClasses.end())
            {
                return Factory.size() + std::distance(PBase::ScriptClasses.begin(), it2);
            }
        }
        return std::numeric_limits<size_t>::max();
    }

    bool Exists(const IdType& id) const
    {
        //std::lock_guard<std::mutex> lock(factoryMutex);

        if(!OnTryFindHandler.IsEmpty())
        {
            for(auto& func : OnTryFindHandler.Functions)
            {
                if((*func)(id))
                {
                    return true;
                }
            }
        }
        return Factory.find(id) != Factory.end();
    }

    std::vector<IdType> GetRegisteredIds() const override
    {
        //std::lock_guard<std::mutex> lock(factoryMutex);
        std::vector<IdType> ids;
        for (const auto& pair : Factory)
        {
            ids.push_back(pair.first);
        }
        for(const auto& sclass : PBase::ScriptClasses)
        {
            ids.push_back(sclass);
        }
        return ids;
    }

    std::vector<IdType> GetRegisteredIdsNative() const override
    {
        //std::lock_guard<std::mutex> lock(factoryMutex);
        std::vector<IdType> ids;
        for (const auto& pair : Factory)
        {
            ids.push_back(pair.first);
        }
        return ids;
    }

    CCallbackHandler<void, Base*> OnCreate;
    CCallbackHandler<void*, const IdType&> OnTryCreateHandler;
    CCallbackHandler<bool, const IdType&> OnTryFindHandler;
private:
    FactoryMap Factory;
    mutable std::mutex factoryMutex;
};