#ifndef KEYBOARD_HH

#define KEYBOARD_HH

#include "KeyboardSettings.hh"

#include "MSXEventListener.hh"

#include "StateChangeListener.hh"

#include "UnicodeKeymap.hh"

#include "Event.hh"

#include "EventListener.hh"

#include "RecordedCommand.hh"

#include "Schedulable.hh"

#include "SimpleDebuggable.hh"

#include "serialize_meta.hh"

#include <array>

#include <cstdint>

#include <deque>

#include <span>

#include <string_view>

#include <vector>

#if defined(_WIN32)

#ifndef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#endif

#include <windows.h>

#include <imm.h>

#endif // _WIN32

namespace openmsx {

class MSXMotherBoard;

class Scheduler;

class CommandController;

class DeviceConfig;

class EventDistributor;

class MSXEventDistributor;

class StateChangeDistributor;

class TclObject;

class Interpreter;

struct KeyCodeMsxMapping {

	SDL_Keycode hostKeyCode;

	KeyMatrixPosition msx;

};

struct ScanCodeMsxMapping {

	SDL_Scancode hostScanCode;

	KeyMatrixPosition msx;

};

class Keyboard final : private MSXEventListener, private StateChangeListener

                     , private Schedulable, private EventListener

{

public:

	static constexpr int MAX_KEYSYM = 0x150;

	enum class Matrix : uint8_t { MSX, SVI, CVJOY, SEGA, NUM };

	/** Constructs a new Keyboard object.

	 * @param motherBoard ref to the motherBoard

	 * @param scheduler ref to the scheduler

	 * @param commandController ref to the command controller

	 * @param eventDistributor ref to the emu event distributor

	 * @param msxEventDistributor ref to the user input event distributor

	 * @param stateChangeDistributor ref to the state change distributor

	 * @param matrix which system's keyboard matrix to use

	 * @param config ref to the device configuration

	 */

	Keyboard(MSXMotherBoard& motherBoard, Scheduler& scheduler,

	         CommandController& commandController,

	         EventDistributor& eventDistributor,

	         MSXEventDistributor& msxEventDistributor,

	         StateChangeDistributor& stateChangeDistributor,

	         Matrix matrix, const DeviceConfig& config);

	~Keyboard();

	[[nodiscard]] const MsxChar2Unicode& getMsxChar2Unicode() const;

	/** Returns a pointer to the current KeyBoard matrix

	 */

	[[nodiscard]] std::span<const uint8_t, KeyMatrixPosition::NUM_ROWS> getKeys() const;

	void transferHostKeyMatrix(const Keyboard& source);

	void setFocus(bool newFocus, EmuTime time);

	template<typename Archive>

	void serialize(Archive& ar, unsigned version);

private:

	// MSXEventListener

	void signalMSXEvent(const Event& event,

	                    EmuTime time) noexcept override;

	// StateChangeListener

	void signalStateChange(const StateChange& event) override;

	void stopReplay(EmuTime time) noexcept override;

	// Schedulable

	void executeUntil(EmuTime time) override;

	// EventListener

	bool signalEvent(const Event& event) override;

	void syncHostKeyMatrix(EmuTime time);

	/** Returns true iff the given key is currently held down in the MSX

	  * keyboard matrix. Pressing such a key again does not produce a new

	  * key-press edge, so the MSX will not see it as a new key press.

	  */

	[[nodiscard]] bool isKeyMatrixPressed(KeyMatrixPosition pos) const;

	void pressKeyMatrixEvent(EmuTime time, KeyMatrixPosition pos);

	void releaseKeyMatrixEvent(EmuTime time, KeyMatrixPosition pos);

	void changeKeyMatrixEvent (EmuTime time, uint8_t row, uint8_t newValue);

	void processCapslockEvent(EmuTime time, bool down);

	void processCodeKanaChange(EmuTime time, bool down);

	void processGraphChange(EmuTime time, bool down);

	void processKeypadEnterKey(EmuTime time, bool down);

	void processSdlKey(EmuTime time, SDLKey key);

	bool processQueuedEvent(const Event& event, EmuTime time);

	bool processKeyEvent(EmuTime time, bool down, const KeyEvent& keyEvent);

	void updateKeyMatrix(EmuTime time, bool down, KeyMatrixPosition pos);

	void processCmd(Interpreter& interp, std::span<const TclObject> tokens, bool up);

	bool pressUnicodeByUser(

			EmuTime time, UnicodeKeymap::KeyInfo keyInfo, unsigned unicode,

			bool down);

	uint8_t pressAscii(unsigned unicode, bool down);

	void pressLockKeys(uint8_t lockKeysMask, bool down);

	[[nodiscard]] bool commonKeys(unsigned unicode1, unsigned unicode2) const;

	void debug(const char* format, ...) const;

	/** Returns a bit vector in which the bit for a modifier is set iff that

	  * modifier is a lock key and must be toggled before the given key input

	  * can be produced.

	  */

	uint8_t needsLockToggle(const UnicodeKeymap::KeyInfo& keyInfo) const;

private:

	CommandController& commandController;

	MSXEventDistributor& msxEventDistributor;

	StateChangeDistributor& stateChangeDistributor;

	EventDistributor& eventDistributor;

	std::span<const KeyCodeMsxMapping> keyCodeTab;

	std::span<const ScanCodeMsxMapping> scanCodeTab;

	const array_with_enum_index<UnicodeKeymap::KeyInfo::Modifier, KeyMatrixPosition>& modifierPos;

	struct KeyMatrixUpCmd final : RecordedCommand {

		KeyMatrixUpCmd(CommandController& commandController,

			       StateChangeDistributor& stateChangeDistributor,

			       Scheduler& scheduler);

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

			     EmuTime time) override;

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

	} keyMatrixUpCmd;

