/*
  *  MoMEMta: a modular implementation of the Matrix Element Method
  *  Copyright (C) 2016  Universite catholique de Louvain (UCL), Belgium
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <lua/bindings/Path.h>
 
 #include <momemta/ILuaCallback.h>
 
 #include <lua/bindings/Types.h>
 #include <ExecutionPath.h>
 
 #include <lua.hpp>
 
 void lua::path_register(lua_State* L, void* ptr) {
 
     // Register metatable for type Path
     push_type_metatable(L, LUA_PATH_TYPE_NAME);
 
     // Register destructor
     static const luaL_Reg functions[] = {
         {"__gc", path_free},
         {nullptr, nullptr}
     };
     luaL_setfuncs(L, functions, 0);
 
     lua_pop(L, 1);
 
     // Register global `Path` function, acting as a constructor for `ExecutionPath` struct
     lua_pushlightuserdata(L, ptr);
     lua_pushcclosure(L, path_new, 1);
     lua_setglobal(L, LUA_PATH_TYPE_NAME);
 }
 
 int lua::path_new(lua_State* L) {
 
     int n = lua_gettop(L);
     if (n == 0) {
         luaL_error(L, "invalid number of arguments: at least 1 expected, got 0");
     }
 
     std::vector<std::string> module_names;
     for (size_t i = 1; i <= (size_t) n; i++) {
         std::string module_name = luaL_checkstring(L, i);
         module_names.push_back(module_name);
     }
 
     ExecutionPath** pPath = static_cast<ExecutionPath**>(lua_newuserdata(L, sizeof(ExecutionPath)));
     *pPath = new ExecutionPath();
 
     luaL_getmetatable(L, LUA_PATH_TYPE_NAME);
     lua_setmetatable(L, -2);
 
     (*pPath)->elements = module_names;
 
 
     void* cfg_ptr = lua_touserdata(L, lua_upvalueindex(1));
     ILuaCallback* callback = static_cast<ILuaCallback*>(cfg_ptr);
     callback->onNewPath(**pPath);
 
     return 1;
 }
 
 int lua::path_free(lua_State* L) {
     delete *static_cast<ExecutionPath**>(luaL_checkudata(L, 1, LUA_PATH_TYPE_NAME));
 
     return 0;
 }
 
 ExecutionPath* lua::path_get(lua_State* L, int index) {
     luaL_checktype(L, index, LUA_TUSERDATA);
     ExecutionPath** path = static_cast<ExecutionPath**>(luaL_checkudata(L, index, LUA_PATH_TYPE_NAME));
     if (!path) {
         const char *msg = lua_pushfstring(L, "%s expected, got %s",
                 LUA_PATH_TYPE_NAME, luaL_typename(L, index));
         luaL_argerror(L, index, msg);
     }
 
     return *path;
 }