#include "CConVarManager.h"
#include "CEngine.h"
#include "CScriptingManager.h"
#include "ILuaWrapableBase.h"
#include "CWrapable.h"
#include "CAngle.h"

#include <stdexcept>
#include <functional>
#include <map>
#include <vector>
#include <string>
#include <glm/gtc/quaternion.hpp>
#include <glm/glm.hpp>

template<typename T>
std::function<CWrapableBase*(sol::object)> CVarCreateFunction()
{
    return [](sol::object obj) -> CWrapableBase*
    {
        CWrapable<T>* ret = new CWrapable<T>();

        if(obj.valid())
        {
            ILuaWrapableBase* luawrap = dynamic_cast<ILuaWrapableBase*>(ret);
            luawrap->SetFromLua(obj);
        }
        return ret;
    };
}

std::vector<std::pair<std::string, std::function<CWrapableBase*(sol::object)>>> CVarTypesTable = //TODO more types! unify types with QuatVecNewFunction (CScriptingEngine)
{
    { "bool", CVarCreateFunction<bool>() },
    { "int", CVarCreateFunction<long long>() },
    { "uint", CVarCreateFunction<unsigned long long>() },
    { "float", CVarCreateFunction<float>() },
    { "double", CVarCreateFunction<double>() },
    { "angle", CVarCreateFunction<CAngle>() },
    { "angles", CVarCreateFunction<CAngles>() },
    { "quat", CVarCreateFunction<glm::quat>() },
    { "vec2", CVarCreateFunction<glm::vec2>() },
    { "vec3", CVarCreateFunction<glm::vec3>() },
    { "vec4", CVarCreateFunction<glm::vec4>() },
    { "string", CVarCreateFunction<std::wstring>() },
    { "string8", CVarCreateFunction<std::string>() },
    { "wstring", CVarCreateFunction<std::wstring>() }
};

std::map<std::string, std::pair<int, std::function<CWrapableBase*(sol::object)>>> CVarTypesTabl = 
{
    { "int", { 0, CVarCreateFunction<long long>() } },
    { "uint", { 1, CVarCreateFunction<unsigned long long>() } },
    { "float", { 2, CVarCreateFunction<float>() } },
    { "double", { 3, CVarCreateFunction<double>() } },
    { "angle", { 4, CVarCreateFunction<CAngle>() } },
    { "angles", { 5, CVarCreateFunction<CAngles>() } },
    { "quat", { 6, CVarCreateFunction<glm::quat>() } },
    { "vec2", { 7, CVarCreateFunction<glm::vec2>() } },
    { "vec3", { 8, CVarCreateFunction<glm::vec3>() } },
    { "vec4", { 9, CVarCreateFunction<glm::vec4>() } },
    { "string", { 10, CVarCreateFunction<std::wstring>() } },
    { "string8", { 11, CVarCreateFunction<std::string>() } },
    { "wstring", { 12, CVarCreateFunction<std::wstring>() } },
};

bool CConVarManager::V_Init()
{
    return true;
}

bool CConVarManager::IsConVarExist(const std::string& path)
{
    return GetConVar(path);
}

CConVarManager::CVarRawPtr CConVarManager::GetConVar(const std::string& path)
{
    //std::shared_lock guard(m_Mutex); //TODO is required?

    CVarNode* nod = Root.GetNode(path);
    if(!nod) { return nullptr; }

    return nod->Value.Wrapable ? nod->Value.Wrapable.get() : nullptr;
}

CConVarManager::CVarNode* CConVarManager::AddConVar(const std::string& path, CConVarManager::CVarRawPtr ptr)
{
    if(!ptr) { return nullptr; }

    //std::lock_guard guard(m_Mutex); //TODO is required?

    CVarNode* nod = Root.CreateNode(path);
    if(nod->Value.Wrapable) { throw std::runtime_error("Convar already exist"); }

    nod->Value.Wrapable = CVarPtr(ptr);
    return nod;
}

bool CConVarManager::DeleteConVar(const std::string& path)
{
    //std::lock_guard guard(m_Mutex); //TODO is required?

    CVarNode* nod = Root.GetNode(path);
    if(!nod) { return false; }

    Root.DeleteNode(nod);
    return true;
}

CConVarManager::CVarNode* CConVarManager::GetRealConVarNode(const std::string& path)
{
    //std::shared_lock guard(m_Mutex); //TODO is required?
    return Root.GetNode(path);
}

CConVarManager::RealCVar& CConVarManager::GetRealConVar(const std::string& path)
{
    //std::shared_lock guard(m_Mutex); //TODO is required?

    CVarNode* nod = Root.GetNode(path);
    if(!nod) { throw std::runtime_error("No such convar"); }

    return nod->Value;
}

bool CConVarManager::V_ScriptInit(std::shared_ptr<sol::state> state, sol::table table)
{
    if(state->get<sol::object>("cvar") == sol::lua_nil)
    {
        sol::table cvar = state->create_named_table("cvar");
        sol::table type = cvar.create_named("type");

        size_t index = 0;
        for(auto& kv : CVarTypesTable)
        {
            type.set(kv.first, index);
            index++;
        }
    }

    table.set_function("getcvar", [this](const std::string& path, sol::this_state ts) -> sol::object
    {
        if(!IsConVarExist(path)) { return sol::lua_nil; }
        auto engine = CEngine::GetInstance()->Components.GetComponentTyped<CScriptingManager>()->GetEngine(ts);

        auto cvar = GetRealConVarNode(path);
        sol::table ret = cvar->Value.GetScriptTable(ts);

        //sol::table ret = engine->ConvarCache.GatedDeleteOrGet(cvar ? cvar->GetPath() : "", cvar);
        return ret;
    });

    table.set_function("createcvar", [this](const std::string& path, int type, sol::object obj, sol::this_state ts) -> sol::object
    {
        auto cvar = GetConVar(path);
        if(cvar) { return sol::lua_nil; }

        if(type < 0 || type >= CVarTypesTable.size()) { return sol::lua_nil; }

        auto node = AddConVar(path, CVarTypesTable.at(type).second(obj));
        auto engine = CEngine::GetInstance()->Components.GetComponentTyped<CScriptingManager>()->GetEngine(ts);

        //return engine->ConvarCache.Get(node->GetPath());
        return node->Value.GetScriptTable(ts);
    });

    table.set_function("deletecvar", [this](const std::string& path) -> int
    {
        return DeleteConVar(path) ? 0 : 1;
    });
    return true;
}

LINK_SOL_USERTYPE(CConVarManager);
LINK_COMPONENT_TO_CLASS(CConVarManager, convarmanager);