/*
 * @Author: DI JUNKUN
 * @Date: 2024-11-25
 * Copyright (c) 2024 by DI JUNKUN, All Rights Reserved.
 */

#ifndef _KEYBOARD_CONVERTER_H_
#define _KEYBOARD_CONVERTER_H_

#include <map>

// Windows vkCode to macOS CGKeyCode (104 keys)
std::map<int, int> vkCodeToCGKeyCode = {
    // A-Z
    {0x41, 0x00},  // A
    {0x42, 0x0B},  // B
    {0x43, 0x08},  // C
    {0x44, 0x02},  // D
    {0x45, 0x0E},  // E
    {0x46, 0x03},  // F
    {0x47, 0x05},  // G
    {0x48, 0x04},  // H
    {0x49, 0x22},  // I
    {0x4A, 0x26},  // J
    {0x4B, 0x28},  // K
    {0x4C, 0x25},  // L
    {0x4D, 0x2E},  // M
    {0x4E, 0x2D},  // N
    {0x4F, 0x1F},  // O
    {0x50, 0x23},  // P
    {0x51, 0x0C},  // Q
    {0x52, 0x0F},  // R
    {0x53, 0x01},  // S
    {0x54, 0x11},  // T
    {0x55, 0x20},  // U
    {0x56, 0x09},  // V
    {0x57, 0x0D},  // W
    {0x58, 0x07},  // X
    {0x59, 0x10},  // Y
    {0x5A, 0x06},  // Z

    // 0-9
    {0x30, 0x1D},  // 0
    {0x31, 0x12},  // 1
    {0x32, 0x13},  // 2
    {0x33, 0x14},  // 3
    {0x34, 0x15},  // 4
    {0x35, 0x17},  // 5
    {0x36, 0x16},  // 6
    {0x37, 0x1A},  // 7
    {0x38, 0x1C},  // 8
    {0x39, 0x19},  // 9

    // F1-F12
    {0x70, 0x7A},  // F1
    {0x71, 0x78},  // F2
    {0x72, 0x63},  // F3
    {0x73, 0x76},  // F4
    {0x74, 0x60},  // F5
    {0x75, 0x61},  // F6
    {0x76, 0x62},  // F7
    {0x77, 0x64},  // F8
    {0x78, 0x65},  // F9
    {0x79, 0x6D},  // F10
    {0x7A, 0x67},  // F11
    {0x7B, 0x6F},  // F12

    // control keys
    {0x1B, 0x35},  // Escape
    {0x0D, 0x24},  // Enter
    {0x20, 0x31},  // Space
    {0x08, 0x33},  // Backspace
    {0x09, 0x30},  // Tab
    {0x2C, 0x74},  // Print Screen
    {0x2D, 0x72},  // Insert
    {0x2E, 0x75},  // Delete
    {0x24, 0x73},  // Home
    {0x23, 0x77},  // End
    {0x21, 0x79},  // Page Up
    {0x22, 0x7A},  // Page Down

    // arrow keys
    {0x25, 0x7B},  // Left Arrow
    {0x27, 0x7C},  // Right Arrow
    {0x26, 0x7E},  // Up Arrow
    {0x28, 0x7D},  // Down Arrow

    // numpad
    {0x60, 0x52},  // Numpad 0
    {0x61, 0x53},  // Numpad 1
    {0x62, 0x54},  // Numpad 2
    {0x63, 0x55},  // Numpad 3
    {0x64, 0x56},  // Numpad 4
    {0x65, 0x57},  // Numpad 5
    {0x66, 0x58},  // Numpad 6
    {0x67, 0x59},  // Numpad 7
    {0x68, 0x5B},  // Numpad 8
    {0x69, 0x5C},  // Numpad 9
    {0x6E, 0x41},  // Numpad .
    {0x6F, 0x4B},  // Numpad /
    {0x6A, 0x43},  // Numpad *
    {0x6D, 0x4E},  // Numpad -
    {0x6B, 0x45},  // Numpad +

    // symbol keys
    {0xBA, 0x29},  // ; (Semicolon)
    {0xDE, 0x27},  // ' (Quote)
    {0xC0, 0x32},  // ` (Backtick)
    {0xBC, 0x2B},  // , (Comma)
    {0xBE, 0x2F},  // . (Period)
    {0xBF, 0x2C},  // / (Slash)
    {0xDC, 0x2A},  // \ (Backslash)
    {0xDB, 0x21},  // [ (Left Bracket)
    {0xDD, 0x1E},  // ] (Right Bracket)
    {0xBD, 0x1B},  // - (Minus)
    {0xBB, 0x18},  // = (Equals)

    // modifier keys
    {0x14, 0x39},  // Caps Lock
    {0xA0, 0x38},  // Shift (Left)
    {0xA1, 0x3C},  // Shift (Right)
    {0xA2, 0x3B},  // Ctrl (Left)
    {0xA3, 0x3E},  // Ctrl (Right)
    {0xA4, 0x3A},  // Alt (Left)
    {0xA5, 0x3D},  // Alt (Right)
    {0x5B, 0x37},  // Left Command (Windows key)
    {0x5C, 0x36},  // Right Command
};

