#pragma once
 
 #include <memory>
 #include <stdexcept>
 #include <tuple>
 #include <vector>
 
 #include <momemta/any.h>
 #include <lua.hpp>
 
 class ILuaCallback;
 class ParameterSet;
 
 namespace lua {
 
     class invalid_configuration_file: public std::runtime_error {
         using std::runtime_error::runtime_error;
     };
 
     class invalid_array_error: public std::runtime_error {
         using std::runtime_error::runtime_error;
     };
 
     class unsupported_type_error: public std::runtime_error {
         using std::runtime_error::runtime_error;
     };
 
     enum Type {
         NOT_SUPPORTED, 
         BOOLEAN, 
         STRING, 
         INTEGER, 
         REAL, 
         INPUT_TAG, 
         PARAMETER_SET, 
     };
 
     struct Lazy {
         lua_State* L; 
 
         Lazy(lua_State* L);
 
         virtual momemta::any operator() () const = 0;
     };
 
     struct LazyFunction: public Lazy {
         int ref_index; 
 
         virtual momemta::any operator() () const override;
 
         LazyFunction(lua_State* L, int index);
     };
 
     Type type(lua_State* L, int index);
 
     size_t get_index(lua_State* L, int index);
 
     int lua_is_array(lua_State* L, int index);
 
     std::pair<momemta::any, bool> to_any(lua_State* L, int index);
 
     void push_any(lua_State* L, const momemta::any& value);
 
     template<typename T> T special_any_cast(const momemta::any& value) {
         return momemta::any_cast<T>(value);
     }
 
     template<typename T>
     momemta::any to_vectorT(lua_State* L, int index) {
 
         std::vector<T> result;
         size_t absolute_index = get_index(L, index);
 
         if (lua_type(L, absolute_index) != LUA_TTABLE)
             return result;
 
         lua_pushnil(L);
         while (lua_next(L, absolute_index) != 0) {
             momemta::any value;
             bool lazy = false;
             std::tie(value, lazy) = to_any(L, -1);
             result.push_back(special_any_cast<T>(value));
             lua_pop(L, 1);
         }
 
         return momemta::any(result);
     }
 
     momemta::any to_vector(lua_State* L, int index, Type type);
 
     void setup_hooks(lua_State* L, void* ptr);
 
     int module_table_newindex(lua_State* L);
 
     void register_modules(lua_State* L, void* ptr);
 
     int load_modules(lua_State* L);
 
     int parameter(lua_State* L);
 
     std::shared_ptr<lua_State> init_runtime(ILuaCallback* callback);
 
     int generate_cuba_inputtag(lua_State* L);
 
     void inject_parameters(lua_State* L, const ParameterSet& parameters);
 
     namespace debug {
         std::vector<std::string> dump_stack(lua_State* L);
         void print_stack(lua_State* L);
     }
 }