// 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/>.

#ifndef NL_COMMAND_H
#define NL_COMMAND_H

#include "types_nl.h"
#include "twin_map.h"

#include <string>
#include <map>
#include <set>
#include <vector>
//#include <sstream>
#include <istream>

#include "stream.h"
#include "config_file.h"
#include "log.h"


namespace NLMISC {

/** WARNING:
 *   This is standard Unix linker behavior: object files
 *   that are not referenced from outside are discarded. The
 *   file in which you run your constructor is thus simply
 *   thrown away by the linker, which explains why the constructor
 *   is not run.
 */

/**
 * Create a function that can be call in realtime.
 *
 * Example:
 * \code
	// I want to create a function that computes the square of the parameter and display the result
	NLMISC_COMMAND(square,"display the square of the parameter","<value>")
	{
		// check args, if there s not the right number of parameter, return bad
		if(args.size() != 1) return false;
		// get the value
		uint32 val;
		fromString(args[0], val);
		// display the result on the displayer
		log.displayNL("The square of %d is %d", val, val*val);
		return true;
	}
 * \endcode
 *
 * Please use the same casing than for the function (first letter in lower case and after each word first letter in upper case)
 * ie: myFunction, step, orderByName, lookAtThis
 *
 * System extended by Sadge July 2004
 *  - NLMISC_CATEGORISED_COMMAND now takes a 4th 'category' parameter which is used by 'help' system to organise cmmands
 *  - All default commands added by NeL are categorised as "nel"
 *  - All commands created using the NLMISC_COMMAND macro are are categorised as "commands"
 *
 * \author Vianney Lecroart
 * \author Nevrax France
 * \date 2001
 */
#define NLMISC_COMMAND(__name,__help,__args) NLMISC_CATEGORISED_COMMAND(commands,__name,__help,__args)
#define NLMISC_CATEGORISED_COMMAND(__category,__name,__help,__args) \
struct __category##_##__name##Class: public NLMISC::ICommand \
{ \
	__category##_##__name##Class() : NLMISC::ICommand(#__category,#__name,__help,__args) { } \
	virtual bool execute(const std::string &rawCommandString, const std::vector<std::string> &args, NLMISC::CLog &log, bool quiet, bool human); \
}; \
__category##_##__name##Class __category##_##__name##Instance; \
bool __category##_##__name##Class::execute(const std::string &rawCommandString, const std::vector<std::string> &args, NLMISC::CLog &log, bool quiet, bool human)

/** Helper to declare a command as friend of a class.
 *	Useful when you want to declare debug command that access private class method or data.
*/
#define NLMISC_COMMAND_FRIEND(__name) friend struct commands_##__name##Class
#define NLMISC_CATEGORISED_COMMAND_FRIEND(__category,__name) friend struct __category##_##__name##Class

/**
 * Create a function that can be call in realtime. Don't use this class directly but use the macro NLMISC_COMMAND
 * \author Vianney Lecroart
 * \author Nevrax France
 * \date 2001
 */
class ICommand
{
public:

	/// Constructor
	ICommand(const char *categoryName, const char *commandName, const char *commandHelp, const char *commandArgs);

	virtual ~ICommand();

	// quiet means that we don't display anything else than the value
	// human means that we want the value in a human readable if possible
	virtual bool execute(const std::string &rawCommandString, const std::vector<std::string> &args, NLMISC::CLog &log, bool quiet, bool human = true) = 0;

	std::string CategoryName;
	std::string HelpString;
	std::string CommandArgs;

	// is it a variable or a classic command?
	enum TType { Unknown, Command, Variable };
	TType Type;

	// static members

	typedef std::map<std::string, ICommand *> TCommand;
//	typedef std::set<std::string> TCategorySet;

	static TCommand		*LocalCommands;
//	static TCategorySet	*LocalCategories;
//	static TCommand		*LocalCommands;
	static bool			LocalCommandsInit;