// macOS CGKeyCode to Windows vkCode
std::map<int, int> CGKeyCodeToVkCode = {
    // A-Z
    {0x00, 0x41},  // A
    {0x0B, 0x42},  // B
    {0x08, 0x43},  // C
    {0x02, 0x44},  // D
    {0x0E, 0x45},  // E
    {0x03, 0x46},  // F
    {0x05, 0x47},  // G
    {0x04, 0x48},  // H
    {0x22, 0x49},  // I
    {0x26, 0x4A},  // J
    {0x28, 0x4B},  // K
    {0x25, 0x4C},  // L
    {0x2E, 0x4D},  // M
    {0x2D, 0x4E},  // N
    {0x1F, 0x4F},  // O
    {0x23, 0x50},  // P
    {0x0C, 0x51},  // Q
    {0x0F, 0x52},  // R
    {0x01, 0x53},  // S
    {0x11, 0x54},  // T
    {0x20, 0x55},  // U
    {0x09, 0x56},  // V
    {0x0D, 0x57},  // W
    {0x07, 0x58},  // X
    {0x10, 0x59},  // Y
    {0x06, 0x5A},  // Z

    // 0-9
    {0x1D, 0x30},  // 0
    {0x12, 0x31},  // 1
    {0x13, 0x32},  // 2
    {0x14, 0x33},  // 3
    {0x15, 0x34},  // 4
    {0x17, 0x35},  // 5
    {0x16, 0x36},  // 6
    {0x1A, 0x37},  // 7
    {0x1C, 0x38},  // 8
    {0x19, 0x39},  // 9

    // F1-F12
    {0x7A, 0x70},  // F1
    {0x78, 0x71},  // F2
    {0x63, 0x72},  // F3
    {0x76, 0x73},  // F4
    {0x60, 0x74},  // F5
    {0x61, 0x75},  // F6
    {0x62, 0x76},  // F7
    {0x64, 0x77},  // F8
    {0x65, 0x78},  // F9
    {0x6D, 0x79},  // F10
    {0x67, 0x7A},  // F11
    {0x6F, 0x7B},  // F12

    // control keys
    {0x35, 0x1B},  // Escape
    {0x24, 0x0D},  // Enter
    {0x31, 0x20},  // Space
    {0x33, 0x08},  // Backspace
    {0x30, 0x09},  // Tab
    {0x74, 0x2C},  // Print Screen
    {0x72, 0x2D},  // Insert
    {0x75, 0x2E},  // Delete
    {0x73, 0x24},  // Home
    {0x77, 0x23},  // End
    {0x79, 0x21},  // Page Up
    {0x7A, 0x22},  // Page Down

    // arrow keys
    {0x7B, 0x25},  // Left Arrow
    {0x7C, 0x27},  // Right Arrow
    {0x7E, 0x26},  // Up Arrow
    {0x7D, 0x28},  // Down Arrow

    // numpad
    {0x52, 0x60},  // Numpad 0
    {0x53, 0x61},  // Numpad 1
    {0x54, 0x62},  // Numpad 2
    {0x55, 0x63},  // Numpad 3
    {0x56, 0x64},  // Numpad 4
    {0x57, 0x65},  // Numpad 5
    {0x58, 0x66},  // Numpad 6
    {0x59, 0x67},  // Numpad 7
    {0x5B, 0x68},  // Numpad 8
    {0x5C, 0x69},  // Numpad 9
    {0x41, 0x6E},  // Numpad .
    {0x4B, 0x6F},  // Numpad /
    {0x43, 0x6A},  // Numpad *
    {0x4E, 0x6D},  // Numpad -
    {0x45, 0x6B},  // Numpad +

    // symbol keys
    {0x29, 0xBA},  // ; (Semicolon)
    {0x27, 0xDE},  // ' (Quote)
    {0x32, 0xC0},  // ` (Backtick)
    {0x2B, 0xBC},  // , (Comma)
    {0x2F, 0xBE},  // . (Period)
    {0x2C, 0xBF},  // / (Slash)
    {0x2A, 0xDC},  // \ (Backslash)
    {0x21, 0xDB},  // [ (Left Bracket)
    {0x1E, 0xDD},  // ] (Right Bracket)
    {0x1B, 0xBD},  // - (Minus)
    {0x18, 0xBB},  // = (Equals)

    // modifier keys
    {0x39, 0x14},  // Caps Lock
    {0x38, 0xA0},  // Shift (Left)
    {0x3C, 0xA1},  // Shift (Right)
    {0x3B, 0xA2},  // Control (Left)
    {0x3E, 0xA3},  // Control (Right)
    {0x3A, 0xA4},  // Alt (Left)
    {0x3D, 0xA5},  // Alt (Right)
    {0x37, 0x5B},  // Left Command (Windows key)
    {0x36, 0x5C},  // Right Command
};

