#ifndef RENDERSETTINGS_HH
#define RENDERSETTINGS_HH

#include "BooleanSetting.hh"
#include "EnumSetting.hh"
#include "FloatSetting.hh"
#include "IntegerSetting.hh"
#include "StringSetting.hh"

#include "Observer.hh"
#include "gl_mat.hh"
#include "narrow.hh"

#include <cstdint>

namespace openmsx {

class CommandController;
class Interpreter;

/** Class containing all settings for renderers.
  * Keeping the settings here makes sure they are preserved when the user
  * switches to another renderer.
  */
class RenderSettings final : private Observer<Setting>
{
public:
	/** Enumeration of Renderers known to openMSX.
	  * This is the full list, the list of available renderers may be smaller.
	  */
	enum class RendererID : uint8_t { UNINITIALIZED, DUMMY, SDLGL_PP };
	using RendererSetting = EnumSetting<RendererID>;

	/** Render accuracy: granularity of the rendered area.
	  */
	enum class Accuracy : uint8_t { SCREEN, LINE, PIXEL };

	/** Scaler algorithm
	  */
	enum class ScaleAlgorithm : uint8_t {
		SIMPLE, SCALE, HQ, RGBTRIPLET, TV,
		NO
	};

	enum class DisplayDeform : uint8_t {
		NORMAL, _3D
	};

	explicit RenderSettings(CommandController& commandController);
	~RenderSettings();

	/** Accuracy [screen, line, pixel]. */
	[[nodiscard]] EnumSetting<Accuracy>& getAccuracySetting() { return accuracySetting; }
	[[nodiscard]] Accuracy getAccuracy() const { return accuracySetting.getEnum(); }

	/** Deinterlacing [on, off]. */
	[[nodiscard]] BooleanSetting& getDeinterlaceSetting() { return deinterlaceSetting; }
	[[nodiscard]] bool getDeinterlace() const { return deinterlaceSetting.getBoolean(); }

	/** Deflicker [on, off]. */
	[[nodiscard]] BooleanSetting& getDeflickerSetting() { return deflickerSetting; }
	[[nodiscard]] bool getDeflicker() const { return deflickerSetting.getBoolean(); }

	/** The current max frameskip. */
	[[nodiscard]] IntegerSetting& getMaxFrameSkipSetting() { return maxFrameSkipSetting; }
	[[nodiscard]] int getMaxFrameSkip() const { return maxFrameSkipSetting.getInt(); }

	/** The current min frameskip. */
	[[nodiscard]] IntegerSetting& getMinFrameSkipSetting() { return minFrameSkipSetting; }
	[[nodiscard]] int getMinFrameSkip() const { return minFrameSkipSetting.getInt(); }

	/** Full screen [on, off]. */
	[[nodiscard]] BooleanSetting& getFullScreenSetting() { return fullScreenSetting; }
	[[nodiscard]] bool getFullScreen() const { return fullScreenSetting.getBoolean(); }

	/** The amount of gamma correction. */
	[[nodiscard]] FloatSetting& getGammaSetting() { return gammaSetting; }
	[[nodiscard]] float getGamma() const { return gammaSetting.getFloat(); }

	/** Brightness video setting. */
	[[nodiscard]] FloatSetting& getBrightnessSetting() { return brightnessSetting; }
	[[nodiscard]] float getBrightness() const { return brightnessSetting.getFloat(); }

	/** Contrast video setting. */
	[[nodiscard]] FloatSetting& getContrastSetting() { return contrastSetting; }
	[[nodiscard]] float getContrast() const { return contrastSetting.getFloat(); }

	/** Color matrix setting. */
	[[nodiscard]] StringSetting& getColorMatrixSetting() { return colorMatrixSetting; }
	/** Returns true iff the current color matrix is the identity matrix. */
	[[nodiscard]] bool isColorMatrixIdentity() const { return cmIdentity; }

	/** The amount of glow [0..100]. */
	[[nodiscard]] IntegerSetting& getGlowSetting() { return glowSetting; }
	[[nodiscard]] int getGlow() const { return glowSetting.getInt(); }

	/** The amount of noise to add to the frame. */
	[[nodiscard]] FloatSetting& getNoiseSetting() { return noiseSetting; }
	[[nodiscard]] float getNoise() const { return noiseSetting.getFloat(); }

	/** The amount of horizontal blur [0..256]. */
	[[nodiscard]] IntegerSetting& getBlurSetting() { return horizontalBlurSetting; }
	[[nodiscard]] int getBlurFactor() const {
		return (horizontalBlurSetting.getInt()) * 256 / 100;
	}

	/** The alpha value [0..255] of the gap between scanlines. */
	[[nodiscard]] IntegerSetting& getScanlineSetting() { return scanlineAlphaSetting; }
	[[nodiscard]] int getScanlineFactor() const {
		return 255 - ((scanlineAlphaSetting.getInt() * 255) / 100);
	}
	/** The amount of space [0..1] between scanlines. */
	[[nodiscard]] float getScanlineGap() const {
		return narrow<float>(scanlineAlphaSetting.getInt()) * 0.01f;
	}

	/** The current renderer. */
	[[nodiscard]] RendererSetting& getRendererSetting() { return rendererSetting; }
	[[nodiscard]] RendererID getRenderer() const {
		auto r = rendererSetting.getEnum();
		return r == RendererID::UNINITIALIZED ? RendererID::DUMMY : r;
	}

	/** The current scaling algorithm. */
	[[nodiscard]] auto& getScaleAlgorithmSetting() { return scaleAlgorithmSetting; }
	[[nodiscard]] ScaleAlgorithm getScaleAlgorithm() const {
		return scaleAlgorithmSetting.getEnum();
	}

