#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/XKBlib.h>
#include <X11/keysym.h>
#include <X11/Xatom.h>
#include <X11/cursorfont.h>

// I cannot find a way to get dpi under VirtualBox
//#include <X11/Xresource.h>
//#include <X11/extensions/Xrandr.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <MiniFB.h>
#include <MiniFB_internal.h>
#include "WindowData.h"
#include "WindowData_X11.h"

#if defined(USE_OPENGL_API)
    #include <gl/MiniFB_GL.h>
#endif

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void init_keycodes(SWindowData_X11 *window_data_x11);

extern void
stretch_image(uint32_t *srcImage, uint32_t srcX, uint32_t srcY, uint32_t srcWidth, uint32_t srcHeight, uint32_t srcPitch,
              uint32_t *dstImage, uint32_t dstX, uint32_t dstY, uint32_t dstWidth, uint32_t dstHeight, uint32_t dstPitch);

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

struct mfb_window *
mfb_open_ex(const char *title, unsigned width, unsigned height, unsigned flags) {
    int depth, i, formatCount, convDepth = -1;
    XPixmapFormatValues* formats;
    XSetWindowAttributes windowAttributes;
    XSizeHints sizeHints;
    Visual* visual;

    SWindowData *window_data = (SWindowData *) malloc(sizeof(SWindowData));
    if (!window_data) {
        return 0x0;
    }
    memset(window_data, 0, sizeof(SWindowData));

    SWindowData_X11 *window_data_x11 = (SWindowData_X11 *) malloc(sizeof(SWindowData_X11));
    if (!window_data_x11) {
        free(window_data);
        return 0x0;
    }
    memset(window_data_x11, 0, sizeof(SWindowData_X11));
    window_data->specific = window_data_x11;

    window_data_x11->display = XOpenDisplay(0);
    if (!window_data_x11->display) {
        free(window_data);
        free(window_data_x11);
        return 0x0;
    }

    init_keycodes(window_data_x11);

    window_data_x11->screen = DefaultScreen(window_data_x11->display);

    visual   = DefaultVisual(window_data_x11->display, window_data_x11->screen);
    formats  = XListPixmapFormats(window_data_x11->display, &formatCount);
    depth    = DefaultDepth(window_data_x11->display, window_data_x11->screen);

    Window defaultRootWindow = DefaultRootWindow(window_data_x11->display);

    for (i = 0; i < formatCount; ++i)
    {
        if (depth == formats[i].depth)
        {
            convDepth = formats[i].bits_per_pixel;
            break;
        }
    }

    XFree(formats);

    // We only support 32-bit right now
    if (convDepth != 32)
    {
        XCloseDisplay(window_data_x11->display);
        return 0x0;
    }

    int screenWidth  = DisplayWidth(window_data_x11->display, window_data_x11->screen);
    int screenHeight = DisplayHeight(window_data_x11->display, window_data_x11->screen);

    windowAttributes.border_pixel     = BlackPixel(window_data_x11->display, window_data_x11->screen);
    windowAttributes.background_pixel = BlackPixel(window_data_x11->display, window_data_x11->screen);
    windowAttributes.backing_store    = NotUseful;

    int posX, posY;
    int windowWidth, windowHeight;

    window_data->window_width  = width;
    window_data->window_height = height;
    window_data->buffer_width  = width;
    window_data->buffer_height = height;
    window_data->buffer_stride = width * 4;
    calc_dst_factor(window_data, width, height);

    if (flags & WF_FULLSCREEN_DESKTOP) {
        posX         = 0;
        posY         = 0;
        windowWidth  = screenWidth;
        windowHeight = screenHeight;
    }
    else {
        posX         = (screenWidth  - width)  / 2;
        posY         = (screenHeight - height) / 2;
        windowWidth  = width;
        windowHeight = height;
    }

    window_data_x11->window = XCreateWindow(
                    window_data_x11->display,
                    defaultRootWindow,
                    posX, posY,
                    windowWidth, windowHeight,
                    0,
                    depth,
                    InputOutput,
                    visual,
                    CWBackPixel | CWBorderPixel | CWBackingStore,
                    &windowAttributes);
    if (!window_data_x11->window)
        return 0x0;

    XSelectInput(window_data_x11->display, window_data_x11->window,
        KeyPressMask | KeyReleaseMask
        | ButtonPressMask | ButtonReleaseMask | PointerMotionMask
        | StructureNotifyMask | ExposureMask
        | FocusChangeMask
        | EnterWindowMask | LeaveWindowMask
    );

    XStoreName(window_data_x11->display, window_data_x11->window, title);

    if (flags & WF_BORDERLESS) {
        struct StyleHints {
            unsigned long   flags;
            unsigned long   functions;
            unsigned long   decorations;
            long            inputMode;
            unsigned long   status;
        } sh = {
            .flags       = 2,
            .functions   = 0,
            .decorations = 0,
            .inputMode   = 0,
            .status      = 0,
        };
        Atom sh_p = XInternAtom(window_data_x11->display, "_MOTIF_WM_HINTS", True);
        XChangeProperty(window_data_x11->display, window_data_x11->window, sh_p, sh_p, 32, PropModeReplace, (unsigned char*)&sh, 5);
    }

    if (flags & WF_ALWAYS_ON_TOP) {
        Atom sa_p = XInternAtom(window_data_x11->display, "_NET_WM_STATE_ABOVE", False);
        XChangeProperty(window_data_x11->display, window_data_x11->window, XInternAtom(window_data_x11->display, "_NET_WM_STATE", False), XA_ATOM, 32, PropModeReplace, (unsigned char *)&sa_p, 1);
    }

    if (flags & WF_FULLSCREEN) {
        Atom sf_p = XInternAtom(window_data_x11->display, "_NET_WM_STATE_FULLSCREEN", True);
        XChangeProperty(window_data_x11->display, window_data_x11->window, XInternAtom(window_data_x11->display, "_NET_WM_STATE", True), XA_ATOM, 32, PropModeReplace, (unsigned char*)&sf_p, 1);
    }

    sizeHints.flags      = PPosition | PMinSize | PMaxSize;
    sizeHints.x          = 0;
    sizeHints.y          = 0;
    sizeHints.min_width  = width;
    sizeHints.min_height = height;
    if (flags & WF_RESIZABLE) {
        sizeHints.max_width  = screenWidth;
        sizeHints.max_height = screenHeight;
    }
    else {
        sizeHints.max_width  = width;
        sizeHints.max_height = height;
    }

#if defined(USE_OPENGL_API)
    if(create_GL_context(window_data) == false) {
        return 0x0;
    }

#else
    window_data_x11->image = XCreateImage(window_data_x11->display, CopyFromParent, depth, ZPixmap, 0, 0x0, width, height, 32, width * 4);
#endif

    XSetWMNormalHints(window_data_x11->display, window_data_x11->window, &sizeHints);
    XClearWindow(window_data_x11->display, window_data_x11->window);
    XMapRaised(window_data_x11->display, window_data_x11->window);
    XFlush(window_data_x11->display);

    window_data_x11->gc = DefaultGC(window_data_x11->display, window_data_x11->screen);

    window_data_x11->timer = mfb_timer_create();

    mfb_set_keyboard_callback((struct mfb_window *) window_data, keyboard_default);

#if defined(_DEBUG) || defined(DEBUG)
    printf("Window created using X11 API\n");
#endif

    window_data->is_initialized = true;
    return (struct mfb_window *) window_data;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int translate_key(int scancode);
int translate_mod(int state);
int translate_mod_ex(int key, int state, int is_pressed);

static void
processEvent(SWindowData *window_data, XEvent *event) {
    switch (event->type) {
        case KeyPress:
        case KeyRelease:
        {
            mfb_key key_code      = (mfb_key) translate_key(event->xkey.keycode);
            int is_pressed        = (event->type == KeyPress);
            window_data->mod_keys = translate_mod_ex(key_code, event->xkey.state, is_pressed);

            window_data->key_status[key_code] = is_pressed;
            kCall(keyboard_func, key_code, (mfb_key_mod) window_data->mod_keys, is_pressed);
        }
        break;

        case ButtonPress:
        case ButtonRelease:
        {
            mfb_mouse_button button = (mfb_mouse_button) event->xbutton.button;
            int          is_pressed = (event->type == ButtonPress);
            window_data->mod_keys   = translate_mod(event->xkey.state);
            switch (button) {
                case Button1:
                case Button2:
                case Button3:
                    kCall(mouse_btn_func, button, (mfb_key_mod) window_data->mod_keys, is_pressed);
                    break;

                case Button4:
                    kCall(mouse_wheel_func, (mfb_key_mod) window_data->mod_keys, 0.0f, 1.0f);
                    break;
                case Button5:
                    kCall(mouse_wheel_func, (mfb_key_mod) window_data->mod_keys, 0.0f, -1.0f);
                    break;

                case 6:
                    kCall(mouse_wheel_func, (mfb_key_mod) window_data->mod_keys, 1.0f, 0.0f);
                    break;
                case 7:
                    kCall(mouse_wheel_func, (mfb_key_mod) window_data->mod_keys, -1.0f, 0.0f);
                    break;

                default:
                    kCall(mouse_btn_func, (mfb_mouse_button) (button - 4), (mfb_key_mod) window_data->mod_keys, is_pressed);
                    break;
            }
        }
        break;

        case MotionNotify:
            window_data->mouse_pos_x = event->xmotion.x;
            window_data->mouse_pos_y = event->xmotion.y;
            kCall(mouse_move_func, event->xmotion.x, event->xmotion.y);
            break;

        case ConfigureNotify:
        {
            window_data->window_width  = event->xconfigure.width;
            window_data->window_height = event->xconfigure.height;
            resize_dst(window_data, event->xconfigure.width, event->xconfigure.height);

#if defined(USE_OPENGL_API)
            resize_GL(window_data);
#else
            SWindowData_X11 *window_data_x11 = (SWindowData_X11 *) window_data->specific;
            if(window_data_x11->image_scaler != 0x0) {
                window_data_x11->image_scaler->data = 0x0;
                XDestroyImage(window_data_x11->image_scaler);
                window_data_x11->image_scaler        = 0x0;
                window_data_x11->image_scaler_width  = 0;
                window_data_x11->image_scaler_height = 0;
            }
            XClearWindow(window_data_x11->display, window_data_x11->window);
#endif
            kCall(resize_func, window_data->window_width, window_data->window_height);
        }
        break;

        case EnterNotify:
        case LeaveNotify:
        break;

        case FocusIn:
            window_data->is_active = true;
            kCall(active_func, true);
            break;

        case FocusOut:
            window_data->is_active = false;
            kCall(active_func, false);
            break;

        case DestroyNotify:
            window_data->close = true;
            return;
            break;
    }
}

static void
processEvents(SWindowData *window_data) {
    XEvent          event;
    SWindowData_X11 *window_data_x11 = (SWindowData_X11 *) window_data->specific;

    while ((window_data->close == false) && XPending(window_data_x11->display)) {
        XNextEvent(window_data_x11->display, &event);
        processEvent(window_data, &event);
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void destroy_window_data(SWindowData *window_data);

mfb_update_state
mfb_update_ex(struct mfb_window *window, void *buffer, unsigned width, unsigned height) {
    if (window == 0x0) {
        return STATE_INVALID_WINDOW;
    }

    SWindowData *window_data = (SWindowData *) window;
    if (window_data->close) {
        destroy_window_data(window_data);
        return STATE_EXIT;
    }

    if (buffer == 0x0) {
        return STATE_INVALID_BUFFER;
    }

#if !defined(USE_OPENGL_API)
    SWindowData_X11 *window_data_x11 = (SWindowData_X11 *) window_data->specific;
    bool different_size = false;
#endif

    if(window_data->buffer_width != width || window_data->buffer_height != height) {
        window_data->buffer_width  = width;
        window_data->buffer_stride = width * 4;
        window_data->buffer_height = height;
#if !defined(USE_OPENGL_API)
        different_size = true;
#endif
    }

#if !defined(USE_OPENGL_API)

    if (different_size || window_data->buffer_width != window_data->dst_width || window_data->buffer_height != window_data->dst_height) {
        if (window_data_x11->image_scaler_width != window_data->dst_width || window_data_x11->image_scaler_height != window_data->dst_height) {
            if (window_data_x11->image_scaler != 0x0) {
                window_data_x11->image_scaler->data = 0x0;
                XDestroyImage(window_data_x11->image_scaler);
            }
            if (window_data_x11->image_buffer != 0x0) {
                free(window_data_x11->image_buffer);
                window_data_x11->image_buffer = 0x0;
            }
            int depth = DefaultDepth(window_data_x11->display, window_data_x11->screen);
            window_data_x11->image_buffer = malloc(window_data->dst_width * window_data->dst_height * 4);
            if(window_data_x11->image_buffer == 0x0) {
                return STATE_INTERNAL_ERROR;
            }
            window_data_x11->image_scaler_width  = window_data->dst_width;
            window_data_x11->image_scaler_height = window_data->dst_height;
            window_data_x11->image_scaler = XCreateImage(window_data_x11->display, CopyFromParent, depth, ZPixmap, 0, 0x0, window_data_x11->image_scaler_width, window_data_x11->image_scaler_height, 32, window_data_x11->image_scaler_width * 4);
        }
    }

    if (window_data_x11->image_scaler != 0x0) {
        stretch_image((uint32_t *) buffer, 0, 0, window_data->buffer_width, window_data->buffer_height, window_data->buffer_width,
                      (uint32_t *) window_data_x11->image_buffer, 0, 0, window_data->dst_width, window_data->dst_height, window_data->dst_width);
        window_data_x11->image_scaler->data = (char *) window_data_x11->image_buffer;
        XPutImage(window_data_x11->display, window_data_x11->window, window_data_x11->gc, window_data_x11->image_scaler, 0, 0, window_data->dst_offset_x, window_data->dst_offset_y, window_data->dst_width, window_data->dst_height);
    }
    else {
        window_data_x11->image->data = (char *) buffer;
        XPutImage(window_data_x11->display, window_data_x11->window, window_data_x11->gc, window_data_x11->image, 0, 0, window_data->dst_offset_x, window_data->dst_offset_y, window_data->dst_width, window_data->dst_height);
    }
    XFlush(window_data_x11->display);

#else

    redraw_GL(window_data, buffer);

#endif

    processEvents(window_data);

    return STATE_OK;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

mfb_update_state
mfb_update_events(struct mfb_window *window) {
    if (window == 0x0) {
        return STATE_INVALID_WINDOW;
    }

    SWindowData *window_data = (SWindowData *) window;
    if (window_data->close) {
        destroy_window_data(window_data);
        return STATE_EXIT;
    }

    SWindowData_X11 *window_data_x11 = (SWindowData_X11 *) window_data->specific;
    XFlush(window_data_x11->display);
    processEvents(window_data);

    return STATE_OK;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

extern double   g_time_for_frame;

bool
mfb_wait_sync(struct mfb_window *window) {
    if (window == 0x0) {
        return STATE_INVALID_WINDOW;
    }

    SWindowData *window_data = (SWindowData *) window;
    if (window_data->close) {
        destroy_window_data(window_data);
        return false;
    }

    SWindowData_X11 *window_data_x11 = (SWindowData_X11 *) window_data->specific;
    XFlush(window_data_x11->display);
    XEvent      event;
    double      current;
    uint32_t    millis = 1;
    while(1) {
        if(XEventsQueued(window_data_x11->display, QueuedAlready) > 0) {
            XNextEvent(window_data_x11->display, &event);
            processEvent(window_data, &event);
        }

        if(window_data->close) {
            destroy_window_data(window_data);
            return false;
        }

        current = mfb_timer_now(window_data_x11->timer);
        if (current >= g_time_for_frame) {
            mfb_timer_reset(window_data_x11->timer);
            return true;
        }
        else if(current >= g_time_for_frame * 0.8) {
            millis = 0;
        }

        usleep(millis * 1000);
        //sched_yield();
    }

    return true;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void
destroy_window_data(SWindowData *window_data)  {
    if (window_data != 0x0) {
        if (window_data->specific != 0x0) {
            SWindowData_X11   *window_data_x11 = (SWindowData_X11 *) window_data->specific;

#if defined(USE_OPENGL_API)
            destroy_GL_context(window_data);
#else
            if (window_data_x11->image != 0x0) {
                window_data_x11->image->data = 0x0;
                XDestroyImage(window_data_x11->image);
                XDestroyWindow(window_data_x11->display, window_data_x11->window);
                XCloseDisplay(window_data_x11->display);
            }
#endif

            mfb_timer_destroy(window_data_x11->timer);
            memset(window_data_x11, 0, sizeof(SWindowData_X11));
            free(window_data_x11);
        }
        memset(window_data, 0, sizeof(SWindowData));
        free(window_data);
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

extern short int g_keycodes[512];

static int
translateKeyCodeB(int keySym) {

    switch (keySym)
    {
        case XK_KP_0:           return KB_KEY_KP_0;
        case XK_KP_1:           return KB_KEY_KP_1;
        case XK_KP_2:           return KB_KEY_KP_2;
        case XK_KP_3:           return KB_KEY_KP_3;
        case XK_KP_4:           return KB_KEY_KP_4;
        case XK_KP_5:           return KB_KEY_KP_5;
        case XK_KP_6:           return KB_KEY_KP_6;
        case XK_KP_7:           return KB_KEY_KP_7;
        case XK_KP_8:           return KB_KEY_KP_8;
        case XK_KP_9:           return KB_KEY_KP_9;
        case XK_KP_Separator:
        case XK_KP_Decimal:     return KB_KEY_KP_DECIMAL;
        case XK_KP_Equal:       return KB_KEY_KP_EQUAL;
        case XK_KP_Enter:       return KB_KEY_KP_ENTER;
    }

    return KB_KEY_UNKNOWN;
}

static int translateKeyCodeA(int keySym) {
    switch (keySym)
    {
        case XK_Escape:         return KB_KEY_ESCAPE;
        case XK_Tab:            return KB_KEY_TAB;
        case XK_Shift_L:        return KB_KEY_LEFT_SHIFT;
        case XK_Shift_R:        return KB_KEY_RIGHT_SHIFT;
        case XK_Control_L:      return KB_KEY_LEFT_CONTROL;
        case XK_Control_R:      return KB_KEY_RIGHT_CONTROL;
        case XK_Meta_L:
        case XK_Alt_L:          return KB_KEY_LEFT_ALT;
        case XK_Mode_switch:      // Mapped to Alt_R on many keyboards
        case XK_ISO_Level3_Shift: // AltGr on at least some machines
        case XK_Meta_R:
        case XK_Alt_R:          return KB_KEY_RIGHT_ALT;
        case XK_Super_L:        return KB_KEY_LEFT_SUPER;
        case XK_Super_R:        return KB_KEY_RIGHT_SUPER;
        case XK_Menu:           return KB_KEY_MENU;
        case XK_Num_Lock:       return KB_KEY_NUM_LOCK;
        case XK_Caps_Lock:      return KB_KEY_CAPS_LOCK;
        case XK_Print:          return KB_KEY_PRINT_SCREEN;
        case XK_Scroll_Lock:    return KB_KEY_SCROLL_LOCK;
        case XK_Pause:          return KB_KEY_PAUSE;
        case XK_Delete:         return KB_KEY_DELETE;
        case XK_BackSpace:      return KB_KEY_BACKSPACE;
        case XK_Return:         return KB_KEY_ENTER;
        case XK_Home:           return KB_KEY_HOME;
        case XK_End:            return KB_KEY_END;
        case XK_Page_Up:        return KB_KEY_PAGE_UP;
        case XK_Page_Down:      return KB_KEY_PAGE_DOWN;
        case XK_Insert:         return KB_KEY_INSERT;
        case XK_Left:           return KB_KEY_LEFT;
        case XK_Right:          return KB_KEY_RIGHT;
        case XK_Down:           return KB_KEY_DOWN;
        case XK_Up:             return KB_KEY_UP;
        case XK_F1:             return KB_KEY_F1;
        case XK_F2:             return KB_KEY_F2;
        case XK_F3:             return KB_KEY_F3;
        case XK_F4:             return KB_KEY_F4;
        case XK_F5:             return KB_KEY_F5;
        case XK_F6:             return KB_KEY_F6;
        case XK_F7:             return KB_KEY_F7;
        case XK_F8:             return KB_KEY_F8;
        case XK_F9:             return KB_KEY_F9;
        case XK_F10:            return KB_KEY_F10;
        case XK_F11:            return KB_KEY_F11;
        case XK_F12:            return KB_KEY_F12;
        case XK_F13:            return KB_KEY_F13;
        case XK_F14:            return KB_KEY_F14;
        case XK_F15:            return KB_KEY_F15;
        case XK_F16:            return KB_KEY_F16;
        case XK_F17:            return KB_KEY_F17;
        case XK_F18:            return KB_KEY_F18;
        case XK_F19:            return KB_KEY_F19;
        case XK_F20:            return KB_KEY_F20;
        case XK_F21:            return KB_KEY_F21;
        case XK_F22:            return KB_KEY_F22;
        case XK_F23:            return KB_KEY_F23;
        case XK_F24:            return KB_KEY_F24;
        case XK_F25:            return KB_KEY_F25;

        // Numeric keypad
        case XK_KP_Divide:      return KB_KEY_KP_DIVIDE;
        case XK_KP_Multiply:    return KB_KEY_KP_MULTIPLY;
        case XK_KP_Subtract:    return KB_KEY_KP_SUBTRACT;
        case XK_KP_Add:         return KB_KEY_KP_ADD;

        // These should have been detected in secondary keysym test above!
        case XK_KP_Insert:      return KB_KEY_KP_0;
        case XK_KP_End:         return KB_KEY_KP_1;
        case XK_KP_Down:        return KB_KEY_KP_2;
        case XK_KP_Page_Down:   return KB_KEY_KP_3;
        case XK_KP_Left:        return KB_KEY_KP_4;
        case XK_KP_Right:       return KB_KEY_KP_6;
        case XK_KP_Home:        return KB_KEY_KP_7;
        case XK_KP_Up:          return KB_KEY_KP_8;
        case XK_KP_Page_Up:     return KB_KEY_KP_9;
        case XK_KP_Delete:      return KB_KEY_KP_DECIMAL;
        case XK_KP_Equal:       return KB_KEY_KP_EQUAL;
        case XK_KP_Enter:       return KB_KEY_KP_ENTER;

        // Last resort: Check for printable keys (should not happen if the XKB
        // extension is available). This will give a layout dependent mapping
        // (which is wrong, and we may miss some keys, especially on non-US
        // keyboards), but it's better than nothing...
        case XK_a:              return KB_KEY_A;
        case XK_b:              return KB_KEY_B;
        case XK_c:              return KB_KEY_C;
        case XK_d:              return KB_KEY_D;
        case XK_e:              return KB_KEY_E;
        case XK_f:              return KB_KEY_F;
        case XK_g:              return KB_KEY_G;
        case XK_h:              return KB_KEY_H;
        case XK_i:              return KB_KEY_I;
        case XK_j:              return KB_KEY_J;
        case XK_k:              return KB_KEY_K;
        case XK_l:              return KB_KEY_L;
        case XK_m:              return KB_KEY_M;
        case XK_n:              return KB_KEY_N;
        case XK_o:              return KB_KEY_O;
        case XK_p:              return KB_KEY_P;
        case XK_q:              return KB_KEY_Q;
        case XK_r:              return KB_KEY_R;
        case XK_s:              return KB_KEY_S;
        case XK_t:              return KB_KEY_T;
        case XK_u:              return KB_KEY_U;
        case XK_v:              return KB_KEY_V;
        case XK_w:              return KB_KEY_W;
        case XK_x:              return KB_KEY_X;
        case XK_y:              return KB_KEY_Y;
        case XK_z:              return KB_KEY_Z;
        case XK_1:              return KB_KEY_1;
        case XK_2:              return KB_KEY_2;
        case XK_3:              return KB_KEY_3;
        case XK_4:              return KB_KEY_4;
        case XK_5:              return KB_KEY_5;
        case XK_6:              return KB_KEY_6;
        case XK_7:              return KB_KEY_7;
        case XK_8:              return KB_KEY_8;
        case XK_9:              return KB_KEY_9;
        case XK_0:              return KB_KEY_0;
        case XK_space:          return KB_KEY_SPACE;
        case XK_minus:          return KB_KEY_MINUS;
        case XK_equal:          return KB_KEY_EQUAL;
        case XK_bracketleft:    return KB_KEY_LEFT_BRACKET;
        case XK_bracketright:   return KB_KEY_RIGHT_BRACKET;
        case XK_backslash:      return KB_KEY_BACKSLASH;
        case XK_semicolon:      return KB_KEY_SEMICOLON;
        case XK_apostrophe:     return KB_KEY_APOSTROPHE;
        case XK_grave:          return KB_KEY_GRAVE_ACCENT;
        case XK_comma:          return KB_KEY_COMMA;
        case XK_period:         return KB_KEY_PERIOD;
        case XK_slash:          return KB_KEY_SLASH;
        case XK_less:           return KB_KEY_WORLD_1; // At least in some layouts...
        default:                break;
    }

    return KB_KEY_UNKNOWN;
}

void
init_keycodes(SWindowData_X11 *window_data_x11) {
    size_t  i;
    int     keySym;

    // Clear keys
    for (i = 0; i < sizeof(g_keycodes) / sizeof(g_keycodes[0]); ++i)
        g_keycodes[i] = KB_KEY_UNKNOWN;

    // Valid key code range is  [8,255], according to the Xlib manual
    for (i=8; i<=255; ++i) {
        // Try secondary keysym, for numeric keypad keys
         keySym  = XkbKeycodeToKeysym(window_data_x11->display, i, 0, 1);
         g_keycodes[i] = translateKeyCodeB(keySym);
         if (g_keycodes[i] == KB_KEY_UNKNOWN) {
            keySym = XkbKeycodeToKeysym(window_data_x11->display, i, 0, 0);
            g_keycodes[i] = translateKeyCodeA(keySym);
         }
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int
translate_key(int scancode) {
    if (scancode < 0 || scancode > 255)
        return KB_KEY_UNKNOWN;

    return g_keycodes[scancode];
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int
translate_mod(int state) {
    int mod_keys = 0;

    if (state & ShiftMask)
        mod_keys |= KB_MOD_SHIFT;
    if (state & ControlMask)
        mod_keys |= KB_MOD_CONTROL;
    if (state & Mod1Mask)
        mod_keys |= KB_MOD_ALT;
    if (state & Mod4Mask)
        mod_keys |= KB_MOD_SUPER;
    if (state & LockMask)
        mod_keys |= KB_MOD_CAPS_LOCK;
    if (state & Mod2Mask)
        mod_keys |= KB_MOD_NUM_LOCK;

    return mod_keys;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int
translate_mod_ex(int key, int state, int is_pressed) {
    int mod_keys = 0;

    mod_keys = translate_mod(state);

    switch (key)
    {
        case KB_KEY_LEFT_SHIFT:
        case KB_KEY_RIGHT_SHIFT:
            if (is_pressed)
                mod_keys |= KB_MOD_SHIFT;
            else
                mod_keys &= ~KB_MOD_SHIFT;
            break;

        case KB_KEY_LEFT_CONTROL:
        case KB_KEY_RIGHT_CONTROL:
            if (is_pressed)
                mod_keys |= KB_MOD_CONTROL;
            else
                mod_keys &= ~KB_MOD_CONTROL;
            break;

        case KB_KEY_LEFT_ALT:
        case KB_KEY_RIGHT_ALT:
            if (is_pressed)
                mod_keys |= KB_MOD_ALT;
            else
                mod_keys &= ~KB_MOD_ALT;
            break;

        case KB_KEY_LEFT_SUPER:
        case KB_KEY_RIGHT_SUPER:
            if (is_pressed)
                mod_keys |= KB_MOD_SUPER;
            else
                mod_keys &= ~KB_MOD_SUPER;
            break;
    }

    return mod_keys;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

bool
mfb_set_viewport(struct mfb_window *window, unsigned offset_x, unsigned offset_y, unsigned width, unsigned height)  {
    SWindowData *window_data = (SWindowData *) window;

    if (offset_x + width > window_data->window_width) {
        return false;
    }
    if (offset_y + height > window_data->window_height) {
        return false;
    }

    window_data->dst_offset_x = offset_x;
    window_data->dst_offset_y = offset_y;
    window_data->dst_width    = width;
    window_data->dst_height   = height;
    calc_dst_factor(window_data, window_data->window_width, window_data->window_height);

    return true;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void
mfb_get_monitor_scale(struct mfb_window *window, float *scale_x, float *scale_y) {
    float x = 96.0, y = 96.0;

    if(window != 0x0) {
        //SWindowData     *window_data     = (SWindowData *) window;
        //SWindowData_X11 *window_data_x11 = (SWindowData_X11 *) window_data->specific;

        // I cannot find a way to get dpi under VirtualBox
        // XrmGetResource "Xft.dpi", "Xft.Dpi"
        // XRRGetOutputInfo
        // DisplayWidthMM, DisplayHeightMM
        // All returning invalid values or 0
    }

    if (scale_x) {
        *scale_x = x / 96.0f;
        if(*scale_x == 0) {
            *scale_x = 1.0f;
        }
    }

    if (scale_y) {
        *scale_y = y / 96.0f;
        if (*scale_y == 0) {
            *scale_y = 1.0f;
        }
    }
}