// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.


#include "stdnet.h"
#include "nel/misc/app_context.h"
#include "nel/misc/dynloadlib.h"
#include "nel/misc/command.h"
#include "nel/misc/path.h"
#include "nel/misc/twin_map.h"
#include "nel/misc/sstring.h"
#include "nel/misc/smart_ptr_inline.h"

#include "nel/net/module_common.h"
#include "nel/net/module_manager.h"
#include "nel/net/service.h"
#include "nel/net/module_gateway.h"
#include "nel/net/module.h"
#include "nel/net/module_socket.h"
#include "nel/net/net_log.h"


using namespace std;
using namespace NLMISC;

// for init of the module manager (if not already done by the application)
NLMISC_CATEGORISED_COMMAND(net, initModuleManager, "force the initialisation of the module manager", "")
{
	nlunreferenced(rawCommandString);
	nlunreferenced(args);
	nlunreferenced(quiet);
	nlunreferenced(human);

	// not really hard in fact :)
	NLNET::IModuleManager::getInstance();

	log.displayNL("Module manager is now initialised.");

	return true;
}


namespace NLNET
{
	/// Implementation class for module manager
	class CModuleManager : public IModuleManager, public ICommandsHandler
	{
		NLMISC_SAFE_SINGLETON_DECL(CModuleManager);

	public:

		static void releaseInstance()
		{
			if (_Instance)
			{
				NLMISC::INelContext::getInstance().releaseSingletonPointer("CModuleManager", _Instance);
				delete _Instance;
				_Instance = NULL;
			}
		}

		struct TModuleLibraryInfo : public CRefCount
		{
			/// The file name of the library with access path
			std::string					FullPathLibraryName;
			/// The short name of the library, i.e not path, no decoration (.dll or  .so and NeL compilation mode tag)
			std::string					ShortLibraryName;
			/// The list of module factory name that are in use in the library.
			std::vector<std::string>	ModuleFactoryList;
			/// The library handler
			CLibrary					LibraryHandler;
			/// the NeL Module library interface pointer.
			CNelModuleLibrary			*ModuleLibrary;
		};

		/** the user set unique name root, replace the normal unique name
		 *	generation system if not empty
		 */
		string _UniqueNameRoot;

		typedef	map<std::string, CSmartPtr<TModuleLibraryInfo> >	TModuleLibraryInfos;
		/// Module library registry
		TModuleLibraryInfos		_ModuleLibraryRegistry;

		typedef std::map<std::string, IModuleFactory*>		TModuleFactoryRegistry;
		/// Module factory registry
		TModuleFactoryRegistry	_ModuleFactoryRegistry;

		typedef NLMISC::CTwinMap<std::string, TModulePtr>	TModuleInstances;
		/// Modules instances tracker
		TModuleInstances		_ModuleInstances;

		typedef NLMISC::CTwinMap<TModuleId, TModulePtr>		TModuleIds;
		/// Modules IDs tracker
		TModuleIds				_ModuleIds;

		/// Local module ID generator
		TModuleId				_LastGeneratedId;

		typedef NLMISC::CTwinMap<TModuleId, TModuleProxyPtr>	TModuleProxyIds;
		/// Modules proxy IDs tracker
		TModuleProxyIds			_ModuleProxyIds;

		typedef map<string, IModuleSocket *>	TModuleSockets;
		/// Module socket registry
		TModuleSockets			_ModuleSocketsRegistry;

		typedef std::map<std::string, IModuleGateway*>		TModuleGateways;
		/// Module factory registry
		TModuleGateways			_ModuleGatewaysRegistry;

		///////////////////////////////////////////////////////////////////
		// Methods
		///////////////////////////////////////////////////////////////////

		static bool		isInitialized()
		{
			return _Instance != NULL;
		}

		const std::string &getCommandHandlerName() const
		{
			static string moduleManagerName("moduleManager");
			return moduleManagerName;
		}


		CModuleManager() :
			IModuleManager(),
			ICommandsHandler(),
			_LastGeneratedId(0)
		{
			registerCommandsHandler();

			// register local module factory
			TLocalModuleFactoryRegistry &lmfr = TLocalModuleFactoryRegistry::instance();
			addModuleFactoryRegistry(lmfr);
		}

