/*
  *  MoMEMta: a modular implementation of the Matrix Element Method
  *  Copyright (C) 2017  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 <ModuleUtils.h>
 
 #include <momemta/Logging.h>
 
 #include <ModuleDefUtils.h>
 
 namespace {
 
 template<typename T>
 T* findPSet(const momemta::ArgDef& input_def, T& parameters) {
     typedef typename std::remove_cv<T>::type type;
 
     T* pset = &parameters;
     std::vector<momemta::AttrDef> nested_attributes = input_def.nested_attributes;
     while (!nested_attributes.empty()) {
         momemta::AttrDef nested_attribute = nested_attributes.front();
         nested_attributes.erase(nested_attributes.begin());
 
         if (pset->template existsAs<type>(nested_attribute.name))
             pset = &pset->template get<type>(nested_attribute.name);
         else {
             pset = nullptr;
             break;
         }
     }
 
     return pset;
 }
 }
 
 bool momemta::validateModuleParameters(const ModuleList::value_type& module_def, const ParameterSet& parameters) {
 
     std::vector<std::string> errors;
     std::vector<std::string> warnings;
 
     // Check that all attributes are defined
     // TODO: We can imagine here validating also the type of the attribute
     for (const auto& attr_def: module_def.attributes) {
 
         // Ignore global or optional attributes
         if (attr_def.global || attr_def.optional)
             continue;
 
         if (! parameters.exists(attr_def.name))
             errors.emplace_back("Attribute not found: " + attr_def.name);
     }
 
     // Check that all inputs are defined
     for (const auto& input_def: module_def.inputs) {
         // Ignore optional inputs
         if (input_def.optional)
             continue;
 
         const ParameterSet* pset = &parameters;
         std::vector<AttrDef> nested_attributes = input_def.nested_attributes;
         while (!nested_attributes.empty()) {
             AttrDef nested_attribute = nested_attributes.front();
             nested_attributes.erase(nested_attributes.begin());
 
             if (pset->existsAs<ParameterSet>(nested_attribute.name))
                 pset = &pset->get<ParameterSet>(nested_attribute.name);
             else {
                 LOG(error) << "Attribute " << nested_attribute.name << " not found in PSet "
                            << pset->getModuleType() << "::" << pset->getModuleName();
                 pset = nullptr;
                 break;
             }
         }
 
         if (!pset || !pset->exists(input_def.name))
             errors.emplace_back("Input not found: " + input_def.name);
     }
 
     // Check for parameters not found in the module definition
     const auto& parameter_names = parameters.getNames();
     for (const auto& name: parameter_names) {
 
         // Ignore internal parameters
         if (name.length() > 0 && name[0] == '@')
             continue;
 
         if (! momemta::inputOrAttrExists(name, module_def))
             warnings.emplace_back("Unexpected parameter: " + name);
     }
 
     if (! warnings.empty()) {
         // Warnings found during validation
         LOG(warning) << "Warnings found during validation of parameters for module "
                      << parameters.getModuleType() << "::" << parameters.getModuleName();
         for (const auto& warning: warnings)
             LOG(warning) << "    " << warning;
         LOG(warning) << "These parameters will never be used by the module, check your configuration file.";
     }
 
     if (!errors.empty()) {
         // Validation failed. Print errors.
         LOG(error) << "Validation of parameters for module " << parameters.getModuleType() << "::"
                    << parameters.getModuleName() << " failed: ";
         for (const auto& error: errors)
             LOG(error) << "    " << error;
 
         LOG(error) << "Check your configuration file.";
     }
 
     return errors.empty();
 }
 
 momemta::gtl::optional<std::vector<InputTag>> momemta::getInputTagsForInput(const ArgDef& input,
                                                                             const ParameterSet& parameters) {
 
     const ParameterSet* pset = findPSet(input, parameters);
     assert(pset || input.optional);
 
     if (! pset)
         return gtl::nullopt;
 
     if (input.optional && !pset->exists(input.name))
         return gtl::nullopt;
 
     if (input.many) {
         return pset->get<std::vector<InputTag>>(input.name);
     } else {
         return gtl::make_optional<std::vector<InputTag>>({pset->get<InputTag>(input.name)});
     }
 }
 
 void momemta::setInputTagsForInput(const ArgDef& input,
                                    ParameterSet& parameters,
                                    const std::vector<InputTag>& inputTags) {
 
     ParameterSet* pset = findPSet(input, parameters);
     assert(pset);
 
     if (input.many) {
         pset->raw_set(input.name, inputTags);
     } else {
         assert(inputTags.size() == 1);
         pset->raw_set(input.name, inputTags.front());
     }
 }