/*
  *  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.hpp>
 
 #include <momemta/any.h>
 #include <momemta/Logging.h>
 #include <momemta/ConfigurationReader.h>
 #include <momemta/ModuleFactory.h>
 #include <momemta/ParameterSet.h>
 
 #include <ExecutionPath.h>
 #include <lua/LazyTable.h>
 #include <lua/ParameterSetParser.h>
 #include <lua/utils.h>
 #include <strings/StringPiece.h>
 
 ConfigurationReader::ConfigurationReader(const std::string& file) :
         ConfigurationReader(file, ParameterSet()) {
     // Empty
 }
 
 ConfigurationReader::ConfigurationReader(const std::string& from, const ParameterSet& parameters) {
 
     lua_state = lua::init_runtime(this);
 
     lua::inject_parameters(lua_state.get(), parameters);
 
     momemta::StringPiece from_view = from;
     bool from_string = from_view.Consume("!");
 
     if (from_string) {
         LOG(debug) << "Parsing LUA configuration from string";
 
         // Parse string
         if (luaL_dostring(lua_state.get(), from_view.data())) {
             std::string error = lua_tostring(lua_state.get(), -1);
             LOG(fatal) << "Failed to parse configuration string: " << error;
             throw lua::invalid_configuration_file(error);
         }
 
     } else {
         LOG(debug) << "Parsing LUA configuration from " << from;
 
         // Parse file
         if (luaL_dofile(lua_state.get(), from.c_str())) {
             std::string error = lua_tostring(lua_state.get(), -1);
             LOG(fatal) << "Failed to parse configuration file: " << error;
             throw lua::invalid_configuration_file(error);
         }
     }
 
     // FIXME: Find a better way of doing that
 
     // Read global parameters from global variable named 'parameters'
     configuration.global_parameters.reset(new lua::LazyTable(lua_state, "parameters"));
     int type = lua_getglobal(lua_state.get(), "parameters");
     if (type == LUA_TTABLE) {
         LOG(debug) << "Parsing global parameters.";
         ParameterSetParser::parse(*configuration.global_parameters, lua_state.get(), -1);
     }
     lua_pop(lua_state.get(), 1);
 
     // Read cuba configuration
     configuration.cuba_configuration.reset(new lua::LazyTable(lua_state, "cuba"));
     type = lua_getglobal(lua_state.get(), "cuba");
     if (type == LUA_TTABLE) {
         LOG(debug) << "Parsing cuba configuration.";
         ParameterSetParser::parse(*configuration.cuba_configuration, lua_state.get(), -1);
     }
     lua_pop(lua_state.get(), 1);
 
     for (auto& m: configuration.modules) {
         LOG(debug) << "Module declared: " << m.type << "::" << m.name;
 
         lua_getglobal(lua_state.get(), m.type.c_str());
         lua_getfield(lua_state.get(), -1, m.name.c_str());
 
         m.parameters.reset(new ParameterSet());
         ParameterSetParser::parse(*m.parameters, lua_state.get(), -1);
 
         lua_pop(lua_state.get(), 2);
     }
 }
 
 void ConfigurationReader::onModuleDeclared(const std::string& type, const std::string& name) {
     Configuration::ModuleDecl module;
     module.name = name;
     module.type = type;
 
     configuration.modules.push_back(module);
 }
 
 void ConfigurationReader::onIntegrandDeclared(const InputTag& tag) {
     configuration.integrands.push_back(tag);
 }
 
 void ConfigurationReader::onNewPath(const ExecutionPath& path) {
     configuration.paths.push_back(std::make_shared<ExecutionPath>(path));
 }
 
 void ConfigurationReader::addIntegrationDimension() {
     configuration.n_dimensions++;
 }
 
 void ConfigurationReader::onNewInputDeclared(const std::string& name) {
     configuration.inputs.push_back(name);
 }
 
 ParameterSet& ConfigurationReader::getGlobalParameters() {
     return *configuration.global_parameters;
 }
 
 ParameterSet& ConfigurationReader::getCubaConfiguration() {
     return *configuration.cuba_configuration;
 }
 
 Configuration ConfigurationReader::freeze() const {
     return configuration.freeze();
 }