		~CModuleManager()
		{
			// unload any loaded module library
			while (!_ModuleLibraryRegistry.empty())
			{
				TModuleLibraryInfo *mli = _ModuleLibraryRegistry.begin()->second;
				unloadModuleLibrary(mli->ShortLibraryName);
			}

			// delete any lasting modules
			while (!_ModuleInstances.getAToBMap().empty())
			{
				deleteModule(_ModuleInstances.getAToBMap().begin()->second);
			}

			// there should not be proxies or gateway lasting
//			nlassert(_ModuleProxyInstances.getAToBMap().empty());

			_Instance = NULL;
		}

		virtual void applicationExit()
		{
			TModuleInstances::TAToBMap::const_iterator first(_ModuleInstances.getAToBMap().begin()), last(_ModuleInstances.getAToBMap().end());
			for (; first != last; ++first)
			{
				IModule *module = first->second;

				module->onApplicationExit();
			}
		}

		virtual void setUniqueNameRoot(const std::string &uniqueNameRoot)
		{
			_UniqueNameRoot = uniqueNameRoot;
		}

		virtual const std::string &getUniqueNameRoot()
		{
			if (_UniqueNameRoot.empty())
			{
				string hostName;
				if (IService::isServiceInitialized())
					hostName = IService::getInstance()->getHostName();
				else
					hostName = ::NLNET::CInetAddress::localHost().hostName();
				int pid = ::getpid();

				_UniqueNameRoot = hostName+":"+toString(pid);
			}

			return _UniqueNameRoot;
		}


		void addModuleFactoryRegistry(TLocalModuleFactoryRegistry &moduleFactoryRegistry)
		{
			vector<string> moduleList;
			moduleFactoryRegistry.fillFactoryList(moduleList);
			// fill the module factory registry
			vector<string>::iterator first(moduleList.begin()), last(moduleList.end());
			for (; first != last; ++first)
			{
				const std::string &className = *first;
				IModuleFactory *factory = moduleFactoryRegistry.getFactory(className);
				if (_ModuleFactoryRegistry.find(*first) != _ModuleFactoryRegistry.end())
				{
					// a module class of that name already exist
					nlinfo("CModuleManger : add module factory : module class '%s' is already registered; ignoring new factory @%p",
						className.c_str(),
						factory);
				}
				else
				{
					// store the factory
					nlinfo("Adding module '%s' factory", className.c_str());
					_ModuleFactoryRegistry.insert(make_pair(className, factory));
				}
			}
		}

		virtual bool loadModuleLibrary(const std::string &libraryName)
		{
			// build the short name
			string path = CFile::getPath(libraryName);
			string shortName = CLibrary::cleanLibName(libraryName);

			if (_ModuleLibraryRegistry.find(shortName) != _ModuleLibraryRegistry.end())
			{
				// this lib is already loaded !
				nlwarning("CModuleManager : trying to load library '%s' in '%s'\n"
					"but it is already loaded as '%s', ignoring.",
					shortName.c_str(),
					libraryName.c_str(),
					_ModuleLibraryRegistry[shortName]->FullPathLibraryName.c_str());
				return false;
			}

			// now, load the library
			string fullName = NLMISC::CPath::standardizePath(path)+CLibrary::makeLibName(shortName);
			std::auto_ptr<TModuleLibraryInfo>	mli = auto_ptr<TModuleLibraryInfo>(new TModuleLibraryInfo);
			if (!mli->LibraryHandler.loadLibrary(fullName, false, true, true))
			{
				nlwarning("CModuleManager : failed to load the library '%s' in '%s'",
					shortName.c_str(),
					fullName.c_str());
				return false;
			}
			// the lib is loaded, check that it is a 'pure' nel library
			if (!mli->LibraryHandler.isLibraryPure())
			{
				nlwarning("CModuleManager : the library '%s' is not a pure Nel library",
					shortName.c_str());
				return false;
			}
			// Check that the lib is a pure module library
			CNelModuleLibrary *modLib = dynamic_cast<CNelModuleLibrary *>(mli->LibraryHandler.getNelLibraryInterface());
			if (modLib == NULL)
			{
				nlwarning("CModuleManager : the library '%s' is not a pure Nel Module library",
					shortName.c_str());
				return false;
			}

			// ok, all is fine ! we can store the loaded library info

			mli->FullPathLibraryName = fullName;
			TLocalModuleFactoryRegistry &lmfr = modLib->getLocalModuleFactoryRegistry();
			lmfr.fillFactoryList(mli->ModuleFactoryList);
			mli->ModuleLibrary = modLib;
			mli->ShortLibraryName = shortName;

			pair<TModuleLibraryInfos::iterator, bool> ret = _ModuleLibraryRegistry.insert(make_pair(shortName, mli.release()));
			if (!ret.second)
			{
				nlwarning("CModuleManager : failed to store module library information !");
				return false;
			}

			// fill the module factory registry
			addModuleFactoryRegistry(lmfr);

			return true;
		}

