#include "CScriptingEngine.h"
#include "CEngine.h"
#include "CScriptingManager.h"

#include "CLuaPreProcessor.h"
#include "CScenesManager.h"
#include "U_Log.h"
#include "CLogger.h"
#include "U_ScriptClasses.h"
#include "U_Scripting.h"

#include <algorithm>

CScriptingEngine::~CScriptingEngine()
{
    COMPONENT_CALL(CScriptingManager, ResetEngineClasses(this));
}

void CScriptingEngine::V_Init() {}

template<typename T>
std::function<sol::table(sol::variadic_args)> QuatVecNewFunction()
{
    return [](sol::variadic_args va) -> sol::table
    {
        T ret;
        for(size_t i = 0; i < ret.length(); i++)
        {
            ret[i] = typename T::value_type{};
        }
        for (size_t i = 0; i < va.size() && i < ret.length(); i++)
        {
            ret[i] = va.get<typename T::value_type>(i);
        }
        return ScriptUtils::ToObject<T>(ret, va.lua_state());
        //return sol::make_object_userdata<T>(va.lua_state(), ret);
    };

    /*return [](sol::variadic_args va) -> sol::table
    {
        auto shared = std::make_shared<T>();

        for (size_t i = 0; i < shared->length(); i++)
        {
            (*shared)[i] = typename T::value_type{};
        }
        for (size_t i = 0; i < va.size() && i < shared->length(); i++)
        {
            (*shared)[i] = va.get<typename T::value_type>(i);
        }

        sol::table tabl = ScriptUtils::ToObject(*shared, va.lua_state());
        tabl["__obj"] = shared;

        return tabl;
    };*/
}

class CLuaDestructor
{
public:
    CCallbackHandler<void> OnDestruct;

    sol::function fn;
    CLuaDestructor(sol::function f) : fn(std::move(f)) {}

    ~CLuaDestructor()
    {
        if (fn.valid())
        {
            fn();
        }
    }
};

template<typename T>
auto VectorCreationFunc()
{
    using VT = T::value_type;
    constexpr size_t L = T::length();

    return sol::overload
    (
        []() -> T
        {
            return T{};
        },
        [](VT _x)
        {
            if constexpr (L == 1) { return T(_x); }
            if constexpr (L == 2) { return T(_x, _x); }
            if constexpr (L == 3) { return T(_x, _x, _x); }
            if constexpr (L == 4) { return T(_x, _x, _x, _x); }
        },
        [](VT _x, VT _y)
        {
            if constexpr (L == 1) { return T(_x); }
            if constexpr (L == 2) { return T(_x, _y); }
            if constexpr (L == 3) { return T(_x, _y, VT{}); }
            if constexpr (L == 4) { return T(_x, _y, VT{}, VT{}); }
        },
        [](VT _x, VT _y, VT _z)
        {
            if constexpr (L == 1) { return T(_x); }
            if constexpr (L == 2) { return T(_x, _y); }
            if constexpr (L == 3) { return T(_x, _y, _z); }
            if constexpr (L == 4) { return T(_x, _y, _z, VT{}); }
        },
        [](VT _x, VT _y, VT _z, VT _w)
        {
            if constexpr (L == 1) { return T(_x); }
            if constexpr (L == 2) { return T(_x, _y); }
            if constexpr (L == 3) { return T(_x, _y, _z); }
            if constexpr (L == 4) { return T(_x, _y, _z, _w); }
        },
        [](const T& v)
        {
            return T(v);
        }
    );
}