// Windows vkCode to X11 KeySym
std::map<int, int> vkCodeToX11KeySym = {
    // A-Z
    {0x41, 0x0041},  // A
    {0x42, 0x0042},  // B
    {0x43, 0x0043},  // C
    {0x44, 0x0044},  // D
    {0x45, 0x0045},  // E
    {0x46, 0x0046},  // F
    {0x47, 0x0047},  // G
    {0x48, 0x0048},  // H
    {0x49, 0x0049},  // I
    {0x4A, 0x004A},  // J
    {0x4B, 0x004B},  // K
    {0x4C, 0x004C},  // L
    {0x4D, 0x004D},  // M
    {0x4E, 0x004E},  // N
    {0x4F, 0x004F},  // O
    {0x50, 0x0050},  // P
    {0x51, 0x0051},  // Q
    {0x52, 0x0052},  // R
    {0x53, 0x0053},  // S
    {0x54, 0x0054},  // T
    {0x55, 0x0055},  // U
    {0x56, 0x0056},  // V
    {0x57, 0x0057},  // W
    {0x58, 0x0058},  // X
    {0x59, 0x0059},  // Y
    {0x5A, 0x005A},  // Z

    // 0-9
    {0x30, 0x0030},  // 0
    {0x31, 0x0031},  // 1
    {0x32, 0x0032},  // 2
    {0x33, 0x0033},  // 3
    {0x34, 0x0034},  // 4
    {0x35, 0x0035},  // 5
    {0x36, 0x0036},  // 6
    {0x37, 0x0037},  // 7
    {0x38, 0x0038},  // 8
    {0x39, 0x0039},  // 9

    // F1-F12
    {0x70, 0xFFBE},  // F1
    {0x71, 0xFFBF},  // F2
    {0x72, 0xFFC0},  // F3
    {0x73, 0xFFC1},  // F4
    {0x74, 0xFFC2},  // F5
    {0x75, 0xFFC3},  // F6
    {0x76, 0xFFC4},  // F7
    {0x77, 0xFFC5},  // F8
    {0x78, 0xFFC6},  // F9
    {0x79, 0xFFC7},  // F10
    {0x7A, 0xFFC8},  // F11
    {0x7B, 0xFFC9},  // F12

    // control keys
    {0x1B, 0xFF1B},  // Escape
    {0x0D, 0xFF0D},  // Enter
    {0x20, 0x0020},  // Space
    {0x08, 0xFF08},  // Backspace
    {0x09, 0xFF09},  // Tab
    {0x2C, 0xFF15},  // Print Screen
    {0x91, 0xFF14},  // Scroll Lock
    {0x13, 0xFF13},  // Pause/Break
    {0x2D, 0xFF63},  // Insert
    {0x2E, 0xFFFF},  // Delete
    {0x24, 0xFF50},  // Home
    {0x23, 0xFF57},  // End
    {0x21, 0xFF55},  // Page Up
    {0x22, 0xFF56},  // Page Down

    // arrow keys
    {0x25, 0xFF51},  // Left Arrow
    {0x27, 0xFF53},  // Right Arrow
    {0x26, 0xFF52},  // Up Arrow
    {0x28, 0xFF54},  // Down Arrow

    // numpad
    {0x60, 0x0030},  // Numpad 0
    {0x61, 0x0031},  // Numpad 1
    {0x62, 0x0032},  // Numpad 2
    {0x63, 0x0033},  // Numpad 3
    {0x64, 0x0034},  // Numpad 4
    {0x65, 0x0035},  // Numpad 5
    {0x66, 0x0036},  // Numpad 6
    {0x67, 0x0037},  // Numpad 7
    {0x68, 0x0038},  // Numpad 8
    {0x69, 0x0039},  // Numpad 9
    {0x6E, 0x003A},  // Numpad .
    {0x6F, 0x002F},  // Numpad /
    {0x6A, 0x002A},  // Numpad *
    {0x6D, 0x002D},  // Numpad -
    {0x6B, 0x002B},  // Numpad +

    // symbol keys
    {0xBA, 0x003B},  // ; (Semicolon)
    {0xDE, 0x0027},  // ' (Quote)
    {0xC0, 0x007E},  // ` (Grave)
    {0xBC, 0x002C},  // , (Comma)
    {0xBE, 0x002E},  // . (Period)
    {0xBF, 0x002F},  // / (Slash)
    {0xDC, 0x005C},  // \ (Backslash)
    {0xDB, 0x005B},  // [ (Left Bracket)
    {0xDD, 0x005D},  // ] (Right Bracket)
    {0xBD, 0x002D},  // - (Minus)
    {0xBB, 0x003D},  // = (Equals)

    // modifier keys
    {0x14, 0xFFE5},  // Caps Lock
    {0xA0, 0xFFE1},  // Shift (Left)
    {0xA1, 0xFFE2},  // Shift (Right)
    {0xA2, 0xFFE3},  // Ctrl (Left)
    {0xA3, 0xFFE4},  // Ctrl (Right)
    {0xA4, 0xFFE9},  // Alt (Left)
    {0xA5, 0xFFEA},  // Alt (Right)
    {0x5B, 0xFFEB},  // Left Command (Windows key)
    {0x5C, 0xFFEC},  // Right Command
};

