#include "SDLKey.hh"
#include "StringOp.hh"
#include "one_of.hh"
#include "ranges.hh"
#include <array>

namespace openmsx {

// We prefer to use 'SDL_GetKeyFromName()' to translate a name into a Keycode.
// That way when new keys are added to SDL2, these immediately work in openMSX.
// In the past we had our own mapping, and to keep backwards compatible (e.g.
// because key-names can end up in settings.xml) we retain (part of) that old
// mapping.
static SDL_Keycode getKeyFromOldOpenmsxName(std::string_view name)
{
	// These (old) openMSX names are the same in SDL2. Except for
	// capitalization (e.g. "PAGEUP" vs "PageUp"), but we anyway
	// do a case-insensitive search.
	// "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
	// "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
	// "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
	// "RETURN", "ESCAPE", "BACKSPACE", "TAB", "SPACE", "CAPSLOCK",
	// "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9",
	// "F10", "F11", "F12", "F13", "F14", "F15", "F16", "F17",
	// "F18", "F19", "F20", "F21", "F22", "F23", "F24",
	// "SCROLLLOCK", "PAUSE", "INSERT", "HOME", "PAGEUP", "DELETE",
	// "END", "PAGEDOWN", "RIGHT", "LEFT", "DOWN", "UP", "NUMLOCK",
	// "POWER", "HELP", "MENU", "UNDO", "SYSREQ", "CLEAR",

	// For these (old) openMSX names it's not clear which SDL2 keycode
	// corresponds to it. So, at least for now, these are no longer
	// supported.
	// "BACK", "ZENKAKU_HENKAKU", "MUHENKAN", "HENKAN_MODE", "HIRAGANA_KATAKANA",

	struct M {
		std::string_view name;
		SDL_Keycode code;
	};
	static constexpr std::array unsortedMap = {
		// Old openMSX name, SDL-key-code, new SDL2 name
		M{"EXCLAIM",     SDLK_EXCLAIM},     // !
		M{"QUOTEDBL",    SDLK_QUOTEDBL},    // "
		M{"HASH",        SDLK_HASH},        // #
		M{"DOLLAR",      SDLK_DOLLAR},      // $
		M{"AMPERSAND",   SDLK_AMPERSAND},   // &
		M{"QUOTE",       SDLK_QUOTE},       // '
		M{"LEFTPAREN",   SDLK_LEFTPAREN},   // (
		M{"RIGHTPAREN",  SDLK_RIGHTPAREN},  // )
		M{"ASTERISK",    SDLK_ASTERISK},    // *
		M{"PLUS",        SDLK_PLUS},        // +
		M{"COMMA",       SDLK_COMMA},       // ,
		M{"MINUS",       SDLK_MINUS},       // -
		M{"PERIOD",      SDLK_PERIOD},      // .
		M{"SLASH",       SDLK_SLASH},       // /
		M{"COLON",       SDLK_COLON},       // :
		M{"SEMICOLON",   SDLK_SEMICOLON},   // ;
		M{"LESS",        SDLK_LESS},        // <
		M{"EQUALS",      SDLK_EQUALS},      // =
		M{"GREATER",     SDLK_GREATER},     // >
		M{"QUESTION",    SDLK_QUESTION},    // ?
		M{"AT",          SDLK_AT},          // @
		M{"LEFTBRACKET", SDLK_LEFTBRACKET}, // [
		M{"BACKSLASH",   SDLK_BACKSLASH},   //
		M{"RIGHTBRACKET",SDLK_RIGHTBRACKET},// ]
		M{"CARET",       SDLK_CARET},       // ^
		M{"UNDERSCORE",  SDLK_UNDERSCORE},  // _
		M{"BACKQUOTE",   SDLK_BACKQUOTE},   // `
		M{"PRINT",       SDLK_PRINTSCREEN}, // PrintScreen
		M{"SCROLLOCK",   SDLK_SCROLLLOCK},  // ScrollLock   backwards compat for typo
		M{"KP_DIVIDE",   SDLK_KP_DIVIDE},   // Keypad /
		M{"KP_MULTIPLY", SDLK_KP_MULTIPLY}, // Keypad *
		M{"KP_MINUS",    SDLK_KP_MINUS},    // Keypad -
		M{"KP_PLUS",     SDLK_KP_PLUS},     // Keypad +
		M{"KP_ENTER",    SDLK_KP_ENTER},    // Keypad Enter
		M{"KP0",         SDLK_KP_0},        // Keypad 0
		M{"KP1",         SDLK_KP_1},        // Keypad 1
		M{"KP2",         SDLK_KP_2},        // Keypad 2
		M{"KP3",         SDLK_KP_3},        // Keypad 3
		M{"KP4",         SDLK_KP_4},        // Keypad 4
		M{"KP5",         SDLK_KP_5},        // Keypad 5
		M{"KP6",         SDLK_KP_6},        // Keypad 6
		M{"KP7",         SDLK_KP_7},        // Keypad 7
		M{"KP8",         SDLK_KP_8},        // Keypad 8
		M{"KP9",         SDLK_KP_9},        // Keypad 9
		M{"KP_PERIOD",   SDLK_KP_PERIOD},   // Keypad .
		M{"KP_EQUALS",   SDLK_KP_EQUALS},   // Keypad =
		M{"LCTRL",       SDLK_LCTRL},       // Left Ctrl
		M{"LSHIFT",      SDLK_LSHIFT},      // Left Shift
		M{"LALT",        SDLK_LALT},        // Left Alt
		M{"LSUPER",      SDLK_LGUI},        // Left GUI     Left "Windows" key
		M{"RCTRL",       SDLK_RCTRL},       // Right Ctrl
		M{"RSHIFT",      SDLK_RSHIFT},      // Right Shift
		M{"RALT",        SDLK_RALT},        // Right Alt
		M{"RSUPER",      SDLK_RGUI},        // Right GUI    Right "Windows" key
		M{"RMODE",       SDLK_MODE},        // ModeSwitch   "Alt Gr" key
	};
	static constexpr auto map = []{
		auto result = unsortedMap;
		ranges::sort(result, {}, &M::name);
		return result;
	}();

	if (const auto* p = binary_find(map, name, StringOp::caseless{}, &M::name)) {
		return p->code;
	}
	return SDLK_UNKNOWN;
}

SDL_Keycode SDLKey::keycodeFromString(zstring_view name)
{
	auto result = SDL_GetKeyFromName(name.c_str());
	if (result == SDLK_UNKNOWN) {
		// for backwards compatibility
		result = getKeyFromOldOpenmsxName(name);
	}
	return result;
}

std::optional<SDLKey> SDLKey::fromString(std::string_view name)
{
	// Some remarks:
	//
	// SDL2 offers the following function to convert a string to a
	// SDL_Keycode.
	//     SDL_Keycode SDL_GetKeyFromName(const char* name)
	// This works for all keys known to SDL2. Meaning we don't have to
	// maintain our own string->key mapping in openMSX.
	//
	// In the past we did have our own mapping. And unfortunately our
	// mapping was not exactly the same as the (new) SDL2 mapping. Some
	// examples:
	//   We named the '=' key "EQUALS". The SDL2 name is simply "=".
	//   We named the '1' on the numeric keypad "KP1", the SDL2 name is "Keypad 1".
	//   Our name "RCTRL" is "Right Ctrl" in SDL2.
	//   Our name "ESCAPE" is "Escape" in SDL2 (different capitalization).
	//   ...
	// (IMHO) The SDL2 names are better (and much more complete), but to
	// maintain backwards compatibility we keep a list of (old) names (for
	// some keys).
	//
	// The 'SDL_GetKeyFromName() function' is only concerned with naming a
	// single key. In openMSX we also want to name key combinations like
	// "A+CTRL" (a single key combined with one or more modifiers). Or
	// "A,Release" to distinguish a key-press from a release. This function
	// extends the SDL2 function to also parse these such annotations.
	//
	// One complication of these annotations are the separator characters
	// between the base-key and the annotations. OpenMSX interprets these
	// three characters as separators:
	//    ,   +   /
	// Unfortunately these three characters can also appear in the new SDL2
	// names. For example:
	//    Keypad ,    Keypad +    Keypad /
	//    or simply ,    +    /
	// Luckily these characters only(?) appear as the last character in the
	// base name, so we can extend our parser to correctly recognize stuff
	// like:
	//     ++CTRL    ,+SHIFT   Keypad /,Release    Shift++

	SDLKey result = {};
	result.sym.scancode = SDL_SCANCODE_UNKNOWN;
	result.sym.sym = SDLK_UNKNOWN;
	result.sym.mod = KMOD_NONE;
	result.sym.unused = 0; // unicode
	result.down = true;

	while (!name.empty()) {
		std::string_view part = [&] {
			auto pos = name.find_first_of(",+/");
			if (pos == std::string_view::npos) {
				// no separator character
				return std::exchange(name, std::string_view{});
			} else if ((pos + 1) == name.size()) {
				// ends with a separator, assume it's part of the name
				return std::exchange(name, std::string_view{});
			} else {
				if (name[pos + 1] == one_of(',', '+', '/')) {
					// next character is also a separator, assume
					// the character at 'pos' is part of the name
					++pos;
				}
				auto r = name.substr(0, pos);
				name.remove_prefix(pos + 1);
				return r;
			}
		}();

		StringOp::casecmp cmp;
		if (cmp(part, "SHIFT")) {
			result.sym.mod |= KMOD_SHIFT;
		} else if (cmp(part, "CTRL")) {
			result.sym.mod |= KMOD_CTRL;
		} else if (cmp(part, "ALT")) {
			result.sym.mod |= KMOD_ALT;
		} else if (cmp(part, "GUI") ||
		           cmp(part, "META")) { // bw-compat
			result.sym.mod |= KMOD_GUI;
		} else if (cmp(part, "MODE")) {
			result.sym.mod |= KMOD_MODE;

		} else if (cmp(part, "PRESS")) {
			result.down = true;
		} else if (cmp(part, "RELEASE")) {
			result.down = false;

		} else {
			if (result.sym.sym != SDLK_UNKNOWN) {
				// more than one non-modifier component is not allowed
				return {};
			}
			result.sym.sym = keycodeFromString(std::string(part));
			if (result.sym.sym == SDLK_UNKNOWN) {
				return {};
			}
		}
	}
	if (result.sym.sym == SDLK_UNKNOWN) {
		return {};
	}
	return result;
}

std::string SDLKey::toString(SDL_Keycode code)
{
	std::string result = SDL_GetKeyName(code);
	if (result.empty()) result = "unknown";
	return result;
}

std::string SDLKey::toString() const
{
	std::string result = toString(sym.sym);
	if (sym.mod & KMOD_CTRL) {
		result += "+CTRL";
	}
	if (sym.mod & KMOD_SHIFT) {
		result += "+SHIFT";
	}
	if (sym.mod & KMOD_ALT) {
		result += "+ALT";
	}
	if (sym.mod & KMOD_GUI) {
		result += "+GUI";
	}
	if (sym.mod & KMOD_MODE) {
		result += "+MODE";
	}
	if (!down) {
		result += ",RELEASE";
	}
	return result;
}

} // namespace openmsx