		virtual bool unloadModuleLibrary(const std::string &libraryName)
		{
			string shorName = CLibrary::cleanLibName(libraryName);
			TModuleLibraryInfos::iterator it(_ModuleLibraryRegistry.find(shorName));
			if (it == _ModuleLibraryRegistry.end())
			{
				nlwarning("CModuleManager : failed to unload library '%s' : unknown or not loaded library", shorName.c_str());
				return false;
			}

			// by erasing this entry, we delete the CLibrary object that hold the library
			// module, thus destroying any factory the belong into and deleting the
			// instantiated module !
			// Wow, that's pretty much for a single line ;)
			_ModuleLibraryRegistry.erase(it);

			return true;
		}

		/** Register a module factory in the manager
		 */
//		virtual void registerModuleFactory(class IModuleFactory *moduleFactory)
//		{
//			nlstop;
//		}
		/** Unregister a module factory
		*/
		virtual void unregisterModuleFactory(class IModuleFactory *moduleFactory)
		{
			// we need to remove the factory from the registry
			TModuleFactoryRegistry::iterator it(_ModuleFactoryRegistry.find(moduleFactory->getModuleClassName()));

			if (it == _ModuleFactoryRegistry.end())
			{
				nlwarning("The module factory for class '%s' in not registered.", moduleFactory->getModuleClassName().c_str());
				return;
			}
			else if (it->second != moduleFactory)
			{
				nlinfo("The module factory @%p for class '%s' is not the registered one, ignoring.",
					moduleFactory,
					moduleFactory->getModuleClassName().c_str());
				return;
			}

			nlinfo("ModuleManager : unregistering factory for module class '%s'", moduleFactory->getModuleClassName().c_str());

			// remove the factory
			_ModuleFactoryRegistry.erase(it);
		}


		/** Fill the vector with the list of available module.
		 *	Note that the vector is not cleared before being filled.
		 */
		virtual void getAvailableModuleClassList(std::vector<std::string> &moduleClassList)
		{
			TModuleFactoryRegistry::iterator first(_ModuleFactoryRegistry.begin()), last(_ModuleFactoryRegistry.end());
			for (; first != last; ++first)
			{
				moduleClassList.push_back(first->first);
			}
		}

		/** Create a new module instance.
		 *	The method create a module of the specified class with the
		 *	specified local name.
		 *	The class MUST be available in the factory and the
		 *	name MUST be unique OR empty.
		 *	If the name is empty, the method generate a name using
		 *	the module class and a number.
		 */
		virtual IModule *createModule(const std::string &className, const std::string &localName, const std::string &paramString)
		{
			TModuleFactoryRegistry::iterator it(_ModuleFactoryRegistry.find(className));
			if (it == _ModuleFactoryRegistry.end())
			{
				nlwarning("createModule : unknown module class '%s'", className.c_str());
				return NULL;
			}

			string moduleName = localName;
			if (moduleName.empty())
			{
				// we need to generate a name
				uint i=0;
				do
				{
					moduleName = className+toString(i++);
				} while (_ModuleInstances.getB(moduleName) != NULL);
			}
			else
			{
				// check that the module name is unique
				if (_ModuleInstances.getB(moduleName) != NULL)
				{
					nlwarning("createModule : the name '%s' is already used by another module, can't instantiate the module", moduleName.c_str());
					return NULL;
				}
			}

			IModuleFactory *mf = it->second;
			// sanity check
			nlassert(mf->getModuleClassName() == className);
			std::auto_ptr<IModule> module = auto_ptr<IModule>(mf->createModule());
			if (module.get() == NULL)
			{
				nlwarning("createModule : factory failed to create a module instance for class '%s'", className.c_str());

				return NULL;
			}

			CModuleBase *modBase = dynamic_cast<CModuleBase*>(module.get());
			if (modBase == NULL)
			{
				nlwarning("Invalid module returned by factory for class '%s'", className.c_str());
				return NULL;
			}

			// init the module basic data
			modBase->_ModuleName = moduleName;
			modBase->_ModuleId = ++_LastGeneratedId;

			// init the module with parameter string
			TParsedCommandLine	mii;
			mii.parseParamList(paramString);
			bool initResult = module->initModule(mii);

			// store the module in the manager
			_ModuleInstances.add(moduleName, module.get());
			_ModuleIds.add(modBase->_ModuleId, module.get());

			if (initResult)
			{
				// ok, all is fine, return the module
				return module.release();
			}
			else
			{
				// error during initialization, delete the module
				nlwarning("Create module : the new module '%s' of class '%s' has failed to initilize properly.",\
					moduleName.c_str(),
					className.c_str());

				deleteModule(module.release());
				return NULL;
			}
		}