// X11 KeySym to Windows vkCode
// std::map<int, int> x11KeySymToVkCode = []() {
//   std::map<int, int> result;
//   for (const auto& pair : vkCodeToX11KeySym) {
//     result[pair.second] = pair.first;
//   }
//   return result;
// }();

std::map<int, int> x11KeySymToVkCode = {
    // A-Z
    {0x0041, 0x41},  // A
    {0x0042, 0x42},  // B
    {0x0043, 0x43},  // C
    {0x0044, 0x44},  // D
    {0x0045, 0x45},  // E
    {0x0046, 0x46},  // F
    {0x0047, 0x47},  // G
    {0x0048, 0x48},  // H
    {0x0049, 0x49},  // I
    {0x004A, 0x4A},  // J
    {0x004B, 0x4B},  // K
    {0x004C, 0x4C},  // L
    {0x004D, 0x4D},  // M
    {0x004E, 0x4E},  // N
    {0x004F, 0x4F},  // O
    {0x0050, 0x50},  // P
    {0x0051, 0x51},  // Q
    {0x0052, 0x52},  // R
    {0x0053, 0x53},  // S
    {0x0054, 0x54},  // T
    {0x0055, 0x55},  // U
    {0x0056, 0x56},  // V
    {0x0057, 0x57},  // W
    {0x0058, 0x58},  // X
    {0x0059, 0x59},  // Y
    {0x005A, 0x5A},  // Z

    // 0-9
    {0x0030, 0x30},  // 0
    {0x0031, 0x31},  // 1
    {0x0032, 0x32},  // 2
    {0x0033, 0x33},  // 3
    {0x0034, 0x34},  // 4
    {0x0035, 0x35},  // 5
    {0x0036, 0x36},  // 6
    {0x0037, 0x37},  // 7
    {0x0038, 0x38},  // 8
    {0x0039, 0x39},  // 9

    // F1-F12
    {0xFFBE, 0x70},  // F1
    {0xFFBF, 0x71},  // F2
    {0xFFC0, 0x72},  // F3
    {0xFFC1, 0x73},  // F4
    {0xFFC2, 0x74},  // F5
    {0xFFC3, 0x75},  // F6
    {0xFFC4, 0x76},  // F7
    {0xFFC5, 0x77},  // F8
    {0xFFC6, 0x78},  // F9
    {0xFFC7, 0x79},  // F10
    {0xFFC8, 0x7A},  // F11
    {0xFFC9, 0x7B},  // F12

    // control keys
    {0xFF1B, 0x1B},  // Escape
    {0xFF0D, 0x0D},  // Enter
    {0x0020, 0x20},  // Space
    {0xFF08, 0x08},  // Backspace
    {0xFF09, 0x09},  // Tab
    {0xFF15, 0x2C},  // Print Screen
    {0xFF14, 0x91},  // Scroll Lock
    {0xFF13, 0x13},  // Pause/Break
    {0xFF63, 0x2D},  // Insert
    {0xFFFF, 0x2E},  // Delete
    {0xFF50, 0x24},  // Home
    {0xFF57, 0x23},  // End
    {0xFF55, 0x21},  // Page Up
    {0xFF56, 0x22},  // Page Down

    // arrow keys
    {0xFF51, 0x25},  // Left Arrow
    {0xFF53, 0x27},  // Right Arrow
    {0xFF52, 0x26},  // Up Arrow
    {0xFF54, 0x28},  // Down Arrow

    // numpad
    {0x0030, 0x60},  // Numpad 0
    {0x0031, 0x61},  // Numpad 1
    {0x0032, 0x62},  // Numpad 2
    {0x0033, 0x63},  // Numpad 3
    {0x0034, 0x64},  // Numpad 4
    {0x0035, 0x65},  // Numpad 5
    {0x0036, 0x66},  // Numpad 6
    {0x0037, 0x67},  // Numpad 7
    {0x0038, 0x68},  // Numpad 8
    {0x0039, 0x69},  // Numpad 9
    {0x003A, 0x6E},  // Numpad .
    {0x002F, 0x6F},  // Numpad /
    {0x002A, 0x6A},  // Numpad *
    {0x002D, 0x6D},  // Numpad -
    {0x002B, 0x6B},  // Numpad +

    // symbol keys
    {0x003B, 0xBA},  // ; (Semicolon)
    {0x0027, 0xDE},  // ' (Quote)
    {0x007E, 0xC0},  // ` (Grave)
    {0x002C, 0xBC},  // , (Comma)
    {0x002E, 0xBE},  // . (Period)
    {0x002F, 0xBF},  // / (Slash)
    {0x005C, 0xDC},  // \ (Backslash)
    {0x005B, 0xDB},  // [ (Left Bracket)
    {0x005D, 0xDD},  // ] (Right Bracket)
    {0x002D, 0xBD},  // - (Minus)
    {0x003D, 0xBB},  // = (Equals)

    // modifier keys
    {0xFFE5, 0x14},  // Caps Lock
    {0xFFE1, 0xA0},  // Shift (Left)
    {0xFFE2, 0xA1},  // Shift (Right)
    {0xFFE3, 0xA2},  // Ctrl (Left)
    {0xFFE4, 0xA3},  // Ctrl (Right)
    {0xFFE9, 0xA4},  // Alt (Left)
    {0xFFEA, 0xA5},  // Alt (Right)
    {0xFFEB, 0x5B},  // Left Command (Windows key)
    {0xFFEC, 0x5C},  // Right Command
};

