#pragma once
#include <string>
#include <unordered_map>

#include "CScriptingEngine.h"
#include "CScriptClassInfo.h"
#include "CObjectFactory.h"

template<typename IdType = std::string>
class CScriptClassesManager
{
public:
    using ClassInfoMap = std::unordered_map<IdType, CScriptClassInfo<IdType>>;
    using ClassesList = std::vector<IdType>;

    class CDeleterBase
    {
    public:
        virtual void Delete() = 0;
        virtual ~CDeleterBase() {}
    };

    template<typename Base, typename Id>
    class CDeleter : public CDeleterBase
    {
    public:
        CDeleter(CObjectFactory<Base, Id>& _Factory, CFunctionBase<void*, const Id&>* _Function, CFunctionBase<bool, const Id&>* _FindFunction) : Factory(_Factory), Function(_Function), FindFunction(_FindFunction) {}
        ~CDeleter() { Delete(); }

        void Delete() override
        {
            Factory.OnTryCreateHandler.DeleteFunction(Function);
            Factory.OnTryFindHandler.DeleteFunction(FindFunction);
        }
        
        CObjectFactory<Base, Id>& Factory;
        CFunctionBase<void*, const Id&>* Function = nullptr;
        CFunctionBase<bool, const Id&>* FindFunction = nullptr;
    };

    template<typename Base>
    ClassInfoMap& GetClassInfoMap()
    {
        size_t hash = typeid(Base).hash_code();
        if(HashClassInfos.find(hash) == HashClassInfos.end())
        {
            HashClassInfos.insert({ hash, ClassInfoMap() });
        }
        return HashClassInfos.find(hash)->second;
    }

    template<typename Base>
    CObjectFactoryBase<IdType>& GetFactory()
    {
        size_t hash = typeid(Base).hash_code();
        return HashFactories.find(hash)->second.get();
    }

	template<typename Generic, typename Base>
	void SetFunction(CObjectFactory<Base, IdType>& factory)
	{
        size_t hash = typeid(Base).hash_code();
        if(HashClassInfos.find(hash) == HashClassInfos.end())
        {
            HashClassInfos.insert({ hash, ClassInfoMap() });
        }

        if(HashFactories.find(hash) == HashFactories.end())
        {
            HashFactories.insert({ hash, std::ref(factory) });
        }

		factory.OnTryCreateHandler += [this, hash](const IdType& id) -> void*
		{
            auto it_hash = HashClassInfos.find(hash);
            if(it_hash == HashClassInfos.end()) { return nullptr; }

            auto& ClassInfos = it_hash->second;

			auto it = ClassInfos.find(id);
			if(it == ClassInfos.end()) { return nullptr; }
			
			return (void*)(new Generic(it->second.LuaKey, it->second.Functions, it->second.State));
		};

        factory.OnTryFindHandler += [this, hash](const IdType& id) -> bool
        {
            auto it_hash = HashClassInfos.find(hash);
            if(it_hash == HashClassInfos.end()) { return false; }

            auto& ClassInfos = it_hash->second;

			auto it = ClassInfos.find(id);
			if(it == ClassInfos.end()) { return false; }

            return true;
        };

        CFunctionBase<void*, const IdType&>* func = factory.OnTryCreateHandler.GetLastFunctionRaw();
        CFunctionBase<bool, const IdType&>* findfunc = factory.OnTryFindHandler.GetLastFunctionRaw();
        Deleters.push_back(std::make_unique<CDeleter<Base, IdType>>(factory, func, findfunc));
	}

    template<typename Base>
    void RegisterClassInfo(const CScriptClassInfo<IdType>& info)
    {
        if(info.LuaKey.empty()) { return; }

        auto& info_map = GetClassInfoMap<Base>();
        auto& factory = GetFactory<Base>();

        if(info_map.find(info.LuaKey) != info_map.end()) { return; }

        info_map.insert({ info.LuaKey, info });
        factory.AddScriptClass(info.LuaKey);
    }

    template<typename Base>
    bool IsClassRegistered(const IdType& className) const
    {
        size_t hash = typeid(Base).hash_code();
        auto it = HashClassInfos.find(hash);
        if (it == HashClassInfos.end()) 
        {
            return false;
        }
        
        return it->second.find(className) != it->second.end();
    }

    template<typename Base>
    void UnregisterClassInfo(const IdType& id)
    {
        std::erase_if(GetClassInfoMap<Base>(), [&id](auto& kv) -> bool
        {
            return kv.second.LuaKey == id;
        });

        auto& factory = GetFactory<Base>();
        factory.RemoveScriptClass(id);
    }

    template<typename Base>
    void UnregisterClassesInfo(CScriptingEngine* engine)
    {
        std::erase_if(GetClassInfoMap<Base>(), [engine](auto& kv) -> bool
        {
            return kv.second.Engine == engine;
        });
    }

    template<typename Base>
    void UnregisterClassesInfo(sol::state_view st)
    {
        std::erase_if(GetClassInfoMap<Base>(), [&st](auto& kv) -> bool
        {
            return kv.second.State == st;
        });
    }
	
    template<typename Base>
	void ResetEngineClasses(CScriptingEngine* engine)
	{
        UnregisterClassesInfo<Base>(engine);
	}

    void UnregisterClassInfoEverywhere(const IdType& id)
    {
        for(auto& kv : HashClassInfos)
        {
            std::erase_if(kv.second, [&id](auto& kv) -> bool
            {
                return kv.second.LuaKey == id;
            });
        }
    }

    void UnregisterClassesInfoEverywhere(CScriptingEngine* engine)
    {
        for(auto& kv : HashClassInfos)
        {
            std::erase_if(kv.second, [engine](auto& kv) -> bool
            {
                return kv.second.Engine == engine;
            });
        }
    }

    void UnregisterClassesInfoEverywhere(sol::state_view st)
    {
        for(auto& kv : HashClassInfos)
        {
            std::erase_if(kv.second, [&st](auto& kv) -> bool
            {
                return kv.second.State == st;
            });
        }
    }
	
	void ResetEngineClassesEverywhere(CScriptingEngine* engine)
	{
        UnregisterClassesInfoEverywhere(engine);
	}
	
    std::vector<std::unique_ptr<CDeleterBase>> Deleters;
    std::unordered_map<size_t, ClassInfoMap> HashClassInfos;
    std::unordered_map<size_t, std::reference_wrapper<CObjectFactoryBase<IdType>>> HashFactories;

    //std::unique_ptr<CDeleterBase> Deleter;
	//ClassInfos;
};