		void deleteModule(IModule *module)
		{
			nlassert(module != NULL);

			// remove module from trackers
			nlassert(_ModuleInstances.getA(module) != NULL);
			nlassert(_ModuleIds.getA(module) != NULL);

			_ModuleInstances.removeWithB(module);
			_ModuleIds.removeWithB(module);

			// unplug the module if needed
			vector<IModuleSocket *> sockets;
			module->getPluggedSocketList(sockets);
			for (uint i=0; i<sockets.size(); ++i)
			{
				module->unplugModule(sockets[i]);
			}

			// ask the factory to delete the module
			CModuleBase *modBase = dynamic_cast<CModuleBase *>(module);
			nlassert(modBase != NULL);
			modBase->getFactory()->deleteModule(module);
		}

		/** Lookup in the created module for a module having the
		 *	specified local name.
		 */
		virtual IModule *getLocalModule(const std::string &moduleName)
		{
			TModuleInstances::TAToBMap::const_iterator it(_ModuleInstances.getAToBMap().find(moduleName));

			if (it == _ModuleInstances.getAToBMap().end())
				return NULL;
			else
				return it->second;
		}

		virtual void updateModules()
		{
			H_AUTO(CModuleManager_updateModules);
			// module are updated in creation order (i.e in module ID order)
			TModuleIds::TAToBMap::const_iterator first(_ModuleIds.getAToBMap().begin()), last(_ModuleIds.getAToBMap().end());
			for (; first != last; ++first)
			{
				TModulePtr module = first->second;

				CModuleBase *modBase = dynamic_cast<CModuleBase *>(module.getPtr());
				if (modBase != NULL)
				{
					// look for module task to run
					while (!modBase->_ModuleTasks.empty())
					{
						CModuleTask *task = modBase->_ModuleTasks.front();
						task->resume();
						// check for finished task
						if (task->isFinished())
						{
							LNETL6_DEBUG("NLNETL6: updateModule : task %p is finished, delete and remove from task list", task);
							// delete the task and resume the next one if any
							delete task;
							modBase->_ModuleTasks.erase(modBase->_ModuleTasks.begin());
						}
						else
						{
							// no more work for this update
							break;
						}
					}
				}

				{
					H_AUTO(CModuleManager_updateModules_2);
					// update the module internal
					first->second->onModuleUpdate();
				}
			}
		}

		/** Lookup in the created socket for a socket having the
		 *	specified local name.
		 */
		virtual IModuleSocket *getModuleSocket(const std::string &socketName)
		{
			TModuleSockets::iterator it(_ModuleSocketsRegistry.find(socketName));
			if (it == _ModuleSocketsRegistry.end())
				return NULL;
			else
				return it->second;
		}
		/** Register a socket in the manager.
		 */
		virtual void registerModuleSocket(IModuleSocket *moduleSocket)
		{
			nlassert(moduleSocket != NULL);
			TModuleSockets::iterator it(_ModuleSocketsRegistry.find(moduleSocket->getSocketName()));
			nlassert(it == _ModuleSocketsRegistry.end());

			nldebug("Registering module socket '%s'", moduleSocket->getSocketName().c_str());
			_ModuleSocketsRegistry.insert(make_pair(moduleSocket->getSocketName(), moduleSocket));
		}
		/** Unregister a socket in the manager.
		 */
		virtual void unregisterModuleSocket(IModuleSocket *moduleSocket)
		{
			nlassert(moduleSocket != NULL);
			TModuleSockets::iterator it(_ModuleSocketsRegistry.find(moduleSocket->getSocketName()));
			nlassert(it != _ModuleSocketsRegistry.end());

			nldebug("Unregistering module socket '%s'", moduleSocket->getSocketName().c_str());

			_ModuleSocketsRegistry.erase(it);
		}