CScriptingEngine::CScriptingEngine() : ComponentsManager(State)
{
    //COMPONENT_CALL(CScriptingManager, PushCurrentEngine(this));

    State = std::make_shared<sol::state>();
    State->open_libraries(sol::lib::base, sol::lib::string, sol::lib::table, sol::lib::math);
    
    State->set_function("getFieldsMan", [](sol::table tabl) -> sol::object
    {
        tabl[CScriptFieldsManager::GetDefaultKey()];
        //TODO return script table of field man of table 'tabl'
        return sol::lua_nil;
    });

    auto engine = State->create_named_table("engine");
    auto hook = State->create_named_table("Hook");
    auto components = engine.create_named("components");
    auto entities = engine.create_named("entities");
    auto criticallog = engine.create_named("criticallog");
    auto math = engine.create_named("math");

    State->set_function("CreateVector", VectorCreationFunc<glm::vec3>);
    State->set_function("CreateVector1f", VectorCreationFunc<glm::vec1>);
    State->set_function("CreateVector2f", VectorCreationFunc<glm::vec2>);
    State->set_function("CreateVector3f", VectorCreationFunc<glm::vec3>);
    State->set_function("CreateVector4f", VectorCreationFunc<glm::vec4>);
    State->set_function("CreateVector1", VectorCreationFunc<glm::vec1>);
    State->set_function("CreateVector2", VectorCreationFunc<glm::vec2>);
    State->set_function("CreateVector3", VectorCreationFunc<glm::vec3>);
    State->set_function("CreateVector4", VectorCreationFunc<glm::vec4>);

    State->set_function
    (
        "CreateTransform",
        sol::overload
        (
            []() -> CTransform
            {
                return CTransform();
            },
            [](const CTransformBase& trans) -> CTransform
            {
                CTransform ret;
                ret.SetPRS(trans.GetPRS());
                return ret;
            },
            [](const CTransform& trans) -> CTransform
            {
                CTransform ret;
                ret.SetPRS(trans.GetPRS());
                return ret;
            },
            [](const CTransformBase::CMeasurePack& trans) -> CTransform
            {
                CTransform ret;
                ret.SetPRS(trans);
                return ret;
            },
            [](const glm::vec3& pos) -> CTransform
            {
                CTransform ret;
                ret.SetPosition(pos);
                return ret;
            },
            [](const glm::vec3& pos, const glm::quat& quat, const glm::vec3& scl) -> CTransform
            {
                CTransform ret;
                ret.SetPRS(pos, quat, scl);
                return ret;
            },
            [](const glm::vec3& pos, const glm::quat& quat) -> CTransform
            {
                CTransform ret;
                ret.SetPR(pos, quat);
                return ret;
            },
            [](const glm::vec3& pos, const CAngles& angles) -> CTransform
            {
                CTransform ret;
                ret.SetPosition(pos);
                ret.GetEulerRotation().SetRotation(angles);
                return ret;
            },
            [](const glm::vec3& pos, const CAngles& angles, const glm::vec3& scl) -> CTransform
            {
                CTransform ret;
                ret.SetPS(pos, scl);
                ret.GetEulerRotation().SetRotation(angles);
                return ret;
            }
        )
    );

    State->new_usertype<CLuaDestructor> //TODO destructor using __gc or shared_ptr
    (
        "CLuaDestructor",
        sol::no_constructor
    );

    State->set_function("make_destructor", [](sol::object target, sol::function destructor, sol::this_state ts)
    {
        if(!target.valid() || !destructor.valid()) { return; }

        sol::state_view lua = ts;
        std::shared_ptr<CLuaDestructor> ud = std::make_shared<CLuaDestructor>(destructor);
        if (target.is<sol::table>())
        {
            sol::table t = target.as<sol::table>();
            t["_destructor"] = ud;
            t["_onDestruct"] = ud->OnDestruct.GetScriptTable(ts);
        }
    });

    engine["time"] = CEngine::GetInstance()->Time.GetScriptTable(State);

    auto callback = State->create_named_table("callback");
    callback.set_function("create", [](sol::this_state ts) -> sol::table
    {
        auto obj = std::make_shared<CCallbackHandler<sol::object, sol::variadic_args>>();
        sol::table tabl = obj->GetScriptTable(ts);

        tabl["__obj"] = obj;
        return tabl;
    });

    engine.set_function("getMainCameraTransform", [](sol::this_state ts) -> sol::table //TODO temporary
    {
        auto scenesMan = CEngine::GetInstance()->Components.GetComponentTyped<CScenesManager>();
        if(!scenesMan) { return sol::lua_nil; }

        auto mainScene = scenesMan->ActiveScene;

        if(!mainScene.lock()) { return sol::lua_nil; }
        auto _mainCamera = mainScene.lock()->CamerasManager.ActiveCamera;

        if(!_mainCamera.lock()) { return sol::lua_nil; }
        auto mainCamera = _mainCamera.lock();

        return mainCamera->Transform.GetScriptTable(ts);
    });

    criticallog.set_function("out", [](const std::wstring& str, sol::object obj)
    {
        std::string path = "critical.txt";

        if(obj.valid() && obj.is<std::string>())
        {
            path = obj.as<std::string>();
        }
        Log::Critical(str, path);
    });

    criticallog.set_function("outln", [](const std::wstring& str, sol::object obj)
    {
        std::string path = "critical.txt";

        if(obj.valid() && obj.is<std::string>())
        {
            path = obj.as<std::string>();
        }
        Log::CriticalLn(str, path);
    });

    math.set_function("angleAxis", [](sol::this_state ts, const CAngle& angle, const glm::vec3& vec) -> auto
    {
        return sol::make_object_userdata<glm::quat>(ts, glm::angleAxis(angle.asRadians(), vec));
    });

    sol::table onComponentAdd = CEngine::GetInstance()->Components.OnComponentAdd.GetScriptTable(State);
    sol::table onComponentInit = CEngine::GetInstance()->Components.OnComponentInit.GetScriptTable(State);
    sol::table onComponentPostInit = CEngine::GetInstance()->Components.OnComponentPostInit.GetScriptTable(State);

    components["onComponentAdd"] = onComponentAdd;
    components["onComponentInit"] = onComponentInit;
    components["onComponentPostInit"] = onComponentPostInit;

    components.set_function("prepareNew", [](sol::object typenmObj, sol::variadic_args va, sol::this_state ts) -> sol::table
    {
        sol::table ret = sol::state_view(ts).create_table();
        ret.set("root_type", "component");

        if(typenmObj.valid() && typenmObj.is<std::string>())
        {
            ret.set("type", typenmObj.as<std::string>());
        }

        std::string nm;
        for (size_t i = 0; i < va.size(); i++)
        {
            //0 - name
            //1 - func
            //2 - name
            //3 - func

            if(i % 2 == 0) //name
            {
                nm = va.get<std::string>(i);
            }
            else //func
            {
                sol::object funcobj = va.get<sol::object>(i);
                if(funcobj.valid() && funcobj.is<sol::function>() && !nm.empty())
                {
                    ret.set(nm, funcobj);
                }
            }
        }

        //constructor
        //destructor
        //init
        //postinit
        //update

        return ret;
    });

    components.set_function("registerNew", InvokeRegisterFunction<CComponent, "component">);
    entities.set_function("registerNew", InvokeRegisterFunction<CEntity, "entity">);

    components.set_function("create", [this](const std::string& type, sol::object instantInitObj) -> sol::object
    {
        bool instantInit = true;
        if(instantInitObj.valid() && instantInitObj.is<bool>())
        {
            instantInit = instantInitObj.as<bool>();
        }

        auto& comps = CEngine::GetInstance()->Components;
        if(!comps.IsComponentPresent(type))
        {
            comps.CreateComponent(type, instantInit);
            if(!comps.IsComponentPresent(type)) { return sol::lua_nil; }
        }

        return comps.GetComponent(type)->GetScriptTable(*this->State); //TODO problem, if not initted table might not be created properly
    });

    components.set_function("ispresent", [this](const std::string& type, sol::this_state ts) -> bool
    {
        return CEngine::GetInstance()->Components.IsComponentPresent(type);
    });

    /*auto angle = State->create_named_table("angle");
    angle.set_function("new", [](sol::variadic_args va) -> sol::table
    {
        float def = 0.0f;
        if(va.size() > 0)
        {
            def = va.get<float>(0); 
        }

        std::shared_ptr<CAngle> angl = std::make_shared<CAngle>();
        angl->setRadians(def);

        sol::table tabl = angl->GetScriptTable(va.lua_state());
        tabl["__obj"] = angl;

        return tabl;
    });*/

    //TODO more types! unify types with cvar.type

    auto angles = State->create_named_table("angles");
    angles.set_function("new", QuatVecNewFunction<CAngles>());

    auto quat = State->create_named_table("quat");
    quat.set_function("new", QuatVecNewFunction<glm::quat>());

    quat.set_function("from_euler", [](sol::object vec) -> sol::table //TODO temp func
    {
        glm::vec3 euler = ScriptUtils::FromObject<glm::vec3>(vec);
        glm::quat ret = glm::quat(euler);

        return ScriptUtils::ToObject<glm::quat>(ret, vec.lua_state());
    });

    quat.set_function("from_euler_degrees", [](sol::object vec) -> sol::table //TODO temp func
    {
        glm::vec3 euler = ScriptUtils::FromObject<glm::vec3>(vec);

        euler.x = glm::radians(euler.x);
        euler.y = glm::radians(euler.y);
        euler.z = glm::radians(euler.z);

        glm::quat ret = glm::quat(euler);

        return ScriptUtils::ToObject<glm::quat>(ret, vec.lua_state());
    });

    auto vec2 = State->create_named_table("vec2");
    vec2.set_function("new", QuatVecNewFunction<glm::vec2>());

    auto vec3 = State->create_named_table("vec3");
    vec3.set_function("new", QuatVecNewFunction<glm::vec3>());

    auto vec4 = State->create_named_table("vec4");
    vec4.set_function("new", QuatVecNewFunction<glm::vec4>());

    auto transform = State->create_named_table("transform");
    transform.set_function("new", [](sol::variadic_args va, sol::this_state ts) -> sol::table
    {
        auto trans = std::make_shared<CTransform>();
        sol::table ret = trans->GetScriptTable(ts);
        
        ret.raw_set("__obj", trans);
        ret.raw_set("__type", std::string("transform"));
        return ret;
    });

    hook.set_function("Set", [this](const std::string& str, sol::object arg1, sol::object arg2)
    {
        if(arg1.valid() && arg1.is<sol::function>())
        {
            AddHook(str, arg1.as<sol::function>());
        }
        else if((arg1.valid() && arg2.valid()) && arg1.is<std::string>() && arg2.is<sol::function>())
        {
            AddHook(str, arg2.as<sol::function>(), arg1.as<std::string>());
        }
    });

    hook.set_function("Call", [this](const std::string& str, sol::variadic_args va)
    {
        COMPONENT_CALL(CScriptingManager, CallHook(str, va));
    });

    hook.set_function("CallSingle", [this](const std::string& str, const std::string& hookName, sol::variadic_args va)
    {
        COMPONENT_CALL(CScriptingManager, CallSingleHook(str, hookName, va));
    });

    hook.set_function("Delete", [this](const std::string& str, sol::object func)
    {
        if(!func.valid()) { return; }

        if(func.is<std::string>())
        {
            DeleteHook(str, func.as<std::string>());
        }
        else if(func.is<sol::function>())
        {
            DeleteHook(str, func.as<sol::function>());
        }
    });

    auto engine_meta = State->create_table();

    engine_meta["__index"] = [this](sol::table table, std::string key, sol::this_state s) -> sol::object
    {
        bool ispr = CEngine::GetInstance()->Components.IsComponentPresent(key);
        if(ispr)
        {
            return CEngine::GetInstance()->Components.GetComponent(key)->GetScriptTable(s);
        }

        return sol::lua_nil;
        //return ComponentsCache.GatedDeleteOrGet(key, ispr);
    };

    /*engine_meta["__pairs"] = [this](sol::table self, sol::this_state s) -> sol::object
    {
        sol::state_view lua(s);
        sol::table merged = lua.create_table();

        for(const auto& [k, v] : CEngine::GetInstance()->Components.Items)
        {
            merged.set(k, ComponentsCache.Get(k));
        }

        return lua["pairs"](merged);
    };

    engine_meta["__len"] = [this](sol::table self, sol::this_state s) -> int
    {
        int len = 0;
        while (true)
        {
            std::string key = std::to_string(len + 1);
            bool exists_in_fields = CEngine::GetInstance()->Components.IsComponentPresent(key);
            bool exists_in_lua = self[static_cast<int>(len + 1)].valid();

            if (exists_in_fields || exists_in_lua)
            {
                ++len;
            }
            else
            {
                break;
            }
        }
        return len;
    };

    engine_meta["__ipairs"] = [this](sol::table self, sol::this_state s) -> std::tuple<sol::function, sol::object, sol::object>
    {
        sol::state_view lua(s);

        auto iter = [this](sol::table tbl, int index) -> std::tuple<sol::object, sol::object>
        {
            int next_index = index + 1;
            std::string key = std::to_string(next_index);

            bool exists = CEngine::GetInstance()->Components.IsComponentPresent(key);
            if (exists)
            {
                sol::object val = ComponentsCache.Get(key);
                return
                {
                    sol::make_object(tbl.lua_state(), next_index),
                    val
                };
            }

            sol::object lua_val = tbl[next_index];
            if (lua_val.valid())
            {
                return
                {
                    sol::make_object(tbl.lua_state(), next_index),
                    lua_val
                };
            }

            return { sol::lua_nil, sol::lua_nil };
        };

        return std::make_tuple(sol::make_object(lua, iter), sol::make_object(lua, self), sol::make_object(lua, 0));
    };*/

    engine[sol::metatable_key] = engine_meta;
    //COMPONENT_CALL(CScriptingManager, PopCurrentEngine());
}