	/** The current scaling factor. */
	[[nodiscard]] IntegerSetting& getScaleFactorSetting() { return scaleFactorSetting; }
	[[nodiscard]] int getScaleFactor() const { return scaleFactorSetting.getInt(); }

	/** Limit number of sprites per line?
	  * If true, limit number of sprites per line as real VDP does.
	  * If false, display all sprites.
	  * For accurate emulation, this setting should be on.
	  * Turning it off can improve games with a lot of flashing sprites,
	  * such as Aleste. */
	[[nodiscard]] BooleanSetting& getLimitSpritesSetting() { return limitSpritesSetting; }

	/** Disable sprite rendering? */
	[[nodiscard]] BooleanSetting& getDisableSpritesSetting() { return disableSpritesSetting; }
	[[nodiscard]] bool getDisableSprites() const { return disableSpritesSetting.getBoolean(); }

	/** CmdTiming [real, broken].
	  * This setting is intended for debugging only, not for users. */
	[[nodiscard]] EnumSetting<bool>& getCmdTimingSetting() { return cmdTimingSetting; }

	/** TooFastAccess [real, ignored].
	  * Indicates whether too fast VDP VRAM access should be correctly
	  * emulated (= some accesses are dropped) or ignored (= all accesses
	  * are correctly executed). */
	[[nodiscard]] EnumSetting<bool>& getTooFastAccessSetting() { return tooFastAccessSetting; }

	/** Display deformation (normal, 3d). */
	[[nodiscard]] auto& getDisplayDeformSetting() { return displayDeformSetting; }
	[[nodiscard]] DisplayDeform getDisplayDeform() const { return displayDeformSetting.getEnum(); }

	/** VSync [on, off]. */
	[[nodiscard]] BooleanSetting& getVSyncSetting() { return vSyncSetting; }

	[[nodiscard]] BooleanSetting& getFullStretchSetting() { return fullStretchSetting; }
	[[nodiscard]] bool getFullStretch() const { return fullStretchSetting.getBoolean(); }

	/** Amount of horizontal stretch.
	  * This number represents the amount of MSX pixels (normal width) that
	  * will be stretched to the complete width of the host window. */
	[[nodiscard]] FloatSetting& getHorizontalStretchSetting() {
		return horizontalStretchSetting;
	}
	[[nodiscard]] float getHorizontalStretch() const {
		return horizontalStretchSetting.getFloat();
	}

	/** The amount of time until the pointer is hidden in the openMSX
	  * window. negative means: no hiding, 0 means immediately. */
	[[nodiscard]] FloatSetting& getPointerHideDelaySetting() {
		return pointerHideDelaySetting;
	}
	[[nodiscard]] float getPointerHideDelay() const {
		return pointerHideDelaySetting.getFloat();
	}

	/** Is black frame interleaving enabled? */
	[[nodiscard]] bool getInterleaveBlackFrame() const {
		return interleaveBlackFrameSetting.getBoolean();
	}

	/** Apply brightness, contrast and gamma transformation on the input
	  * color component. The component is expected to be in the range
	  * [0.0 .. 1.0] but it's not an error if it lays outside of this range.
	  * The return value is guaranteed to lay inside this range.
	  * This method skips the cross-influence of color components on each
	  * other that is controlled by the "color_matrix" setting.
	  */
	[[nodiscard]] float transformComponent(float c) const;

	/** Apply brightness, contrast and gamma transformation on the input
	  * color. The R, G and B component are expected to be in the range
	  * [0.0 .. 1.0] but it's not an error if a component lays outside of
	  * this range. After transformation it's guaranteed all components
	  * lay inside this range.
	  */
	[[nodiscard]] gl::vec3 transformRGB(gl::vec3 rgb) const;

private:
	[[nodiscard]] static EnumSetting<ScaleAlgorithm>::Map getScalerMap();
	[[nodiscard]] static EnumSetting<RendererID>::Map getRendererMap();

	// Observer:
	void update(const Setting& setting) noexcept override;

	/** Sets the "brightness" and "contrast" fields according to the setting
	  * values.
	  */
	void updateBrightnessAndContrast();

	void parseColorMatrix(Interpreter& interp, const TclObject& value);

private:
	EnumSetting<Accuracy> accuracySetting;
	BooleanSetting deinterlaceSetting;
	BooleanSetting deflickerSetting;
	IntegerSetting maxFrameSkipSetting;
	IntegerSetting minFrameSkipSetting;
	BooleanSetting fullScreenSetting;
	FloatSetting gammaSetting;
	FloatSetting brightnessSetting;
	FloatSetting contrastSetting;
	StringSetting colorMatrixSetting;
	IntegerSetting glowSetting;
	FloatSetting noiseSetting;
	RendererSetting rendererSetting;
	IntegerSetting horizontalBlurSetting;
	EnumSetting<ScaleAlgorithm> scaleAlgorithmSetting;
	IntegerSetting scaleFactorSetting;
	IntegerSetting scanlineAlphaSetting;
	BooleanSetting limitSpritesSetting;
	BooleanSetting disableSpritesSetting;
	EnumSetting<bool> cmdTimingSetting;
	EnumSetting<bool> tooFastAccessSetting;
	EnumSetting<DisplayDeform> displayDeformSetting;
	BooleanSetting vSyncSetting;
	BooleanSetting fullStretchSetting;
	FloatSetting horizontalStretchSetting;
	FloatSetting pointerHideDelaySetting;
	BooleanSetting interleaveBlackFrameSetting;

	float brightness;
	float contrast;

	/** Parsed color matrix, kept in sync with colorMatrix setting. */
	gl::mat3 colorMatrix;
	/** True iff color matrix is identity matrix. */
	bool cmIdentity;
};

} // namespace openmsx

#endif