		/** Lookup in the created gateway for a gateway having the
		 *	specified local name.
		 */
		virtual IModuleGateway *getModuleGateway(const std::string &gatewayName)
		{
			TModuleGateways::iterator it(_ModuleGatewaysRegistry.find(gatewayName));
			if (it == _ModuleGatewaysRegistry.end())
				return NULL;
			else
				return it->second;
		}
		/** Register a gateway in the manager.
		 */
		virtual void registerModuleGateway(IModuleGateway *moduleGateway)
		{
			nlassert(moduleGateway != NULL);
			TModuleGateways::iterator it(_ModuleGatewaysRegistry.find(moduleGateway->getGatewayName()));
			nlassert(it == _ModuleGatewaysRegistry.end());

			nldebug("Registering module gateway '%s'", moduleGateway->getGatewayName().c_str());
			_ModuleGatewaysRegistry.insert(make_pair(moduleGateway->getGatewayName(), moduleGateway));
		}
		/** Unregister a socket in the manager.
		 */
		virtual void unregisterModuleGateway(IModuleGateway *moduleGateway)
		{
			nlassert(moduleGateway != NULL);
			TModuleGateways::iterator it(_ModuleGatewaysRegistry.find(moduleGateway->getGatewayName()));
			nlassert(it != _ModuleGatewaysRegistry.end());

			nldebug("Unregistering module gateway '%s'", moduleGateway->getGatewayName().c_str());

			_ModuleGatewaysRegistry.erase(it);
		}

		/** Get a module proxy with the module ID */
		virtual TModuleProxyPtr getModuleProxy(TModuleId moduleProxyId)
		{
			const TModuleProxyPtr *pproxy = _ModuleProxyIds.getB(moduleProxyId);

			if (pproxy == NULL)
				return NULL;
			else
				return *pproxy;
		}

		/** Called by a module that is begin destroyed.
		 *	This remove module information from the
		 *	the manager
		 */
//		virtual void onModuleDeleted(IModule *module)
//		{
//			// not needed ? to remove
//		}

		virtual IModuleProxy *createModuleProxy(
			IModuleGateway *gateway,
			CGatewayRoute *route,
			uint32 distance,
			IModule *localModule,
			const std::string &moduleClassName,
			const std::string &moduleFullyQualifiedName,
			const std::string &moduleManifest,
			TModuleId foreignModuleId)
		{
			std::auto_ptr<CModuleProxy> modProx = auto_ptr<CModuleProxy>(new CModuleProxy(localModule, ++_LastGeneratedId, moduleClassName, moduleFullyQualifiedName, moduleManifest));
			modProx->_Gateway = gateway;
			modProx->_Route = route;
			modProx->_Distance = distance;
			modProx->_ForeignModuleId = foreignModuleId;

			nldebug("Creating module proxy (ID : %u, foreign ID : %u, name : '%s', class : '%s' at %u hop",
				modProx->getModuleProxyId(),
				modProx->getForeignModuleId(),
				modProx->getModuleName().c_str(),
				modProx->getModuleClassName().c_str(),
				modProx->_Distance);

//			_ModuleProxyInstances.add(moduleFullyQualifiedName, TModuleProxyPtr(modProx.get()));
			_ModuleProxyIds.add(modProx->getModuleProxyId(), TModuleProxyPtr(modProx.get()));

			return modProx.release();
		}

