#ifndef GLOBALCOMMANDCONTROLLER_HH

#define GLOBALCOMMANDCONTROLLER_HH

#include "Command.hh"

#include "CommandController.hh"

#include "InfoCommand.hh"

#include "InfoTopic.hh"

#include "Interpreter.hh"

#include "TclObject.hh"

#include "HotKey.hh"

#include "RomInfoTopic.hh"

#include "SettingsConfig.hh"

#include "hash_map.hh"

#include "xxhash.hh"

#include <memory>

#include <string>

#include <vector>

namespace openmsx {

class EventDistributor;

class Reactor;

class GlobalCliComm;

class ProxyCmd;

class ProxySetting;

class GlobalCommandControllerBase

{

protected:

	~GlobalCommandControllerBase();

#ifdef DEBUG

	hash_map<std::string, Command*,          XXHasher> commands;

#endif

	hash_map<std::string, CommandCompleter*, XXHasher> commandCompleters;

};

class GlobalCommandController final : private GlobalCommandControllerBase

                                    , public CommandController

{

public:

	GlobalCommandController(EventDistributor& eventDistributor,

	                        GlobalCliComm& cliComm,

	                        Reactor& reactor);

	GlobalCommandController(const GlobalCommandController&) = delete;

	GlobalCommandController(GlobalCommandController&&) = delete;

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

	GlobalCommandController& operator=(GlobalCommandController&&) = delete;

	~GlobalCommandController();

	[[nodiscard]] InfoCommand& getOpenMSXInfoCommand() { return openMSXInfoCommand; }

	/**

	 * Executes all defined auto commands

	 */

	void source(const std::string& script);

	void registerProxyCommand(std::string_view name);

	void unregisterProxyCommand(std::string_view name);

	void registerProxySetting(const Setting& setting);

	void unregisterProxySetting(const Setting& setting);

	// CommandController

	void   registerCompleter(CommandCompleter& completer,

	                         std::string_view str) override;

	void unregisterCompleter(CommandCompleter& completer,

	                         std::string_view str) override;

	void   registerCommand(Command& command,

	                       zstring_view str) override;

	void unregisterCommand(Command& command,

	                       std::string_view str) override;

	TclObject executeCommand(zstring_view command,

	                         CliConnection* connection = nullptr) override;

	void registerSetting(Setting& setting) override;

	void unregisterSetting(Setting& setting) override;

	[[nodiscard]] CliComm& getCliComm() override;

	[[nodiscard]] Interpreter& getInterpreter() override;

	/**

	 * Complete the given command.

	 */

	[[nodiscard]] std::string tabCompletion(std::string_view command);

	[[nodiscard]] std::string tabCompletionReplace(

		std::string_view command, const CompletionCandidate& replacement);

	/**

	 * Returns true iff the command is complete (all braces, quotes etc. are

	 * balanced).

	 */

	[[nodiscard]] bool isComplete(zstring_view command);

	[[nodiscard]] SettingsConfig& getSettingsConfig() { return settingsConfig; }

	[[nodiscard]] SettingsManager& getSettingsManager() { return settingsConfig.getSettingsManager(); }

	[[nodiscard]] CliConnection* getConnection() const { return connection; }

	[[nodiscard]] Reactor& getReactor() const { return reactor; }

	[[nodiscard]] const HotKey& getHotKey() const { return hotKey; }

private:

	void tabCompletion(std::vector<std::string>& tokens);

	using ProxySettings =

		std::vector<std::pair<std::unique_ptr<ProxySetting>, unsigned>>;

	ProxySettings::iterator findProxySetting(std::string_view name);

	GlobalCliComm& cliComm;

	CliConnection* connection = nullptr;

	Reactor& reactor;

	Interpreter interpreter;

	InfoCommand openMSXInfoCommand;

	HotKey hotKey;

	SettingsConfig settingsConfig;

	struct HelpCmd final : Command {

		explicit HelpCmd(GlobalCommandController& controller);

		void execute(std::span<const TclObject> tokens, TclObject& result) override;

		[[nodiscard]] std::string help(std::span<const TclObject> tokens) const override;

		void tabCompletion(std::vector<std::string>& tokens) const override;

	} helpCmd;

	struct TabCompletionCmd final : Command {

		explicit TabCompletionCmd(GlobalCommandController& controller);

		void execute(std::span<const TclObject> tokens, TclObject& result) override;

		[[nodiscard]] std::string help(std::span<const TclObject> tokens) const override;

	} tabCompletionCmd;

	struct UpdateCmd final : Command {

		explicit UpdateCmd(CommandController& commandController);

		void execute(std::span<const TclObject> tokens, TclObject& result) override;

		[[nodiscard]] std::string help(std::span<const TclObject> tokens) const override;

		void tabCompletion(std::vector<std::string>& tokens) const override;

	private:

		CliConnection& getConnection();

	} updateCmd;

	struct PlatformInfo final : InfoTopic {

		explicit PlatformInfo(InfoCommand& openMSXInfoCommand);

		void execute(std::span<const TclObject> tokens,

			     TclObject& result) const override;

		[[nodiscard]] std::string help(std::span<const TclObject> tokens) const override;

	} platformInfo;

	struct VersionInfo final : InfoTopic {

		explicit VersionInfo(InfoCommand& openMSXInfoCommand);

		void execute(std::span<const TclObject> tokens,

			     TclObject& result) const override;

		[[nodiscard]] std::string help(std::span<const TclObject> tokens) const override;

	} versionInfo;

	RomInfoTopic romInfoTopic;

	struct NameFromProxy {

		template<typename Pair>

		[[nodiscard]] const std::string& operator()(const Pair& p) const {

			return p.second->getName();

		}

	};

	hash_set<std::pair<unsigned, std::unique_ptr<ProxyCmd>>, NameFromProxy, XXHasher> proxyCommandMap;

	ProxySettings proxySettings;

};

} // namespace openmsx

#endif