// macOS CGKeyCode to X11 KeySym
std::map<int, int> cgKeyCodeToX11KeySym = {
    // A-Z
    {0x00, 0x0041},  // A
    {0x0B, 0x0042},  // B
    {0x08, 0x0043},  // C
    {0x02, 0x0044},  // D
    {0x0E, 0x0045},  // E
    {0x03, 0x0046},  // F
    {0x05, 0x0047},  // G
    {0x04, 0x0048},  // H
    {0x22, 0x0049},  // I
    {0x26, 0x004A},  // J
    {0x28, 0x004B},  // K
    {0x25, 0x004C},  // L
    {0x2E, 0x004D},  // M
    {0x2D, 0x004E},  // N
    {0x1F, 0x004F},  // O
    {0x23, 0x0050},  // P
    {0x0C, 0x0051},  // Q
    {0x0F, 0x0052},  // R
    {0x01, 0x0053},  // S
    {0x11, 0x0054},  // T
    {0x20, 0x0055},  // U
    {0x09, 0x0056},  // V
    {0x0D, 0x0057},  // W
    {0x07, 0x0058},  // X
    {0x10, 0x0059},  // Y
    {0x06, 0x005A},  // Z

    // 0-9
    {0x1D, 0x0030},  // 0
    {0x12, 0x0031},  // 1
    {0x13, 0x0032},  // 2
    {0x14, 0x0033},  // 3
    {0x15, 0x0034},  // 4
    {0x17, 0x0035},  // 5
    {0x16, 0x0036},  // 6
    {0x1A, 0x0037},  // 7
    {0x1C, 0x0038},  // 8
    {0x19, 0x0039},  // 9

    // F1-F12
    {0x7A, 0xFFBE},  // F1
    {0x78, 0xFFBF},  // F2
    {0x63, 0xFFC0},  // F3
    {0x76, 0xFFC1},  // F4
    {0x60, 0xFFC2},  // F5
    {0x61, 0xFFC3},  // F6
    {0x62, 0xFFC4},  // F7
    {0x64, 0xFFC5},  // F8
    {0x65, 0xFFC6},  // F9
    {0x6D, 0xFFC7},  // F10
    {0x67, 0xFFC8},  // F11
    {0x6F, 0xFFC9},  // F12

    // control keys
    {0x35, 0xFF1B},  // Escape
    {0x24, 0xFF0D},  // Enter
    {0x31, 0x0020},  // Space
    {0x33, 0xFF08},  // Backspace
    {0x30, 0xFF09},  // Tab
    {0x74, 0xFF15},  // Print Screen
    {0x72, 0xFF63},  // Insert
    {0x75, 0xFFFF},  // Delete
    {0x73, 0xFF50},  // Home
    {0x77, 0xFF57},  // End
    {0x79, 0xFF55},  // Page Up
    {0x7A, 0xFF56},  // Page Down

    // arrow keys
    {0x7B, 0xFF51},  // Left Arrow
    {0x7C, 0xFF53},  // Right Arrow
    {0x7E, 0xFF52},  // Up Arrow
    {0x7D, 0xFF54},  // Down Arrow

    // numpad
    {0x52, 0x0030},  // Numpad 0
    {0x53, 0x0031},  // Numpad 1
    {0x54, 0x0032},  // Numpad 2
    {0x55, 0x0033},  // Numpad 3
    {0x56, 0x0034},  // Numpad 4
    {0x57, 0x0035},  // Numpad 5
    {0x58, 0x0036},  // Numpad 6
    {0x59, 0x0037},  // Numpad 7
    {0x5B, 0x0038},  // Numpad 8
    {0x5C, 0x0039},  // Numpad 9
    {0x41, 0x003A},  // Numpad .
    {0x4B, 0x002F},  // Numpad /
    {0x43, 0x002A},  // Numpad *
    {0x4E, 0x002D},  // Numpad -
    {0x45, 0x002B},  // Numpad +

    // symbol keys
    {0x29, 0x003B},  // ; (Semicolon)
    {0x27, 0x0027},  // ' (Quote)
    {0x32, 0x007E},  // ` (Backtick)
    {0x2B, 0x002C},  // , (Comma)
    {0x2F, 0x002E},  // . (Period)
    {0x2C, 0x002F},  // / (Slash)
    {0x2A, 0x005C},  // \ (Backslash)
    {0x21, 0x005B},  // [ (Left Bracket)
    {0x1E, 0x005D},  // ] (Right Bracket)
    {0x1B, 0x002D},  // - (Minus)
    {0x18, 0x003D},  // = (Equals)

    // modifier keys
    {0x39, 0xFFE5},  // Caps Lock
    {0x38, 0xFFE1},  // Shift (Left)
    {0x3C, 0xFFE2},  // Shift (Right)
    {0x3B, 0xFFE3},  // Control (Left)
    {0x3E, 0xFFE4},  // Control (Right)
    {0x3A, 0xFFE9},  // Alt (Left)
    {0x3D, 0xFFEA},  // Alt (Right)
    {0x37, 0xFFEB},  // Left Command (Windows key)
    {0x36, 0xFFEC},  // Right Command
};