		virtual void releaseModuleProxy(TModuleId moduleProxyId)
		{
			TModuleProxyIds::TAToBMap::const_iterator it(_ModuleProxyIds.getAToBMap().find(moduleProxyId));
			nlassert(it != _ModuleProxyIds.getAToBMap().end());
			CRefPtr<IModuleProxy> sanityCheck(it->second.getPtr());

			nldebug("Releasing module proxy ('%s', ID : %u)",
				it->second->getModuleName().c_str(),
				moduleProxyId);

			// remove the smart ptr, must delete the proxy
//			_ModuleProxyInstances.removeWithB(it->second);
			_ModuleProxyIds.removeWithB(it->second);

			nlassertex(sanityCheck == NULL, ("Someone has kept a smart pointer on the proxy '%s' of class '%s'", sanityCheck->getModuleName().c_str(), sanityCheck->getModuleClassName().c_str()));
		}

		virtual uint32 getNbModule()
		{
			return (uint32)_ModuleInstances.getAToBMap().size();
		}

		virtual uint32 getNbModuleProxy()
		{
			return (uint32)_ModuleProxyIds.getAToBMap().size();
		}



		NLMISC_COMMAND_HANDLER_TABLE_BEGIN(CModuleManager)
			NLMISC_COMMAND_HANDLER_ADD(CModuleManager, dump, "dump various information about module manager state", "");
			NLMISC_COMMAND_HANDLER_ADD(CModuleManager, loadLibrary, "load a pure nel library module (give the path if needed and only the undecorated lib name)", "[path]<undecoratedLibName>");
			NLMISC_COMMAND_HANDLER_ADD(CModuleManager, unloadLibrary, "unload a pure nel library module (give the undecorated name, any path will be removed", "<undecoratedLibName>");
			NLMISC_COMMAND_HANDLER_ADD(CModuleManager, createModule, "create a new module instance", "<moduleClass> <instanceName> [*<moduleArg>]");
			NLMISC_COMMAND_HANDLER_ADD(CModuleManager, deleteModule, "delete a module instance", "<instanceName>");
		NLMISC_COMMAND_HANDLER_TABLE_END

		NLMISC_CLASS_COMMAND_DECL(deleteModule)
		{
			nlunreferenced(rawCommandString);
			nlunreferenced(quiet);
			nlunreferenced(human);

			if (args.size() != 1)
				return false;

			TModulePtr const *module = _ModuleInstances.getB(args[0]);
			if (module == NULL)
			{
				log.displayNL("Unknow module '%s'", args[0].c_str());
				return false;
			}

			nlinfo("Deleting module '%s'", args[0].c_str());

			CRefPtr<IModule>	sanityCheck(*module);
			deleteModule(*module);
			if (sanityCheck != NULL)
			{
				log.displayNL("Failed to delete the module instance !");
				return false;
			}
			return true;
		}

		NLMISC_CLASS_COMMAND_DECL(unloadLibrary)
		{
			nlunreferenced(rawCommandString);
			nlunreferenced(log);
			nlunreferenced(quiet);
			nlunreferenced(human);

			if (args.size() != 1)
				return false;

			unloadModuleLibrary(args[0]);

			return true;
		}

		NLMISC_CLASS_COMMAND_DECL(loadLibrary)
		{
			nlunreferenced(log);
			nlunreferenced(quiet);
			nlunreferenced(human);

			if (args.size() < 1)
				return false;

			CSString libName = rawCommandString;
			// remove the command name
			libName.strtok(" \t");

			// load the library
			return this->loadModuleLibrary(libName);
		}

		NLMISC_CLASS_COMMAND_DECL(createModule)
		{
			nlunreferenced(log);
			nlunreferenced(quiet);
			nlunreferenced(human);

			if (args.size() < 2)
				return false;

			CSString moduleArgs = rawCommandString;
			// remove the command name
			moduleArgs.strtok(" \t");
			// retrieve module class
			string moduleClass = moduleArgs.strtok(" \t");
			// retrieve module instance name
			string moduleName = moduleArgs.strtok(" \t");

			nlinfo("Creating module '%s' of class '%s' with params '%s'",
				moduleName.c_str(),
				moduleClass.c_str(),
				moduleArgs.c_str());
			// create the module instance
			IModule *module = createModule(moduleClass, moduleName, moduleArgs);

			return module != NULL;
		}