void CScriptingEngine::AddHook(const std::string& hooksGroup, sol::function func, const std::string& hookName)
{
    Hooks.insert({ hooksGroup, { hookName, func } });
}

void CScriptingEngine::DeleteHook(const std::string& hooksGroup, sol::function func)
{
    std::erase_if(Hooks, [&hooksGroup, &func](const auto& kv)
    {
        return kv.first == hooksGroup && kv.second.second == func;
    });
}

void CScriptingEngine::DeleteHook(const std::string& hooksGroup, const std::string& hookName)
{
    std::erase_if(Hooks, [&hooksGroup, &hookName](const auto& kv)
    {
        return kv.first == hooksGroup && kv.second.first == hookName;
    });
}

void CScriptingEngine::ScriptString(const std::wstring& code)
{
    COMPONENT_CALL(CScriptingManager, PushCurrentEngine(this));

    CLuaPreProcessor Processor;
    Processor.ProcessText(code);

    if(!code.empty())
    {
        sol::protected_function_result result = State->safe_script(StringUtils::WstrToStr(Processor.CodeString), sol::script_pass_on_error);

        if (!result.valid())
        {
            sol::error err = result;
            Log::ErrInstance() << "Lua error: " << err.what() << Log::Endl;
        }
    }

    COMPONENT_CALL(CScriptingManager, PopCurrentEngine());
}

