#pragma once
extern "C"{
    #include <lua.h>
    #include <lualib.h>
    #include <lauxlib.h>
}
#include <luabind/luabind.hpp>
#include "alpha/LogManager.h"
#include "alpha/_luaImplementation.h"

///Wrap lua using R.A.I.I.
class Lua_State
{
public:
    Lua_State() : L(luaL_newstate()){
        luabind::open(L);///Connect automatically luabind to all states
    }
    ~Lua_State() { lua_close(L); }
    operator lua_State*() { return L; }///implicite conversion Lua_State ------> lua_state*
private:
    lua_State *L;
};

inline static void LuaOpenLibs(lua_State *L){ ///convenience functions;
        luaopen_io(L);
        luaopen_base(L);
        luaopen_table(L);
        luaopen_string(L);
        luaopen_math(L);
        luaL_openlibs(L);
}


inline static void ReportLuaError(lua_State *L, int status){
    if(status != 0){
        LOG_ERROR_INFO("LuaLoader", "ERROR : LUA ERROR", lua_tostring(L, -1));
        lua_pop(L, 1);
    }
}

inline static int LuaExecuteScript(lua_State *L){
    return lua_pcall(L, 0, LUA_MULTRET, 0);
}


class LuaScript
{
public:
    LuaScript(){ LoadAlphaLuaBinding(m_luaState); }
    ~LuaScript(){}

    bool Load(const char* scriptName);
    bool ExecuteScript();
    Lua_State GetState() { return m_luaState; }

    template<class F>
    void RegisterFunction(const char* name, F f){
        luabind::module(m_luaState)
        [
            luabind::def(name, f)
        ];
}

private:
    Lua_State m_luaState = Lua_State();
    int m_status;
};

#pragma once
#include <iostream>
#include "alpha/Shader.h"
#include "alpha/Window.h"
#include "alpha/Vertex.h"
#include "alpha/Mesh.h"
#include "alpha/Texture.h"
#include "alpha/Material.h"
#include "alpha/Transform.h"
#include "alpha/Camera.h"
#include "alpha/ModelLoader.h"
#include "alpha/InputHandler.h"
#include "alpha/wrapper/SDL_Handle.h"
extern "C"{
    #include <lua.h>
    #include <lualib.h>
    #include <lauxlib.h>
}
#include <luabind/luabind.hpp>

#define DEFINE_LUA_IMPLEMENTAION


inline void LoadAlphaLuaBinding(lua_State *L){
    using namespace luabind;

    module(L)
    [
        class_<Window>("Window")
            .def(constructor<unsigned, unsigned, unsigned, unsigned,
                            const char*, bool, bool>())
            .def("Clear", &Window::Clear)
            .def("SwapBuffers", &Window::SwapBuffers)
            .def("Update", &Window::Update)
            .def("Resized", &Window::Resized)
            .def("GetWidth", &Window::GetWidth)
            .def("GetHeight", &Window::GetHeight)
            .def("SetWidth", &Window::SetWidth)
            .def("SetHeight", &Window::SetHeight)
            .def("HasMoved", &Window::HasMoved)
            .def("SetTitle", &Window::SetTitle)
            .def("SetMousePosition", &Window::SetMousePosition)
            .def("CaptureMouse", &Window::CaptureMouse)
            .def("BlockPosition", &Window::BlockPosition)
            .def("GetXPosition", &Window::GetXPosition)
            .def("GetYPosition", &Window::GetYPosition)
            .def("SetPosition", &Window::SetPosition)
            .def("SetMouseVisible", &Window::SetMouseVisible)

        , ///END

        class_<InputHandler>("InputHandler")
            .def(constructor<>())
            .def("Update", &InputHandler::Update)
            .def("GetMousePosition", &InputHandler::GetMousePosition)
            .def("KeyDown", &InputHandler::KeyDown)
            .def("CloseRequested", &InputHandler::CloseRequested)
        ///And so on for a ~100 lines...

   ];



}

input = InputHandler()
window = Window(100, 100, 1000, 900, "Hello Gangnam Style !", false, false)

while input:CloseRequested() == false do
    window:Clear(0.5, 0.5, 0.5, 1)
    window:SwapBuffers()
end

io.read()