// X11 KeySym to macOS CGKeyCode
// std::map<int, int> x11KeySymToCgKeyCode = []() {
//   std::map<int, int> result;
//   for (const auto& pair : cgKeyCodeToX11KeySym) {
//     result[pair.second] = pair.first;
//   }
//   return result;
// }();

std::map<int, int> x11KeySymToCgKeyCode = {
    // A-Z
    {0x0041, 0x00},  // A
    {0x0042, 0x0B},  // B
    {0x0043, 0x08},  // C
    {0x0044, 0x02},  // D
    {0x0045, 0x0E},  // E
    {0x0046, 0x03},  // F
    {0x0047, 0x05},  // G
    {0x0048, 0x04},  // H
    {0x0049, 0x22},  // I
    {0x004A, 0x26},  // J
    {0x004B, 0x28},  // K
    {0x004C, 0x25},  // L
    {0x004D, 0x2E},  // M
    {0x004E, 0x2D},  // N
    {0x004F, 0x1F},  // O
    {0x0050, 0x23},  // P
    {0x0051, 0x0C},  // Q
    {0x0052, 0x0F},  // R
    {0x0053, 0x01},  // S
    {0x0054, 0x11},  // T
    {0x0055, 0x20},  // U
    {0x0056, 0x09},  // V
    {0x0057, 0x0D},  // W
    {0x0058, 0x07},  // X
    {0x0059, 0x10},  // Y
    {0x005A, 0x06},  // Z

    // 0-9
    {0x0030, 0x1D},  // 0
    {0x0031, 0x12},  // 1
    {0x0032, 0x13},  // 2
    {0x0033, 0x14},  // 3
    {0x0034, 0x15},  // 4
    {0x0035, 0x17},  // 5
    {0x0036, 0x16},  // 6
    {0x0037, 0x1A},  // 7
    {0x0038, 0x1C},  // 8
    {0x0039, 0x19},  // 9

    // F1-F12
    {0xFFBE, 0x7A},  // F1
    {0xFFBF, 0x78},  // F2
    {0xFFC0, 0x63},  // F3
    {0xFFC1, 0x76},  // F4
    {0xFFC2, 0x60},  // F5
    {0xFFC3, 0x61},  // F6
    {0xFFC4, 0x62},  // F7
    {0xFFC5, 0x64},  // F8
    {0xFFC6, 0x65},  // F9
    {0xFFC7, 0x6D},  // F10
    {0xFFC8, 0x67},  // F11
    {0xFFC9, 0x6F},  // F12

    // control keys
    {0xFF1B, 0x35},  // Escape
    {0xFF0D, 0x24},  // Enter
    {0x0020, 0x31},  // Space
    {0xFF08, 0x33},  // Backspace
    {0xFF09, 0x30},  // Tab
    {0xFF15, 0x74},  // Print Screen
    {0xFF63, 0x72},  // Insert
    {0xFFFF, 0x75},  // Delete
    {0xFF50, 0x73},  // Home
    {0xFF57, 0x77},  // End
    {0xFF55, 0x79},  // Page Up
    {0xFF56, 0x7A},  // Page Down

    // arrow keys
    {0xFF51, 0x7B},  // Left Arrow
    {0xFF53, 0x7C},  // Right Arrow
    {0xFF52, 0x7E},  // Up Arrow
    {0xFF54, 0x7D},  // Down Arrow

    // numpad
    {0x0030, 0x52},  // Numpad 0
    {0x0031, 0x53},  // Numpad 1
    {0x0032, 0x54},  // Numpad 2
    {0x0033, 0x55},  // Numpad 3
    {0x0034, 0x56},  // Numpad 4
    {0x0035, 0x57},  // Numpad 5
    {0x0036, 0x58},  // Numpad 6
    {0x0037, 0x59},  // Numpad 7
    {0x0038, 0x5B},  // Numpad 8
    {0x0039, 0x5C},  // Numpad 9
    {0x003A, 0x41},  // Numpad .
    {0x002F, 0x4B},  // Numpad /
    {0x002A, 0x43},  // Numpad *
    {0x002D, 0x4E},  // Numpad -
    {0x002B, 0x45},  // Numpad +

    // symbol keys
    {0x003B, 0x29},  // ; (Semicolon)
    {0x0027, 0x27},  // ' (Quote)
    {0x007E, 0x32},  // ` (Backtick)
    {0x002C, 0x2B},  // , (Comma)
    {0x002E, 0x2F},  // . (Period)
    {0x002F, 0x2C},  // / (Slash)
    {0x005C, 0x2A},  // \ (Backslash)
    {0x005B, 0x21},  // [ (Left Bracket)
    {0x005D, 0x1E},  // ] (Right Bracket)
    {0x002D, 0x1B},  // - (Minus)
    {0x003D, 0x18},  // = (Equals)

    // modifier keys
    {0xFFE5, 0x39},  // Caps Lock
    {0xFFE1, 0x38},  // Shift (Left)
    {0xFFE2, 0x3C},  // Shift (Right)
    {0xFFE3, 0x3B},  // Control (Left)
    {0xFFE4, 0x3E},  // Control (Right)
    {0xFFE9, 0x3A},  // Alt (Left)
    {0xFFEA, 0x3D},  // Alt (Right)
    {0xFFEB, 0x37},  // Left Command
    {0xFFEC, 0x36},  // Right Command
};

#endif