#ifndef _plugin_H_
#define _plugin_H_

#include <memory>
#include <string>
#include <map>
#include <functional>
#include <iostream>
#include <random>
#include <dlfcn.h>
#include <dirent.h>
#include <libscerror.hpp>

namespace sc {

	template <typename T>
	class plugin {
		public:
			static void scan_plugins(const std::string& dir, const std::string& ext) {
				DIR* plugins_dir = opendir(dir.c_str());
				throw_if_null_msg(plugins_dir, (dir + " could not be opened").c_str());
				struct dirent* info;
				while ((info = readdir(plugins_dir)) != nullptr) {
					if (info->d_name[0] != '.') {
						std::string plugname {info->d_name};
						std::string::size_type lastdot = plugname.rfind(".");
						if (plugname.substr(lastdot + 1) == ext) {
							plugin plugin {dir + '/' + plugname};
							plugin.name(plugname.substr(0, lastdot));
							plugins.emplace(plugin.name(), std::move(plugin));
						}
					}
				}
				throw_if_min1(closedir(plugins_dir));
			}

			using processor = std::function<void(const plugin&)>;
			static void foreach(processor proc) {
				for (const auto& elem : plugins) {
					proc(elem.second);
				}
			}

			static plugin& get(const std::string& name) {
				return plugins.at(name);
			}

			static std::vector<std::string> names() {
				std::vector<std::string> result;
				for (const auto& elem : plugins) {
					result.emplace_back(elem.first);
				}
				return result;
			}

			static size_t count() { return plugins.size(); }

			static const std::map<std::string, plugin<T>>& all() { return plugins; }

			plugin(const std::string& path) : _path {path} {
				_plugin = dlopen(path.c_str(), RTLD_LAZY);

				const char* err {dlerror()};
				if (err) std::cerr << err << '\n';
				if (_plugin) {
					_factory = reinterpret_cast<factory>(dlsym(_plugin, "create_instance"));
					if (!_factory) {
						std::cerr << "create_instance() function not found in " << path << '\n';
					}
				}
			}

			~plugin() {
				if (_plugin) {
					dlclose(_plugin);
					_plugin = nullptr;
				}
			}

			plugin(const plugin&) = delete;
			plugin& operator=(const plugin&) = delete;

			plugin(plugin&& other) {
				_path = other._path;
				_plugin = other._plugin;
				_factory = other._factory;
				other._plugin = nullptr;
			}

			plugin& operator=(plugin&& other) {
				if (this != &other) {
					_path = other._path;
					_plugin = other._plugin;
					_factory = other._factory;
					other._plugin = nullptr;
				}
				return *this;
			}

			const std::string& path() const { return _path; }

			const std::string& name() const { return _name; }
			void name(const std::string& nm) { _name = nm; }

			std::unique_ptr<T> operator()() const {
				std::unique_ptr<T> obj;
				if (_factory) {
					obj.reset(_factory());
				}
				return obj;
			}

		private:
			static std::map<std::string, plugin<T>> plugins;

			std::string _path;
			std::string _name;
			void* _plugin {nullptr};
			using factory = T*(*)();
			factory _factory {nullptr};
	};

	template <typename T>
	std::map<std::string, plugin<T>> plugin<T>::plugins;
}

#endif // _plugin_H_