	/// Executes the command and display output to the log
	/// \param quiet true if you don't want to display the "executing the command ..."
	static bool execute (const std::string &commandWithArgs, NLMISC::CLog &log, bool quiet = false, bool human = true);

	/** Command name completion.
	 * Case-sensitive. Displays the list after two calls with the same non-unique completion.
     * Completes commands used with prefixes (such as "help " for example) as well.
	 */
	static void	expand (std::string &commandName, NLMISC::CLog &log=*InfoLog);

	static void serialCommands (IStream &f);

	/// returns true if the command exists
	static bool exists (std::string const &commandName);

	/// if the string begin with an upper case, it s a variable, otherwise, it s a command
	static bool isCommand (const std::string &str);

	/// Retrieve the interface over command object for the given command name.
	static ICommand *getCommand(const std::string &commandName);

	const std::string &getName () const { return _CommandName; }

	/** declare a command to "enable control char". By default all commands "enable control char"
	 *
	 *	eg: if enableControlCharForCommand("region", false) is called, then the command:
	 *
	 *	region hello; "i am busy" \never disturb me please
	 *
	 *	won't treat '"', '\' and ';' as special control character.
	 *	Thus the final list of args will be (separated by '/' here for clarity):
	 *
	 *	hello;/"i/am/busy"/\never/disturb/me/please
	 */
	static void	enableControlCharForCommand(const std::string &commandName, bool state);

	/// see enableControlCharForCommand()
	static bool	isControlCharForCommandEnabled(const std::string &commandName);

protected:

	std::string _CommandName;

};


/** Struct to host data for one object command
 * \author Boris 'SoniX' Boucher
 * \author Nevrax France
 * \date 2005
 */
struct TCommandHandlerInfo
{
	/// The help string of the command
	std::string		CommandHelp;
	/// The argument required for the command
	std::string		CommandArgs;

	/// A comparison operator need for STL container storage
	bool operator ==(const TCommandHandlerInfo &other) const
	{
		return (CommandHelp == other.CommandHelp) && (CommandArgs == other.CommandArgs);
	}
};

/** Struct to host data for all the commands of an object class
 * \author Boris 'SoniX' Boucher
 * \author Nevrax France
 * \date 2005
 */
struct TCommandHandlerClassInfo
{
	/// Number of instance of object of this class
	uint32			InstanceCount;

	/// The list of command available on this class of object.
	typedef std::map<std::string, TCommandHandlerInfo>	TCommandsInfo;
	TCommandsInfo	_Commands;

	/// Constructor.
	TCommandHandlerClassInfo()
		: InstanceCount(0)
	{}
};


/** Base class for command handler.
 *	Command handler are a mean to build object that support NeL commands
 *	_Commands are associated to object class and invoked to named instance.
 *	Each named instance must have a unique name (whatever it's class).
 *	Unlike NeL global commands, object commands are invoked in the context
 *	of the object instance.
 *
 *	In order to write an object that support commands, you must devive from
 *	template<class MyClass> CCommandsHandler. The class ICommandsHandler
 *	is used by the command registry to handle any type of object.
 *
 * \author Boris 'SoniX' Boucher
 * \author Nevrax France
 * \date 2005
 */
class ICommandsHandler
{
	/// Store the class name after handler registration
	const std::string		*_ClassName;
public:

	ICommandsHandler();

	/** The derived class call this method to register the instance in
	 *	the command registry.
	 *	Before calling this method, the object is not available for
	 *	commands invocation.
	 */
	void registerCommandsHandler();
	/** The derived class call this method to unregister the instance in
	 *	the command registry.
	 *	After this call, the object is no more liste in named object
	 *	list nor it can receive command invocation.
	 *	You can later re-register the object.
	 */
	void unregisterCommandsHandler();

	virtual const std::string &getCommandHandlerClassName() const =0;