	struct KeyMatrixDownCmd final : RecordedCommand {

		KeyMatrixDownCmd(CommandController& commandController,

				 StateChangeDistributor& stateChangeDistributor,

				 Scheduler& scheduler);

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

			     EmuTime time) override;

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

	} keyMatrixDownCmd;

	class KeyInserter final : public RecordedCommand, public Schedulable {

	public:

		KeyInserter(CommandController& commandController,

			    StateChangeDistributor& stateChangeDistributor,

			    Scheduler& scheduler);

		[[nodiscard]] bool isActive() const { return isPending().has_value(); }

		template<typename Archive>

		void serialize(Archive& ar, unsigned version);

	private:

		void type(std::string_view str);

		void reschedule(EmuTime time);

		// Command

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

			     EmuTime time) override;

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

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

		// Schedulable

		void executeUntil(EmuTime time) override;

	private:

		std::string text_utf8;

		unsigned last = 0;

		uint8_t lockKeysMask = 0;

		bool releaseLast = false;

		uint8_t oldLocksOn = 0;

		bool releaseBeforePress = false;

		int typingFrequency = 15;

	} keyTypeCmd;

	struct Msxcode2UnicodeCmd final : public Command {

		explicit Msxcode2UnicodeCmd(CommandController& commandController);

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

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

	} msxcode2UnicodeCmd;

	struct Unicode2MsxcodeCmd final : public Command {

		explicit Unicode2MsxcodeCmd(CommandController& commandController);

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

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

	} unicode2MsxcodeCmd;

	class CapsLockAligner final : private EventListener, private Schedulable {

	public:

		CapsLockAligner(EventDistributor& eventDistributor,

				Scheduler& scheduler);

		~CapsLockAligner();

	private:

		// EventListener

		bool signalEvent(const Event& event) override;

		// Schedulable

		void executeUntil(EmuTime time) override;

		void alignCapsLock(EmuTime time);

	private:

		EventDistributor& eventDistributor;

		enum CapsLockAlignerStateType : uint8_t {

			MUST_ALIGN_CAPSLOCK, MUST_DISTRIBUTE_KEY_RELEASE, IDLE

		} state = IDLE;

	} capsLockAligner;

