/*
  *  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 <momemta/Logging.h>
 #include <momemta/ModuleRegistry.h>
 
 namespace momemta {
 
 ModuleRegistryInterface::~ModuleRegistryInterface() {}
 
 ModuleRegistry& ModuleRegistry::get() {
     static ModuleRegistry s_instance;
     return s_instance;
 }
 
 ModuleRegistry::ModuleRegistry() { }
 
 void ModuleRegistry::registerModule(RegisterOp registration_op) {
     std::unique_lock<std::mutex> lock(mutex_);
     if (!initialized_) {
         deferred_.emplace_back(registration_op);
     } else {
         registerModuleWithLock(registration_op);
     }
 }
 
 void ModuleRegistry::deregisterModule(const std::string& module_name) {
     std::unique_lock<std::mutex> lock(mutex_);
     callDeferred();
 
     registry_.erase(module_name);
 }
 
 const ModuleRegistrationData& ModuleRegistry::find(const std::string& module_name) const {
 
     const ModuleRegistrationData* data = nullptr;
 
     {
         std::unique_lock<std::mutex> lock(mutex_);
         callDeferred();
 
         auto it = registry_.find(module_name);
         if (it != registry_.end())
             data = &it->second;
     }
 
     if (! data) {
         throw module_not_found_error("Module '" + module_name + "' is not present in the registry");
     }
 
     return *data;
 }
 
 void ModuleRegistry::exportList(bool ignore_internal, ModuleList& list) const {
     list.clear();
 
     std::unique_lock<std::mutex> lock(mutex_);
     callDeferred();
 
     for (const auto& it: registry_) {
         if (ignore_internal && it.second.module_def.internal)
             continue;
 
         list.emplace_back(it.second.module_def);
     }
 }
 
 void ModuleRegistry::processRegistrations() {
     std::unique_lock<std::mutex> lock(mutex_);
     callDeferred();
 }
 
 void ModuleRegistry::callDeferred() const {
     if (initialized_)
         return;
 
     initialized_ = true;
 
     for (auto& fn: deferred_) {
         registerModuleWithLock(fn);
     }
 
     deferred_.clear();
 }
 
 void ModuleRegistry::registerModuleWithLock(RegisterOp registration_op) const {
     auto registration_data = registration_op();
 
     // Insert module into registry
     auto it = registry_.find(registration_data.module_def.name);
     if (it != registry_.end())
         throw module_already_exists_error("The module '" + registration_data.module_def.name + "' already exists.");
 
     registry_.emplace(registration_data.module_def.name, registration_data);
 }
 
 namespace registration {
 
 
 ModuleDefBuilderReceiver::ModuleDefBuilderReceiver(const ModuleDefBuilder& builder) {
     name_ = builder.name();
     ModuleRegistry::get().registerModule([builder]() -> ModuleRegistrationData {
         return builder.Build();
     });
 }
 
 ModuleDefBuilderReceiver::~ModuleDefBuilderReceiver() {
     ModuleRegistry::get().deregisterModule(name_);
 }
 
 }
 }