/*
  *  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/>.
  */
 
 
 #pragma once
 
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include <momemta/Logging.h>
 
 // Plugin system
 template<typename T> class PluginFactory;
 
 template<typename Interface, typename... Args>
 class PluginFactory<Interface* (Args...)> {
     public:
         using type = Interface* (Args...);
         using Factory = PluginFactory<Interface*(Args...)>;
 
         struct PMakerBase {
             virtual std::shared_ptr<Interface> create(Args...) const = 0;
             virtual ~PMakerBase() {}
         };
 
         template<class PluginType>
             struct PMaker: public PMakerBase {
                 PMaker(const std::string& name) {
                     Factory::get().registerPMaker(this, name);
                 }
 
                 virtual std::shared_ptr<Interface> create(Args... args) const override {
                     return std::shared_ptr<PluginType>(new PluginType(std::forward<Args>(args)...));
                 }
             };
 
         std::shared_ptr<Interface> create(const std::string& name, Args... args) const {
             return find(name)->create(std::forward<Args>(args)...);
         }
 
         static PluginFactory<Interface* (Args...)>& get();
 
         void registerPMaker(PMakerBase* pMaker, const std::string& name) {
             auto it = m_plugins.find(name);
             if (it != m_plugins.end())
                 throw plugin_already_exists_error("The plugin type '" + name + "' is already registered in the factory.");
 
             m_plugins.emplace(name, pMaker);
         }
 
         PMakerBase* find(const std::string& name) const {
             auto it = m_plugins.find(name);
             if (it == m_plugins.end()) {
                 LOG(fatal) << "No such plugin type '" << name << "' registered in the factory (" << m_plugins.size() <<" plugins).";
                 throw plugin_not_found_error("No such plugin type '" + name + "' registered in the factory.");
             }
 
             return it->second;
         }
 
         std::vector<std::string> getPluginsList() const {
             std::vector<std::string> result;
             for (const auto& plugin: m_plugins) {
                 result.push_back(plugin.first);
             }
 
             return result;
         }
 
     private:
         class plugin_already_exists_error: public std::runtime_error {
             using std::runtime_error::runtime_error;
         };
 
         class plugin_not_found_error: public std::runtime_error {
             using std::runtime_error::runtime_error;
         };
 
         PluginFactory() = default;
 
         PluginFactory(const PluginFactory&) = delete; // stop default
         const PluginFactory& operator=(const PluginFactory&) = delete; // stop default
 
         std::unordered_map<std::string, PMakerBase*> m_plugins;
 };
 
 #define PLUGIN_UNIQUE_NAME2(x, y) x ## y
 #define PLUGIN_UNIQUE_NAME(x, y) PLUGIN_UNIQUE_NAME2(x, y)