#ifndef SETTING_HH
#define SETTING_HH

#include "Subject.hh"
#include "TclObject.hh"
#include "static_string_view.hh"
#include "strCat.hh"

#include <cassert>
#include <cstdint>
#include <functional>
#include <optional>
#include <string_view>
#include <vector>

namespace openmsx {

class CommandController;
class GlobalCommandController;
class Interpreter;

class BaseSetting
{
protected:
	explicit BaseSetting(std::string_view name);
	explicit BaseSetting(TclObject name);
	~BaseSetting() = default;

public:
	/** Get the name of this setting.
	  * For global settings 'fullName' and 'baseName' are the same. For
	  * machine specific settings 'fullName' is the fully qualified name,
	  * and 'baseName' is the name without machine-prefix. For example:
	  *   fullName = "::machine1::PSG_volume"
	  *   baseName = "PSG_volume"
	  */
	[[nodiscard]] const TclObject& getFullNameObj() const { return fullName; }
	[[nodiscard]] const TclObject& getBaseNameObj() const { return baseName; }
	[[nodiscard]] std::string_view getFullName()    const { return fullName.getString(); }
	[[nodiscard]] std::string_view getBaseName()    const { return baseName.getString(); }

	/** Set a machine specific prefix.
	 */
	void setPrefix(std::string_view prefix) {
		assert(prefix.starts_with("::"));
		fullName = tmpStrCat(prefix, getBaseName());
	}

	/** For SettingInfo
	  */
	void info(TclObject& result) const;

	/// pure virtual methods ///

	/** Get a description of this setting that can be presented to the user.
	  */
	[[nodiscard]] virtual std::string_view getDescription() const = 0;

	/** Returns a string describing the setting type (integer, string, ..)
	  * Could be used in a GUI to pick an appropriate setting widget.
	  */
	[[nodiscard]] virtual std::string_view getTypeString() const = 0;

	/** Helper method for info().
	 */
	virtual void additionalInfo(TclObject& result) const = 0;

	/** Complete a partly typed value.
	  * Default implementation does not complete anything,
	  * subclasses can override this to complete according to their
	  * specific value type.
	  */
	virtual void tabCompletion(std::vector<std::string>& tokens) const = 0;

	/** Get current value as a TclObject.
	 */
	[[nodiscard]] virtual const TclObject& getValue() const = 0;

	/** Like getValue(), but in case of error returns an empty optional
	  * instead of throwing an exception.
	  */
	[[nodiscard]] virtual std::optional<TclObject> getOptionalValue() const = 0;

	/** Get the default value of this setting.
	  * This is the initial value of the setting. Default values don't
	  * get saved in 'settings.xml'.
	  * This is also the value used for a Tcl 'unset' command.
	  */
	[[nodiscard]] virtual TclObject getDefaultValue() const = 0;

	/** Change the value of this setting to the given value.
	  * This method will trigger Tcl traces.
	  * This value still passes via the 'checker-callback' (see below),
	  * so the value may be adjusted. Or in case of an invalid value
	  * this method may throw.
	  */
	virtual void setValue(const TclObject& value) = 0;

	/** Similar to setValue(), but doesn't trigger Tcl traces.
	  * Like setValue(), the given value may be adjusted or rejected.
	  * Should only be used by the Interpreter class.
	  */
	virtual void setValueDirect(const TclObject& value) = 0;

	/** Does this setting need to be loaded or saved (settings.xml).
	  */
	[[nodiscard]] virtual bool needLoadSave() const = 0;

	/** Does this setting need to be transfered on reverse.
	  */
	[[nodiscard]] virtual bool needTransfer() const = 0;

private:
	      TclObject fullName;
	const TclObject baseName;
};


class Setting : public BaseSetting, public Subject<Setting>
{
public:
	enum class Save : uint8_t {
		YES,                  //    save,    transfer
		NO,                   // no-save,    transfer
		NO_AND_DONT_TRANSFER, // no-save, no-transfer
	};

	Setting(const Setting&) = delete;
	Setting(Setting&&) = delete;
	Setting& operator=(const Setting&) = delete;
	Setting& operator=(Setting&&) = delete;
	virtual ~Setting();

	/** Gets the current value of this setting as a TclObject.
	  */
	[[nodiscard]] const TclObject& getValue() const final { return value; }
	[[nodiscard]] std::optional<TclObject> getOptionalValue() const final { return value; }

	/** Set value-check-callback.
	 * The callback is called on each change of this settings value.
	 * The callback has the possibility to
	 *  - change the value (modify the parameter)
	 *  - disallow the change (throw an exception)
	 * The callback is only executed on each value change, even if the
	 * new value is the same as the current value. However the callback
	 * is not immediately executed once it's set (via this method).
	 */
	void setChecker(std::function<void(TclObject&)> checkFunc_) {
		checkFunc = std::move(checkFunc_);
	}

	// BaseSetting
	void setValue(const TclObject& newValue) final;
	[[nodiscard]] std::string_view getDescription() const final;
	[[nodiscard]] TclObject getDefaultValue() const final { return defaultValue; }
	void setValueDirect(const TclObject& newValue) final;
	void tabCompletion(std::vector<std::string>& tokens) const override;
	[[nodiscard]] bool needLoadSave() const final;
	void additionalInfo(TclObject& result) const override;
	[[nodiscard]] bool needTransfer() const final;

	// convenience functions
	[[nodiscard]] CommandController& getCommandController() const { return commandController; }
	[[nodiscard]] Interpreter& getInterpreter() const;

protected:
	Setting(CommandController& commandController,
	        std::string_view name, static_string_view description,
	        const TclObject& initialValue, Save save = Save::YES);
	void init();
	void notifyPropertyChange() const;

private:
	[[nodiscard]] GlobalCommandController& getGlobalCommandController() const;
	void notify() const;

private:
	CommandController& commandController;
	const static_string_view description;
	std::function<void(TclObject&)> checkFunc;
	TclObject value; // TODO can we share the underlying Tcl var storage?
	const TclObject defaultValue;
	const Save save;
};

} // namespace openmsx

#endif