////////////////////////////////////////////////////////////////////////////////
//         Distributed under the Boost Software License, Version 1.0.         //
//            (See accompanying file LICENSE or copy at                       //
//                 https://www.boost.org/LICENSE_1_0.txt)                     //
////////////////////////////////////////////////////////////////////////////////

#include "scripting/lua/lua_script.h"

#include <cstdint>
#include <memory>
#include <sstream>
#include <string>

extern "C"
{
#include "lauxlib.h"
#include "lua.h"
#include "lualib.h"
}

#include "core/auto_release.h"
#include "core/error_handling.h"
#include "core/vector3.h"
#include "scripting/lua/interop/quaternion.h"
#include "scripting/lua/interop/register_class.h"
#include "scripting/lua/interop/vector3.h"

namespace
{

/**
 * Helper function to create a lua state from a script string.
 *
 * @param source
 *   Lua script source.
 *
 * @return
 *   Lua state object.
 */
iris::AutoRelease<lua_State *, nullptr> create_lua_state(const std::string &source)
{
    auto *state = ::luaL_newstate();
    iris::ensure(state != nullptr, "could not create lua state");

    // register standard library and engine custom classes
    ::luaL_openlibs(state);
    iris::interop::lua::register_class(state, iris::interop::lua::vector3_class_interop);
    iris::interop::lua::register_class(state, iris::interop::lua::quaternion_class_interop);

    // try and load the script
    if (::luaL_loadstring(state, source.c_str()) == LUA_OK)
    {
        if (::lua_pcall(state, 0, 0, 0) == LUA_OK)
        {
            ::lua_pop(state, ::lua_gettop(state));
        }
    }
    else
    {
        // if the script failed to load then get the error string from the lua stack and throw it
        const auto error_msg = ::lua_tostring(state, -1);

        std::stringstream strm{};
        strm << "Execution of function failed: " << error_msg;

        throw iris::Exception(strm.str());
    }

    return {state, ::lua_close};
}

}

namespace iris
{

struct LuaScript::implementation
{
    AutoRelease<lua_State *, nullptr> state;
};

LuaScript::LuaScript(const std::string &source)
    : Script()
    , impl_(std::make_unique<implementation>())
{
    impl_->state = create_lua_state(source);
}

LuaScript::LuaScript(ResourceManager &resource_manager, const std::string &file)
    : Script()
    , impl_(std::make_unique<implementation>())
{
    const auto script_data = resource_manager.load(file);
    const std::string source(reinterpret_cast<const char *>(script_data.data()), script_data.size());

    impl_->state = create_lua_state(source);
}

LuaScript::~LuaScript() = default;

void LuaScript::set_argument(bool argument)
{
    ::lua_pushboolean(impl_->state, argument);
}

void LuaScript::set_function(const std::string &function)
{
    ensure(::lua_getglobal(impl_->state, function.c_str()) == LUA_TFUNCTION, "missing function");
}

void LuaScript::set_argument(std::int32_t argument)
{
    ::lua_pushinteger(impl_->state, argument);
}

void LuaScript::set_argument(float argument)
{
    ::lua_pushnumber(impl_->state, argument);
}

void LuaScript::set_argument(const char *argument)
{
    ::lua_pushstring(impl_->state, argument);
}

void LuaScript::set_argument(const std::string &argument)
{
    set_argument(argument.c_str());
}

void LuaScript::set_argument(const Vector3 &argument)
{
    interop::lua::vector3_construct_raw(impl_->state, argument);
}

void LuaScript::set_argument(const Quaternion &argument)
{
    interop::lua::quaternion_construct_raw(impl_->state, argument);
}

void LuaScript::execute(std::uint32_t num_args, std::uint32_t num_results)
{
    if (::lua_pcall(impl_->state, num_args, num_results, 0) != LUA_OK)
    {
        std::string error_msg;
        get_result(error_msg);

        std::stringstream strm{};
        strm << "Execution of function failed: " << error_msg;

        throw Exception(strm.str());
    }
}

void LuaScript::get_result(bool &result)
{
    ensure(lua_isboolean(impl_->state, -1) == 1, "incorrect result type");

    result = ::lua_toboolean(impl_->state, -1);
    ::lua_pop(impl_->state, 1);
}

void LuaScript::get_result(std::int32_t &result)
{
    ensure(lua_isinteger(impl_->state, -1) == 1, "incorrect result type");

    result = static_cast<std::int32_t>(::lua_tointeger(impl_->state, -1));
    ::lua_pop(impl_->state, 1);
}

void LuaScript::get_result(float &result)
{
    ensure(lua_isnumber(impl_->state, -1) == 1, "incorrect result type");

    result = static_cast<float>(::lua_tonumber(impl_->state, -1));
    ::lua_pop(impl_->state, 1);
}

void LuaScript::get_result(std::string &result)
{
    ensure(lua_isstring(impl_->state, -1) == 1, "incorrect result type");

    result = ::lua_tostring(impl_->state, -1);
    ::lua_pop(impl_->state, 1);
}

void LuaScript::get_result(Vector3 &result)
{
    auto **vector = interop::lua::get_vector3(impl_->state);
    result = **vector;

    ::lua_pop(impl_->state, 1);
}

void LuaScript::get_result(Quaternion &result)
{
    auto **q = interop::lua::get_quaternion(impl_->state);
    result = **q;

    ::lua_pop(impl_->state, 1);
}

}