#include "SettingsManager.hh"

#include "CommandException.hh"
#include "GlobalCommandController.hh"
#include "MSXException.hh"
#include "SettingsConfig.hh"
#include "TclObject.hh"

#include "outer.hh"

#include <cassert>
#include <ranges>

namespace openmsx {

// SettingsManager implementation:

SettingsManager::SettingsManager(GlobalCommandController& commandController)
	: settingInfo   (commandController.getOpenMSXInfoCommand())
	, setCompleter  (commandController)
	, incrCompleter (commandController, *this, "incr")
	, unsetCompleter(commandController, *this, "unset")
{
}

SettingsManager::~SettingsManager()
{
	assert(settings.empty());
}

void SettingsManager::registerSetting(BaseSetting& setting)
{
	assert(!settings.contains(setting.getFullNameObj()));
	settings.emplace_noDuplicateCheck(&setting);
}

void SettingsManager::unregisterSetting(BaseSetting& setting)
{
	const auto& name = setting.getFullNameObj();
	assert(settings.contains(name));
	settings.erase(name);
}

BaseSetting* SettingsManager::findSetting(std::string_view name) const
{
	if (auto it = settings.find(name); it != end(settings)) {
		return *it;
	}
	if (name.starts_with("::")) {
		// try without leading ::
		if (auto it = settings.find(name.substr(2)); it != end(settings)) {
			return *it;
		}
	} else {
		// try adding ::
		if (auto it = settings.find(tmpStrCat("::", name)); it != end(settings)) {
			return *it;
		}
	}
	return nullptr;
}

BaseSetting* SettingsManager::findSetting(std::string_view prefix, std::string_view baseName) const
{
	return findSetting(tmpStrCat(prefix, baseName));
}

// Helper functions for setting commands

BaseSetting& SettingsManager::getByName(std::string_view cmd, std::string_view name) const
{
	if (auto* setting = findSetting(name)) {
		return *setting;
	}
	throw CommandException(cmd, ": ", name, ": no such setting");
}

std::vector<std::string> SettingsManager::getTabSettingNames() const
{
	std::vector<std::string> result;
	result.reserve(size_t(settings.size()) * 2);
	for (const auto* s : settings) {
		std::string_view name = s->getFullName();
		result.emplace_back(name);
		if (name.starts_with("::")) {
			result.emplace_back(name.substr(2));
		} else {
			result.push_back(strCat("::", name));
		}
	}
	return result;
}

void SettingsManager::loadSettings(const SettingsConfig& config) const
{
	// restore default values or load new values
	for (auto* s : settings) {
		if (!s->needLoadSave()) continue;

		if (const auto* savedValue = config.getValueForSetting(s->getBaseName())) {
			try {
				s->setValue(TclObject(*savedValue));
			} catch (MSXException&) {
				// ignore error, instead set default value
				s->setValue(s->getDefaultValue());
			}
		} else {
			s->setValue(s->getDefaultValue());
		}
	}
}


// class SettingInfo

SettingsManager::SettingInfo::SettingInfo(InfoCommand& openMSXInfoCommand)
	: InfoTopic(openMSXInfoCommand, "setting")
{
}

void SettingsManager::SettingInfo::execute(
	std::span<const TclObject> tokens, TclObject& result) const
{
	auto& manager = OUTER(SettingsManager, settingInfo);
	switch (tokens.size()) {
	case 2:
		result.addListElements(std::views::transform(
			manager.settings,
			[](auto* p) { return p->getFullNameObj(); }));
		break;
	case 3: {
		const auto& settingName = tokens[2].getString();
		const auto* setting = manager.findSetting(settingName);
		if (!setting) {
			throw CommandException("No such setting: ", settingName);
		}
		try {
			setting->info(result);
		} catch (MSXException& e) {
			throw CommandException(e.getMessage());

		}
		break;
	}
	default:
		throw CommandException("Too many parameters.");
	}
}

std::string SettingsManager::SettingInfo::help(std::span<const TclObject> /*tokens*/) const
{
	return "openmsx_info setting        : "
	             "returns list of all settings\n"
	       "openmsx_info setting <name> : "
	             "returns info on a specific setting\n";
}

void SettingsManager::SettingInfo::tabCompletion(std::vector<std::string>& tokens) const
{
	if (tokens.size() == 3) {
		// complete setting name
		const auto& manager = OUTER(SettingsManager, settingInfo);
		completeString(tokens, manager.getTabSettingNames());
	}
}


// class SetCompleter

SettingsManager::SetCompleter::SetCompleter(
		CommandController& commandController_)
	: CommandCompleter(commandController_, "set")
{
}

std::string SettingsManager::SetCompleter::help(std::span<const TclObject> tokens) const
{
	if (tokens.size() == 2) {
		const auto& manager = OUTER(SettingsManager, setCompleter);
		return std::string(manager.getByName("set", tokens[1].getString()).getDescription());
	}
	return "Set or query the value of a openMSX setting or Tcl variable\n"
	       "  set <setting>          shows current value\n"
	       "  set <setting> <value>  set a new value\n"
	       "Use 'help set <setting>' to get more info on a specific\n"
	       "openMSX setting.\n";
}

void SettingsManager::SetCompleter::tabCompletion(std::vector<std::string>& tokens) const
{
	const auto& manager = OUTER(SettingsManager, setCompleter);
	switch (tokens.size()) {
	case 2: {
		// complete setting name
		completeString(tokens, manager.getTabSettingNames(), false); // case insensitive
		break;
	}
	case 3:
		// complete setting value
		if (const auto* setting = manager.findSetting(tokens[1])) {
			setting->tabCompletion(tokens);
		}
		break;
	}
}


// class SettingCompleter

SettingsManager::SettingCompleter::SettingCompleter(
		CommandController& commandController_, SettingsManager& manager_,
		const std::string& name_)
	: CommandCompleter(commandController_, name_)
	, manager(manager_)
{
}

std::string SettingsManager::SettingCompleter::help(std::span<const TclObject> /*tokens*/) const
{
	return {}; // TODO
}

void SettingsManager::SettingCompleter::tabCompletion(std::vector<std::string>& tokens) const
{
	if (tokens.size() == 2) {
		// complete setting name
		completeString(tokens, manager.getTabSettingNames());
	}
}

} // namespace openmsx