void CScriptingEngine::ScriptFile(const std::filesystem::path& path)
{
    std::wifstream file(path);
    if(!file.is_open())
    {
        COMPONENT_CALL(CLogger, Errln(L"Couldn't open file " + StringUtils::StrToWstr(path.string())));
        return;
    }

    std::wstringstream stream;

    stream << std::noskipws << file.rdbuf();
    std::wstring code = stream.str();

    file.close();
    ScriptString(code);
}

void CScriptingEngine::ScriptDirectory(const std::filesystem::path& dir)
{
    if (!std::filesystem::exists(dir) || !std::filesystem::is_directory(dir)) { return; }
    std::vector<std::filesystem::path> lua_files;
    
    for (const auto& entry : std::filesystem::recursive_directory_iterator(dir))
    {
        if (entry.is_regular_file() && entry.path().extension() == ".lua")
        {
            lua_files.push_back(entry.path());
        }
    }

    for(auto& file : lua_files)
    {
        ScriptFile(file);
    }
}

void CScriptingEngine::Init()
{
    RegisterGeneralTypes();
    RegisterOtherTypes();

    V_Init();
    OnInit(this);
}

bool CScriptingEngine::IsTypeRegistered(size_t hash)
{
    return std::find_if(RegisteredTypes.begin(), RegisteredTypes.end(), [hash](const auto& kv) -> bool { return kv.second == hash; }) != RegisteredTypes.end();
}