#if defined(_WIN32)

	class ImeManager final : private EventListener {

	public:

		ImeManager(EventDistributor& eventDistributor);

		~ImeManager();

	private:

		// EventListener

		bool signalEvent(const Event& event) override;

	private:

		EventDistributor& eventDistributor;

		HIMC hImc;

	} imeManager;

#endif

	KeyboardSettings keyboardSettings;

	class MsxKeyEventQueue final : public Schedulable {

	public:

		MsxKeyEventQueue(Scheduler& scheduler, Interpreter& interp);

		void process_asap(EmuTime time,

		                  const Event& event);

		void clear();

		template<typename Archive>

		void serialize(Archive& ar, unsigned version);

	private:

		// Schedulable

		void executeUntil(EmuTime time) override;

	private:

		std::deque<Event> eventQueue;

		Interpreter& interp;

	} msxKeyEventQueue;

	struct KeybDebuggable final : SimpleDebuggable {

		explicit KeybDebuggable(MSXMotherBoard& motherBoard);

		[[nodiscard]] uint8_t read(unsigned address) override;

		void write(unsigned address, uint8_t value) override;

		void readBlock(unsigned start, std::span<uint8_t> output) override;

	} keybDebuggable;

	UnicodeKeymap unicodeKeymap;

	// Remembers the last unicode for a key-press-scancode. To be used later

	// on the corresponding key-release, because those don't have unicode info.

	// Since there are keys for which keycodes are not reported, it is not

	// desirable to save them as keycodes.

	// To be able to serialize this, we use int32_t instead of

	// SDL_Scancode, because enums are not serializable

	std::vector<std::pair<int32_t, uint32_t>> lastUnicodeForScancode; // sorted on SDL_Scancode

	static_assert(sizeof(int32_t) >= sizeof(SDL_Scancode), "lastUnicodeForScancode: 1st elm. size error.");

	/** Keyboard matrix state for 'keymatrix' command. */

	std::array<uint8_t, KeyMatrixPosition::NUM_ROWS> cmdKeyMatrix;

	/** Keyboard matrix state for 'type' command. */

	std::array<uint8_t, KeyMatrixPosition::NUM_ROWS> typeKeyMatrix;

	/** Keyboard matrix state for pressed user keys (live or replay). */

	std::array<uint8_t, KeyMatrixPosition::NUM_ROWS> userKeyMatrix;

	/** Keyboard matrix state that is always in sync with host keyb, also during replay. */

	std::array<uint8_t, KeyMatrixPosition::NUM_ROWS> hostKeyMatrix;

	/** Combination of 'cmdKeyMatrix', 'typeKeyMatrix' and 'userKeyMatrix'. */

	mutable std::array<uint8_t, KeyMatrixPosition::NUM_ROWS> keyMatrix;

	uint8_t msxModifiers = 0xff;

	/** True iff keyboard includes a numeric keypad. */

	const bool hasKeypad;

	/** True iff changes to keyboard row 11 must be rejected.

	  * On MSX, row 11 contains the (Japanese) Yes/No keys.

	  */

	const bool blockRow11;

	/** True iff pressing multiple keys at once can add ghost key presses. */

	const bool keyGhosting;

	/** True iff Shift, Graph and Code are protected against key ghosting. */

	const bool keyGhostingSGCprotected;

	/** Bit vector where each modifier's bit (using KeyInfo::Modifier's

	  * numbering) is set iff it is a lock key.

	  */

	const uint8_t modifierIsLock;

	mutable bool keysChanged = false;

	/** Bit vector where each modifier's bit (using KeyInfo::Modifier's

	  * numbering) is set iff it is a lock key that is currently on in

	  * the emulated machine.

	  */

	uint8_t locksOn = 0;

	/*  Countermeasure for missing Release events on Japanese keyboard s*/

	enum class HostKeyMap : uint8_t { UNKNOWN, EN, JP };

	HostKeyMap hostKeyMap = HostKeyMap::UNKNOWN;

	bool focus = true;

};

SERIALIZE_CLASS_VERSION(Keyboard, 5);

} // namespace openmsx

#endif