		NLMISC_CLASS_COMMAND_DECL(dump)
		{
			nlunreferenced(rawCommandString);
			nlunreferenced(args);
			nlunreferenced(quiet);
			nlunreferenced(human);

			log.displayNL("Dumping CModuleManager internal states :");
			{
				std::vector<std::string> moduleList;
				TLocalModuleFactoryRegistry::instance().fillFactoryList(moduleList);
				log.displayNL(" List of %u local modules classes :", moduleList.size());
				for (uint i=0; i<moduleList.size(); ++i)
				{
					if (_ModuleFactoryRegistry.find(moduleList[i]) == _ModuleFactoryRegistry.end())
					{
						log.displayNL("    %s : UNAVAILABLE !", moduleList[i].c_str());
					}
					else
					{
						IModuleFactory *modFact = TLocalModuleFactoryRegistry::instance().getFactory(moduleList[i]);
						log.displayNL("    %s : OK\tInit params : '%s'", moduleList[i].c_str(), modFact->getInitStringHelp().c_str());
					}
				}
			}
			{
				log.displayNL(" List of %u loaded module libraries :", _ModuleLibraryRegistry.size());
				TModuleLibraryInfos::iterator first(_ModuleLibraryRegistry.begin()), last(_ModuleLibraryRegistry.end());
				for (; first != last; ++first)
				{
					TModuleLibraryInfo &mli = *(first->second);
					log.displayNL("  Library '%s' loaded from '%s', contains %u modules classes:",
						first->first.c_str(),
						mli.FullPathLibraryName.c_str(),
						mli.ModuleFactoryList.size());
					{
						vector<string>::iterator f2(mli.ModuleFactoryList.begin()), l2(mli.ModuleFactoryList.end());
						for (uint i=0; i<mli.ModuleFactoryList.size(); ++i)
						{
							if (_ModuleFactoryRegistry.find(mli.ModuleFactoryList[i]) == _ModuleFactoryRegistry.end())
							{
								log.displayNL("    %s : UNAVAILABLE, this class is already registered !", mli.ModuleFactoryList[i].c_str());
							}
							else
							{
								log.displayNL("    %s : OK", mli.ModuleFactoryList[i].c_str());
							}
						}
					}
				}
			}
			{
				log.displayNL(" List of %u module instances :", _ModuleInstances.getAToBMap().size());
				TModuleInstances::TAToBMap::const_iterator first(_ModuleInstances.getAToBMap().begin()), last(_ModuleInstances.getAToBMap().end());
				for (; first != last; ++first)
				{
					IModule *module = first->second;
					log.displayNL("    ID:%5u : \tname = '%s' \tclass = '%s'",
						module->getModuleId(),
						module->getModuleName().c_str(),
						module->getModuleClassName().c_str());
				}
			}
			{
				log.displayNL(" List of %u module proxies :", _ModuleProxyIds.getAToBMap().size());
				TModuleProxyIds::TAToBMap::const_iterator first(_ModuleProxyIds.getAToBMap().begin()), last(_ModuleProxyIds.getAToBMap().end());
				for (; first != last; ++first)
				{
					IModuleProxy *modProx = first->second;
					if (modProx->getGatewayRoute() != NULL)
					{
						log.displayNL("    ID:%5u (Foreign ID : %u) : \tname = '%s' \tclass = '%s'",
							modProx->getModuleProxyId(),
							modProx->getForeignModuleId(),
							modProx->getModuleName().c_str(),
							modProx->getModuleClassName().c_str());
					}
					else
					{
						log.displayNL("    ID:%5u (Local proxy for module ID : %u) : \tname = '%s' \tclass = '%s'",
							modProx->getModuleProxyId(),
							modProx->getForeignModuleId(),
							modProx->getModuleName().c_str(),
							modProx->getModuleClassName().c_str());
					}
				}
			}
			return true;
		}

	};

	bool		IModuleManager::isInitialized()
	{
		return CModuleManager::isInitialized();
	}

	IModuleManager &IModuleManager::getInstance()
	{
		return CModuleManager::getInstance();
	}

	void IModuleManager::releaseInstance()
	{
		CModuleManager::releaseInstance();
	}

	NLMISC_SAFE_SINGLETON_IMPL(CModuleManager);


	extern void forceGatewayLink();
	extern void forceLocalGatewayLink();
	extern void forceGatewayTransportLink();
	extern void forceGatewayL5TransportLink();


	void forceLink()
	{
		forceGatewayLink();
		forceLocalGatewayLink();
		forceGatewayTransportLink();
		forceGatewayL5TransportLink();
	}

} // namespace NLNET