bool CScriptingEngine::IsTypeRegistered(const std::string& _name)
{
    return RegisteredTypes.find(_name) != RegisteredTypes.end();
}

void CScriptingEngine::RegisterType(const std::string& _name, size_t hash)
{
    if(IsTypeRegistered(_name) || IsTypeRegistered(hash)) { return; }
    RegisteredTypes.emplace(_name, hash);
}

void CScriptingEngine::RegisterGeneralTypes()
{
    ScriptUtils::RegisterType<glm::vec1>(*State);
    ScriptUtils::RegisterType<glm::vec2>(*State);
    ScriptUtils::RegisterType<glm::vec3>(*State);
    ScriptUtils::RegisterType<glm::vec4>(*State);

    ScriptUtils::RegisterType<glm::mat2x2>(*State);
    ScriptUtils::RegisterType<glm::mat2x3>(*State);
    ScriptUtils::RegisterType<glm::mat2x4>(*State);

    ScriptUtils::RegisterType<glm::mat3x2>(*State);
    ScriptUtils::RegisterType<glm::mat3x3>(*State);
    ScriptUtils::RegisterType<glm::mat3x4>(*State);

    ScriptUtils::RegisterType<glm::mat3x2>(*State);
    ScriptUtils::RegisterType<glm::mat3x3>(*State);
    ScriptUtils::RegisterType<glm::mat3x4>(*State);

    ScriptUtils::RegisterType<glm::mat4x2>(*State);
    ScriptUtils::RegisterType<glm::mat4x3>(*State);
    ScriptUtils::RegisterType<glm::mat4x4>(*State);

    //ScriptUtils::RegisterType<glm::mat2>(*State);
    //ScriptUtils::RegisterType<glm::mat3>(*State);
    //ScriptUtils::RegisterType<glm::mat4>(*State);

    ScriptUtils::RegisterType<glm::quat>(*State);
    ScriptUtils::RegisterType<CAngle>(*State);
    ScriptUtils::RegisterType<CAngles>(*State);

    ScriptUtils::RegisterType<SDL_Event>(*State);
}