	/** This methods implemented by CCommandHandler is used by the
	 *	command registry to retrieve the name of the object instance.
	 */
	virtual const std::string &getCommandHandlerName() const =0;

	/** This methods implemented by CCommandHandler is used by the
	 *	command registry to build the list of available commands
	 *	on the object class.
	 */
	virtual void fillCommandsHandlerList(TCommandHandlerClassInfo::TCommandsInfo &commandList) =0;

	/** Virtual destructor to unregister the object instance.
	 *	When all the instance of a given class are deleted,
	 *	the associated command an class information are
	 *	removed from the command registry.
	 */
	virtual ~ICommandsHandler();

	/** This methods implemented by CCommandHandler is used by the
	 *	command registry to start a command execution.
	 */
	virtual bool execute(const std::string &rawCommandString, const std::string &commandName, const std::vector<std::string> &args, NLMISC::CLog &log, bool quiet, bool human = true) =0;
};

template <class T>
struct TCommandHandler : public TCommandHandlerInfo
{
	typedef bool (T::*TCommand)(const std::string &rawCommandString, const std::vector<std::string> &args, NLMISC::CLog &log, bool quiet, bool human);

	TCommand	CommandHandler;
};


/** Template class used as base for derivation of object that support commands.
 *	To declare your object supporting commands, you must
 *	derive from this class with your class type as template parameter.
 *
 *	e.g :
 *	class CMyClass : public CCommandsHandler<CMyClass>
 *	{
 *	};
 *
 *	To easily generate the command table, NeL provide some macros :
 *
 *	class CMyClass : public CCommandsHandler<CMyClass>
 *	{
 *	public:
 *
 *		NLMISC_COMMAND_HANDLER_TABLE_BEGIN(CMyClass)
 *			NLMISC_COMMAND_HANDLER_ADD(CMyClass, theCommand1, "help", "args")
 *			NLMISC_COMMAND_HANDLER_ADD(CMyClass, theCommand2, "other help", "other args")
 *		NLMISC_COMMAND_HANDLER_TABLE_END
 *
 *		NLMISC_CLASS_COMMAND_DECL(theCommand1)
 *		{
 *			// put yout code here
 *		}
 *
 *		NLMISC_CLASS_COMMAND_DECL(theCommand2)
 *		{
 *			// put yout code here
 *		}
 *	};
 *
 *	You can also derive a class and add some more commands in the
 *	derived class by using NLMISC_COMMAND_HANDLER_TABLE_EXTEND_BEGIN:
 *
 *	class CMyDerivedClass : public CMyClass
 *	{
 *		NLMISC_COMMAND_HANDLER_TABLE_EXTEND_BEGIN(CMyClass)
 *			NLMISC_COMMAND_HANDLER_ADD(CMyClass, addedCommand, "help", "args")
 *		NLMISC_COMMAND_HANDLER_TABLE_END
 *
 *		NLMISC_CLASS_COMMAND_DECL(addedCommand)
 *		{
 *			// put yout code here
 *		}
 *	};
 *
 * \author Boris 'SoniX' Boucher
 * \author Nevrax France
 * \date 2005
 */
//template <class T>
//class CCommandsHandler : public ICommandsHandler
//{
//public:
//	/** Constructor, used to initialise the class name in the interface class */
////	CCommandsHandler()
////		: ICommandsHandler(T::getCommandHandlerClassName())
////	{
////	}
////
//	/** Virtual pure method used by execute to retrieve the method pointer.
//	 *	This method will be automatically implemented by the NLMISC_COMMAND_HANDLER_TABLE_BEGIN
//	 *	macro utility.
//	 */
////	virtual TCommand getCommandHandler(const std::string &commandName) =0;
//
//	/** Execute a command.
//	 *	Return false if no command of the name exist.
//	 */
////	bool execute(const std::string &rawCommandString, const std::string &commandName, const std::vector<std::string> &args, NLMISC::CLog &log, bool quiet, bool human = true)
////	{
////		TCommand cmd = getCommandHandler(commandName);
////		if (cmd != NULL)
////		{
////			T* tp = static_cast<T*>(this);
////			return (tp->*cmd)(rawCommandString, args, log, quiet, human);
////		}
////		else
////		{
////			log.displayNL("Command on object '%s' : unknow command '%s'",
////				getCommandHandlerName().c_str(),
////				commandName.c_str());
////			return false;
////		}
////	}
//};

/** Macro to start a command handler table.
 *	Use it inside the class declaration.
 */
#define NLMISC_COMMAND_HANDLER_TABLE_BEGIN(className)	\
	/* Typedef a method pointer on the template class.		*/	\
	/*	This type is the type of the command handler method.*/	\
	/*	It have the same signature as global NeL commands.	*/	\
	typedef bool (className::*TCommand)(const std::string &rawCommandString, const std::vector<std::string> &args, NLMISC::CLog &log, bool quiet, bool human);	\
	\
	/** Typedef for a container for command handler table. */	\
	typedef std::map<std::string, NLMISC::TCommandHandler<className> >	TCommandsTable;	\
	\
	virtual const std::string &getCommandHandlerClassName()	const\
	{	\
		static std::string className(#className);	\
		return className;	\
	}	\
	TCommand className##_getCommandHandler(const std::string &commandName)	\
	{	\
		TCommandsTable	commandTable = className##_getCommandsHandlerTable();	\
		TCommandsTable::iterator it = commandTable.find(commandName);	\
		\
		if (it != commandTable.end())	\
		{	\
			/** ok, we have the command handler*/	\
			return it->second.CommandHandler;	\
		}	\
		else	\
			return NULL;	\
	}	\
	virtual bool execute(const std::string &rawCommandString, const std::string &commandName, const std::vector<std::string> &args, NLMISC::CLog &log, bool quiet, bool human) \
	{ \
		TCommand cmd = className##_getCommandHandler(commandName); \
		if (cmd != NULL) \
		{ \
			if (!quiet)\
				log.displayNL("Execute command: %s", rawCommandString.c_str()); \
			return (this->*cmd)(rawCommandString, args, log, quiet, human); \
		} \
		else \
		{ \
			log.displayNL("Command on object '%s' : unknow command '%s'", \
				getCommandHandlerName().c_str(), \
				commandName.c_str()); \
			return false; \
		} \
	} \
	virtual void fillCommandsHandlerList(NLMISC::TCommandHandlerClassInfo::TCommandsInfo &commandList)	\
	{	\
		const TCommandsTable	&commandTable = className##_getCommandsHandlerTable();	\
		TCommandsTable::const_iterator first(commandTable.begin()), last(commandTable.end());	\
		for (; first != last; ++first)	\
		{	\
			commandList.insert(std::make_pair(first->first, first->second));	\
		}	\
	}	\
	\
	const TCommandsTable &className##_getCommandsHandlerTable()	\
	{	\
		static bool initialized = false;	\
		static TCommandsTable	commandsTable;	\
	\
		if (!initialized)	\
		{	\
			initialized = true; \


/** Macro to add a handler in the handler table.
 *	Use this macro between NLMISC_COMMAND_HANDLER_TABLE_BEGIN and
 *	NLMISC_COMMAND_HANDLER_TABLE_END macros.
 *
 *	The command name must match a method of the class with
 *	a command signature.
 *	You can easily declare command method using the macro
 *	NLMISC_CLASS_COMMAND_DECL
 *
 */
#define NLMISC_COMMAND_HANDLER_ADD(className, theCommandName, theCommandHelp, theCommandArgs) \
			{	\
				NLMISC::TCommandHandler<className> ch;	\
				ch.CommandArgs = theCommandArgs;	\
				ch.CommandHelp = theCommandHelp;	\
				ch.CommandHandler = &className::cmdHandler_##theCommandName; \
				commandsTable.insert(std::make_pair(std::string(#theCommandName), ch));	\
			}	\

/** Macro to end the command handler table.
 *	Must be put after the last command handler adding.
 */
#define NLMISC_COMMAND_HANDLER_TABLE_END	\
		}	\
		return commandsTable; \
	}	\

/** Macro to add commands in a class that derive from a class
 *	that already declare a command handler table.
 *	the most derivative class will override base class commands
 *	if they have the same name.
 */
#define NLMISC_COMMAND_HANDLER_TABLE_EXTEND_BEGIN(className, baseClassName)	\
	typedef bool (className::*TCommand)(const std::string &rawCommandString, const std::vector<std::string> &args, NLMISC::CLog &log, bool quiet, bool human);	\
	typedef std::map<std::string, NLMISC::TCommandHandler<className> >	TCommandsTable;	\
	virtual const std::string &getCommandHandlerClassName()	const\
	{	\
		static std::string className(#className);	\
		return className;	\
	}	\
	TCommand className##_getCommandHandler(const std::string &commandName)	\
	{	\
		TCommandsTable	commandTable = className##_getCommandsHandlerTable();	\
		TCommandsTable::iterator it = commandTable.find(commandName);	\
		\
		if (it != commandTable.end())	\
		{	\
			/* ok, we have the command handler*/	\
			return it->second.CommandHandler;	\
		}	\
		else	\
		{ \
			return NULL;\
		} \
	}	\
	virtual bool execute(const std::string &rawCommandString, const std::string &commandName, const std::vector<std::string> &args, NLMISC::CLog &log, bool quiet, bool human) \
	{ \
		TCommand cmd = className##_getCommandHandler(commandName); \
		if (cmd != NULL) \
		{ \
			return (this->*cmd)(rawCommandString, args, log, quiet, human); \
		} \
		else \
		{ \
			/* try with the base class */ \
			return baseClassName::execute(rawCommandString, commandName, args, log, quiet, human);\
		} \
	} \
	virtual void fillCommandsHandlerList(NLMISC::TCommandHandlerClassInfo::TCommandsInfo &commandList)	\
	{	\
		const TCommandsTable	&commandTable = className##_getCommandsHandlerTable();	\
		TCommandsTable::const_iterator first(commandTable.begin()), last(commandTable.end());	\
		for (; first != last; ++first)	\
		{	\
			commandList.insert(std::make_pair(first->first, first->second));	\
		}	\
		/* call base class to complete the command table */ \
		baseClassName::fillCommandsHandlerList(commandList); \
	}	\
	\
	const TCommandsTable &className##_getCommandsHandlerTable()	\
	{	\
		static bool initialized = false;	\
		static TCommandsTable	commandsTable;	\
	\
		if (!initialized)	\
		{	\
			initialized = true; \


// A macro to declare or implement inline the command method
#define NLMISC_CLASS_COMMAND_DECL(commandName) \
	bool cmdHandler_##commandName(const std::string &rawCommandString, const std::vector<std::string> &args, NLMISC::CLog &log, bool quiet, bool human)

// A macro to implement the command method in a cpp (you still need to declare it in the class scope using the previous macro)
#define NLMISC_CLASS_COMMAND_IMPL(className, commandName) \
	bool className::cmdHandler_##commandName(const std::string &rawCommandString, const std::vector<std::string> &args, NLMISC::CLog &log, bool quiet, bool human)

// A macro to recall a base class command implementation
#define NLMISC_CLASS_COMMAND_CALL_BASE(baseClassName, commandName)\
	baseClassName::cmdHandler_##commandName(rawCommandString, args, log, quiet, human)

/** The command registry is a singleton that hold all available
 *	commands.
 *	It bridge the legacy global commands and variable with
 *	the object commands.
 *
 *	All the legacy static call made on ICommand are now forwarded
 *	directly to this class (e.g. IService::execute)
 *
 *	This class is modeled after the safe singlton pattern,
 *	so it is safe to use in a dynamicaly loaded library
 *	program.
 *
 * \author Boris 'SoniX' Boucher
 * \author Nevrax France
 * \date 2005
 */
class CCommandRegistry
{
	// this class is a safe singleton (dll friendly)
	NLMISC_SAFE_SINGLETON_DECL(CCommandRegistry);
	CCommandRegistry() {}

	NLMISC_CATEGORISED_COMMAND_FRIEND(nel, help);

	friend void cbVarChanged (CConfigFile::CVar &var);
	friend class ICommand;
	friend class ICommandsHandler;
	friend class INelContext;

	typedef std::map<std::string, ICommand *>	TCommand;
	typedef std::set<std::string>				TCategorySet;

	/// List of commands categories
	TCategorySet	_Categories;
	/// List of available command
	TCommand		_Commands;

	typedef CTwinMap<std::string, ICommandsHandler *>	TCommandsHandlers;
	/// Registry for commands handlers named instance
	TCommandsHandlers			_CommandsHandlers;

	typedef std::map<std::string, TCommandHandlerClassInfo >	TCommandsHandlersClass;
	/// Registry for commands name and handler class
	TCommandsHandlersClass		_CommandsHandlersClass;

	std::set<std::string>		_CommandsDisablingControlChar;

	/// Used by ICommand to register themselves
	void registerCommand(ICommand *command);
	/// Used by ICommand to unregister themselves
	void unregisterCommand(ICommand *command);


public:

	/// Called by command handlers to register themselves.
	void registerNamedCommandHandler(ICommandsHandler *handler, const std::string &className);
	/// Called by command handlers to unregister themselves.
	void unregisterNamedCommandHandler(ICommandsHandler *handler, const std::string &className);

	/// Executes the command and display output to the log
	/// \param quiet true if you don't want to display the "executing the command ..."
	bool execute (const std::string &commandWithArgs, NLMISC::CLog &log, bool quiet = false, bool human = true);

	/** Command name completion.
	 * Case-sensitive. Displays the list after two calls with the same non-unique completion.
     * Completes commands used with prefixes (such as "help " for example) as well.
	 */
	void expand (std::string &commandName, NLMISC::CLog &log=*InfoLog);

	void serialCommands (IStream &f);

	/// returns true if the command exists
	bool exists (std::string const &commandName);

	/// Return true if a named command handler with that name is registered
	bool isNamedCommandHandler(const std::string &handlerName);

	/// if the string begin with an upper case, it s a variable, otherwise, it s a command
	bool isCommand (const std::string &str);

	/// Retrieve the interface over command object for the given command name.
	ICommand *getCommand(const std::string &commandName);

	/** declare a command to "enable control char". By default all commands "enable control char"
	 *
	 *	eg: if enableControlCharForCommand("region", false) is called, then the command:
	 *
	 *	region hello; "i am busy" \never disturb me please
	 *
	 *	won't treat '"', '\' and ';' as special control character.
	 *	Thus the final list of args will be (separated by '/' here for clarity):
	 *
	 *	hello;/"i/am/busy"/\never/disturb/me/please
	 */
	void	enableControlCharForCommand(const std::string &commandName, bool state);

	/// see enableControlCharForCommand()
	bool	isControlCharForCommandEnabled(const std::string &commandName);

	// initialisation for IVariable management (variable are an extension of commands)
	void initVariables(NLMISC::CConfigFile &configFile);

};

/** This class is only used to serialize easily a command for the admin service for example */
struct CSerialCommand
{
	CSerialCommand () : Name ("<Unknown>"), Type(ICommand::Unknown) { }
	CSerialCommand (std::string n, ICommand::TType t) : Name (n), Type(t) { }

	std::string Name;
	ICommand::TType Type;

	void serial (IStream &f)
	{
		f.serial (Name);
		f.serialEnum (Type);
	}
};


} // NLMISC


#endif // NL_COMMAND_H

/* End of command.h */