/**********************************************************************************************
*
*   raylibExtras * Utilities and Shared Components for Raylib
*
*   rlImGui * basic ImGui integration
*
*   LICENSE: ZLIB
*
*   Copyright (c) 2020 Jeffery Myers
*
*   Permission is hereby granted, free of charge, to any person obtaining a copy
*   of this software and associated documentation files (the "Software"), to deal
*   in the Software without restriction, including without limitation the rights
*   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
*   copies of the Software, and to permit persons to whom the Software is
*   furnished to do so, subject to the following conditions:
*
*   The above copyright notice and this permission notice shall be included in all
*   copies or substantial portions of the Software.
*
*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
*   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
*   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
*   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
*   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
*   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
*   SOFTWARE.
*
**********************************************************************************************/
#include "rlImGui.h"

#include "imgui_impl_raylib.h"

#include "raylib.h"
#include "rlgl.h"

#ifdef PLATFORM_DESKTOP

#include <GLFW/glfw3.h>

#endif

#include <math.h>
#include <memory.h>

#define NO_FONT_AWESOME
#ifndef NO_FONT_AWESOME
#include "extras/FA6FreeSolidFontData.h"
#endif

static ImGuiMouseCursor CurrentMouseCursor = ImGuiMouseCursor_COUNT;
static MouseCursor MouseCursorMap[ImGuiMouseCursor_COUNT];

ImGuiContext *GlobalContext = NULL;

#define KEY_MAP_SIZE 512
static ImGuiKey RaylibKeyMap[KEY_MAP_SIZE] = {};
static bool RaylibKeyMapReady = false;

static bool LastFrameFocused = false;

static bool LastControlPressed = false;
static bool LastShiftPressed = false;
static bool LastAltPressed = false;
static bool LastSuperPressed = false;

bool rlImGuiIsControlDown() { return IsKeyDown(KEY_RIGHT_CONTROL) || IsKeyDown(KEY_LEFT_CONTROL); }

bool rlImGuiIsShiftDown() { return IsKeyDown(KEY_RIGHT_SHIFT) || IsKeyDown(KEY_LEFT_SHIFT); }

bool rlImGuiIsAltDown() { return IsKeyDown(KEY_RIGHT_ALT) || IsKeyDown(KEY_LEFT_ALT); }

bool rlImGuiIsSuperDown() { return IsKeyDown(KEY_RIGHT_SUPER) || IsKeyDown(KEY_LEFT_SUPER); }

void ReloadFonts() {
    ImGuiIO *io = igGetIO();
    unsigned char *pixels = NULL;

    int width;
    int height;
    ImFontAtlas_GetTexDataAsRGBA32(io->Fonts, &pixels, &width, &height, NULL);
    Image image = GenImageColor(width, height, BLANK);
    memcpy(image.data, pixels, width * height * 4);

    Texture2D *fontTexture = (Texture2D *) io->Fonts->TexID;
    if (fontTexture && fontTexture->id != 0) {
        UnloadTexture(*fontTexture);
        MemFree(fontTexture);
    }

    fontTexture = (Texture2D *) MemAlloc(sizeof(Texture2D));
    *fontTexture = LoadTextureFromImage(image);
    UnloadImage(image);
    io->Fonts->TexID = fontTexture;
}

static const char *GetClipTextCallback(void *) {
    return GetClipboardText();
}

static void SetClipTextCallback(void *, const char *text) {
    SetClipboardText(text);
}

static void ImGuiNewFrame(float deltaTime) {
    ImGuiIO *io = igGetIO();

    if (IsWindowFullscreen()) {
        int monitor = GetCurrentMonitor();
        io->DisplaySize.x = (float) (GetMonitorWidth(monitor));
        io->DisplaySize.y = (float) (GetMonitorHeight(monitor));
    } else {
        io->DisplaySize.x = (float) (GetScreenWidth());
        io->DisplaySize.y = (float) (GetScreenHeight());
    }

    int width = (int) (io->DisplaySize.x), height = (int) (io->DisplaySize.y);
#ifdef PLATFORM_DESKTOP
    glfwGetFramebufferSize(glfwGetCurrentContext(), &width, &height);
#endif
    if (width > 0 && height > 0) {
        io->DisplayFramebufferScale = (ImVec2) {width / io->DisplaySize.x, height / io->DisplaySize.y};
    } else {
        io->DisplayFramebufferScale = (ImVec2) {1.0f, 1.0f};
    }

    io->DeltaTime = deltaTime;

    if (io->WantSetMousePos) {
        SetMousePosition((int) io->MousePos.x, (int) io->MousePos.y);
    } else {
        ImGuiIO_AddMousePosEvent(io, (float) GetMouseX(), (float) GetMouseY());
    }

#define setMouseEvent(rayMouse, imGuiMouse)                 \
    do {                                                    \
        int rMouse = rayMouse;                              \
        int iMouse = imGuiMouse;                            \
        if (IsMouseButtonPressed(rMouse))                   \
            ImGuiIO_AddMouseButtonEvent(io, iMouse, true);      \
        else if (IsMouseButtonReleased(rMouse))             \
            ImGuiIO_AddMouseButtonEvent(io, iMouse, false);   \
    } while(0)

    setMouseEvent(MOUSE_BUTTON_LEFT, ImGuiMouseButton_Left);
    setMouseEvent(MOUSE_BUTTON_RIGHT, ImGuiMouseButton_Right);
    setMouseEvent(MOUSE_BUTTON_MIDDLE, ImGuiMouseButton_Middle);
    setMouseEvent(MOUSE_BUTTON_FORWARD, ImGuiMouseButton_Middle + 1);
    setMouseEvent(MOUSE_BUTTON_BACK, ImGuiMouseButton_Middle + 2);
#undef setMouseEvent

    {
        Vector2 mouseWheel = GetMouseWheelMoveV();
        ImGuiIO_AddMouseWheelEvent(io, mouseWheel.x, mouseWheel.y);
    }

    if ((io->ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange) == 0) {
        ImGuiMouseCursor imgui_cursor = igGetMouseCursor();
        if (imgui_cursor != CurrentMouseCursor || io->MouseDrawCursor) {
            CurrentMouseCursor = imgui_cursor;
            if (io->MouseDrawCursor || imgui_cursor == ImGuiMouseCursor_None) {
                HideCursor();
            } else {
                ShowCursor();

                if (!(io->ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange)) {
                    SetMouseCursor(
                            (imgui_cursor > -1 && imgui_cursor < ImGuiMouseCursor_COUNT) ? MouseCursorMap[imgui_cursor]
                                                                                         : MOUSE_CURSOR_DEFAULT);
                }
            }
        }
    }
}

static void ImGuiTriangleVert(ImDrawVert *idx_vert) {
    Color *c;
    c = (Color *) &idx_vert->col;
    rlColor4ub(c->r, c->g, c->b, c->a);
    rlTexCoord2f(idx_vert->uv.x, idx_vert->uv.y);
    rlVertex2f(idx_vert->pos.x, idx_vert->pos.y);
}

static void ImGuiRenderTriangles(unsigned int count, int indexStart, const ImVector_ImDrawIdx *indexBuffer,
                                 const ImVector_ImDrawVert *vertBuffer, void *texturePtr) {
    if (count < 3)
        return;

    Texture *texture = (Texture *) texturePtr;

    unsigned int textureId = (texture == NULL) ? 0 : texture->id;

    rlBegin(RL_TRIANGLES);
    rlSetTexture(textureId);

    for (unsigned int i = 0; i <= (count - 3); i += 3) {
        if (rlCheckRenderBatchLimit(3)) {
            rlBegin(RL_TRIANGLES);
            rlSetTexture(textureId);
        }

        ImDrawIdx indexA = indexBuffer->Data[indexStart + i];
        ImDrawIdx indexB = indexBuffer->Data[indexStart + i + 1];
        ImDrawIdx indexC = indexBuffer->Data[indexStart + i + 2];

        ImDrawVert vertexA = vertBuffer->Data[indexA];
        ImDrawVert vertexB = vertBuffer->Data[indexB];
        ImDrawVert vertexC = vertBuffer->Data[indexC];

        ImGuiTriangleVert(&vertexA);
        ImGuiTriangleVert(&vertexB);
        ImGuiTriangleVert(&vertexC);
    }

    rlEnd();

}

static void EnableScissor(float x, float y, float width, float height) {
    rlEnableScissorTest();
    ImGuiIO *io = igGetIO();
    rlScissor((int) (x * io->DisplayFramebufferScale.x),
              (int) ((GetScreenHeight() - (int) (y + height)) * io->DisplayFramebufferScale.y),
              (int) (width * io->DisplayFramebufferScale.x),
              (int) (height * io->DisplayFramebufferScale.y));
}

static void SetupMouseCursors() {
    MouseCursorMap[ImGuiMouseCursor_Arrow] = MOUSE_CURSOR_ARROW;
    MouseCursorMap[ImGuiMouseCursor_TextInput] = MOUSE_CURSOR_IBEAM;
    MouseCursorMap[ImGuiMouseCursor_Hand] = MOUSE_CURSOR_POINTING_HAND;
    MouseCursorMap[ImGuiMouseCursor_ResizeAll] = MOUSE_CURSOR_RESIZE_ALL;
    MouseCursorMap[ImGuiMouseCursor_ResizeEW] = MOUSE_CURSOR_RESIZE_EW;
    MouseCursorMap[ImGuiMouseCursor_ResizeNESW] = MOUSE_CURSOR_RESIZE_NESW;
    MouseCursorMap[ImGuiMouseCursor_ResizeNS] = MOUSE_CURSOR_RESIZE_NS;
    MouseCursorMap[ImGuiMouseCursor_ResizeNWSE] = MOUSE_CURSOR_RESIZE_NWSE;
    MouseCursorMap[ImGuiMouseCursor_NotAllowed] = MOUSE_CURSOR_NOT_ALLOWED;
}

void SetupFontAwesome() {
#ifndef NO_FONT_AWESOME
    static const ImWchar icons_ranges[] = { ICON_MIN_FA, ICON_MAX_FA, 0 };
    ImFontConfig icons_config;
    icons_config.MergeMode = true;
    icons_config.PixelSnapH = true;
    icons_config.FontDataOwnedByAtlas = false;

    icons_config.GlyphRanges = icons_ranges;

    ImGuiIO& io = ImGui::GetIO();

    io->Fonts->AddFontFromMemoryCompressedTTF((void*)fa_solid_900_compressed_data, fa_solid_900_compressed_size, FONT_AWESOME_ICON_SIZE, &icons_config, icons_ranges);
#endif

}

void SetupBackend() {
    ImGuiIO *io = igGetIO();
    io->BackendPlatformName = "imgui_impl_raylib";

    io->BackendFlags |= ImGuiBackendFlags_HasMouseCursors;

    io->MousePos = (ImVec2) {0, 0};

    io->SetClipboardTextFn = SetClipTextCallback;
    io->GetClipboardTextFn = GetClipTextCallback;

    io->ClipboardUserData = NULL;
}

void rlImGuiEndInitImGui() {
    igSetCurrentContext(GlobalContext);

    SetupFontAwesome();

    SetupMouseCursors();

    SetupBackend();

    ReloadFonts();
}

static void SetupKeymap() {
    if (RaylibKeyMapReady)
        return;
    RaylibKeyMapReady = true;

    // build up a map of raylib keys to ImGuiKeys
    RaylibKeyMap[KEY_APOSTROPHE] = ImGuiKey_Apostrophe;
    RaylibKeyMap[KEY_COMMA] = ImGuiKey_Comma;
    RaylibKeyMap[KEY_MINUS] = ImGuiKey_Minus;
    RaylibKeyMap[KEY_PERIOD] = ImGuiKey_Period;
    RaylibKeyMap[KEY_SLASH] = ImGuiKey_Slash;
    RaylibKeyMap[KEY_ZERO] = ImGuiKey_0;
    RaylibKeyMap[KEY_ONE] = ImGuiKey_1;
    RaylibKeyMap[KEY_TWO] = ImGuiKey_2;
    RaylibKeyMap[KEY_THREE] = ImGuiKey_3;
    RaylibKeyMap[KEY_FOUR] = ImGuiKey_4;
    RaylibKeyMap[KEY_FIVE] = ImGuiKey_5;
    RaylibKeyMap[KEY_SIX] = ImGuiKey_6;
    RaylibKeyMap[KEY_SEVEN] = ImGuiKey_7;
    RaylibKeyMap[KEY_EIGHT] = ImGuiKey_8;
    RaylibKeyMap[KEY_NINE] = ImGuiKey_9;
    RaylibKeyMap[KEY_SEMICOLON] = ImGuiKey_Semicolon;
    RaylibKeyMap[KEY_EQUAL] = ImGuiKey_Equal;
    RaylibKeyMap[KEY_A] = ImGuiKey_A;
    RaylibKeyMap[KEY_B] = ImGuiKey_B;
    RaylibKeyMap[KEY_C] = ImGuiKey_C;
    RaylibKeyMap[KEY_D] = ImGuiKey_D;
    RaylibKeyMap[KEY_E] = ImGuiKey_E;
    RaylibKeyMap[KEY_F] = ImGuiKey_F;
    RaylibKeyMap[KEY_G] = ImGuiKey_G;
    RaylibKeyMap[KEY_H] = ImGuiKey_H;
    RaylibKeyMap[KEY_I] = ImGuiKey_I;
    RaylibKeyMap[KEY_J] = ImGuiKey_J;
    RaylibKeyMap[KEY_K] = ImGuiKey_K;
    RaylibKeyMap[KEY_L] = ImGuiKey_L;
    RaylibKeyMap[KEY_M] = ImGuiKey_M;
    RaylibKeyMap[KEY_N] = ImGuiKey_N;
    RaylibKeyMap[KEY_O] = ImGuiKey_O;
    RaylibKeyMap[KEY_P] = ImGuiKey_P;
    RaylibKeyMap[KEY_Q] = ImGuiKey_Q;
    RaylibKeyMap[KEY_R] = ImGuiKey_R;
    RaylibKeyMap[KEY_S] = ImGuiKey_S;
    RaylibKeyMap[KEY_T] = ImGuiKey_T;
    RaylibKeyMap[KEY_U] = ImGuiKey_U;
    RaylibKeyMap[KEY_V] = ImGuiKey_V;
    RaylibKeyMap[KEY_W] = ImGuiKey_W;
    RaylibKeyMap[KEY_X] = ImGuiKey_X;
    RaylibKeyMap[KEY_Y] = ImGuiKey_Y;
    RaylibKeyMap[KEY_Z] = ImGuiKey_Z;
    RaylibKeyMap[KEY_SPACE] = ImGuiKey_Space;
    RaylibKeyMap[KEY_ESCAPE] = ImGuiKey_Escape;
    RaylibKeyMap[KEY_ENTER] = ImGuiKey_Enter;
    RaylibKeyMap[KEY_TAB] = ImGuiKey_Tab;
    RaylibKeyMap[KEY_BACKSPACE] = ImGuiKey_Backspace;
    RaylibKeyMap[KEY_INSERT] = ImGuiKey_Insert;
    RaylibKeyMap[KEY_DELETE] = ImGuiKey_Delete;
    RaylibKeyMap[KEY_RIGHT] = ImGuiKey_RightArrow;
    RaylibKeyMap[KEY_LEFT] = ImGuiKey_LeftArrow;
    RaylibKeyMap[KEY_DOWN] = ImGuiKey_DownArrow;
    RaylibKeyMap[KEY_UP] = ImGuiKey_UpArrow;
    RaylibKeyMap[KEY_PAGE_UP] = ImGuiKey_PageUp;
    RaylibKeyMap[KEY_PAGE_DOWN] = ImGuiKey_PageDown;
    RaylibKeyMap[KEY_HOME] = ImGuiKey_Home;
    RaylibKeyMap[KEY_END] = ImGuiKey_End;
    RaylibKeyMap[KEY_CAPS_LOCK] = ImGuiKey_CapsLock;
    RaylibKeyMap[KEY_SCROLL_LOCK] = ImGuiKey_ScrollLock;
    RaylibKeyMap[KEY_NUM_LOCK] = ImGuiKey_NumLock;
    RaylibKeyMap[KEY_PRINT_SCREEN] = ImGuiKey_PrintScreen;
    RaylibKeyMap[KEY_PAUSE] = ImGuiKey_Pause;
    RaylibKeyMap[KEY_F1] = ImGuiKey_F1;
    RaylibKeyMap[KEY_F2] = ImGuiKey_F2;
    RaylibKeyMap[KEY_F3] = ImGuiKey_F3;
    RaylibKeyMap[KEY_F4] = ImGuiKey_F4;
    RaylibKeyMap[KEY_F5] = ImGuiKey_F5;
    RaylibKeyMap[KEY_F6] = ImGuiKey_F6;
    RaylibKeyMap[KEY_F7] = ImGuiKey_F7;
    RaylibKeyMap[KEY_F8] = ImGuiKey_F8;
    RaylibKeyMap[KEY_F9] = ImGuiKey_F9;
    RaylibKeyMap[KEY_F10] = ImGuiKey_F10;
    RaylibKeyMap[KEY_F11] = ImGuiKey_F11;
    RaylibKeyMap[KEY_F12] = ImGuiKey_F12;
    RaylibKeyMap[KEY_LEFT_SHIFT] = ImGuiKey_LeftShift;
    RaylibKeyMap[KEY_LEFT_CONTROL] = ImGuiKey_LeftCtrl;
    RaylibKeyMap[KEY_LEFT_ALT] = ImGuiKey_LeftAlt;
    RaylibKeyMap[KEY_LEFT_SUPER] = ImGuiKey_LeftSuper;
    RaylibKeyMap[KEY_RIGHT_SHIFT] = ImGuiKey_RightShift;
    RaylibKeyMap[KEY_RIGHT_CONTROL] = ImGuiKey_RightCtrl;
    RaylibKeyMap[KEY_RIGHT_ALT] = ImGuiKey_RightAlt;
    RaylibKeyMap[KEY_RIGHT_SUPER] = ImGuiKey_RightSuper;
    RaylibKeyMap[KEY_KB_MENU] = ImGuiKey_Menu;
    RaylibKeyMap[KEY_LEFT_BRACKET] = ImGuiKey_LeftBracket;
    RaylibKeyMap[KEY_BACKSLASH] = ImGuiKey_Backslash;
    RaylibKeyMap[KEY_RIGHT_BRACKET] = ImGuiKey_RightBracket;
    RaylibKeyMap[KEY_GRAVE] = ImGuiKey_GraveAccent;
    RaylibKeyMap[KEY_KP_0] = ImGuiKey_Keypad0;
    RaylibKeyMap[KEY_KP_1] = ImGuiKey_Keypad1;
    RaylibKeyMap[KEY_KP_2] = ImGuiKey_Keypad2;
    RaylibKeyMap[KEY_KP_3] = ImGuiKey_Keypad3;
    RaylibKeyMap[KEY_KP_4] = ImGuiKey_Keypad4;
    RaylibKeyMap[KEY_KP_5] = ImGuiKey_Keypad5;
    RaylibKeyMap[KEY_KP_6] = ImGuiKey_Keypad6;
    RaylibKeyMap[KEY_KP_7] = ImGuiKey_Keypad7;
    RaylibKeyMap[KEY_KP_8] = ImGuiKey_Keypad8;
    RaylibKeyMap[KEY_KP_9] = ImGuiKey_Keypad9;
    RaylibKeyMap[KEY_KP_DECIMAL] = ImGuiKey_KeypadDecimal;
    RaylibKeyMap[KEY_KP_DIVIDE] = ImGuiKey_KeypadDivide;
    RaylibKeyMap[KEY_KP_MULTIPLY] = ImGuiKey_KeypadMultiply;
    RaylibKeyMap[KEY_KP_SUBTRACT] = ImGuiKey_KeypadSubtract;
    RaylibKeyMap[KEY_KP_ADD] = ImGuiKey_KeypadAdd;
    RaylibKeyMap[KEY_KP_ENTER] = ImGuiKey_KeypadEnter;
    RaylibKeyMap[KEY_KP_EQUAL] = ImGuiKey_KeypadEqual;
}

static void SetupGlobals() {
    LastFrameFocused = IsWindowFocused();
    LastControlPressed = false;
    LastShiftPressed = false;
    LastAltPressed = false;
    LastSuperPressed = false;

}

void rlImGuiBeginInitImGui() {
    SetupGlobals();
    GlobalContext = igCreateContext(NULL);
    SetupKeymap();

    ImGuiIO *io = igGetIO();
    ImFontAtlas_AddFontDefault(io->Fonts, NULL);
}

void rlImGuiSetup(bool dark) {
    rlImGuiBeginInitImGui();

    if (dark)
        igStyleColorsDark(NULL);
    else
        igStyleColorsLight(NULL);

    rlImGuiEndInitImGui();
}

void rlImGuiReloadFonts() {
    igSetCurrentContext(GlobalContext);

    ReloadFonts();
}

void rlImGuiBegin() {
    igSetCurrentContext(GlobalContext);
    rlImGuiBeginDelta(GetFrameTime());
}

void rlImGuiBeginDelta(float deltaTime) {
    igSetCurrentContext(GlobalContext);
    ImGuiNewFrame(deltaTime);
    ImGui_ImplRaylib_ProcessEvents();
    igNewFrame();
}

void rlImGuiEnd() {
    igSetCurrentContext(GlobalContext);
    igRender();
    ImGui_ImplRaylib_RenderDrawData(igGetDrawData());
}

void rlImGuiShutdown() {
    igSetCurrentContext(GlobalContext);
    ImGui_ImplRaylib_Shutdown();

    igDestroyContext(NULL);
}

static ImVec2 defaultUV0 = {0, 0};
static ImVec2 defaultUV1 = {1, 1};
static ImVec4 defaultBgCol = {0, 0, 0, 0};
static ImVec4 defaultTintCol = {1, 1, 1, 1};

void rlImGuiImage(const Texture *image) {
    if (!image)
        return;
    if (GlobalContext)
        igSetCurrentContext(GlobalContext);
    igImage((ImTextureID) image, (ImVec2) {(float) (image->width), (float) (image->height)},
            defaultUV0, defaultUV1, defaultTintCol, defaultBgCol
    );
}

bool rlImGuiImageButton(const char *name, const Texture *image) {
    if (!image)
        return false;
    if (GlobalContext)
        igSetCurrentContext(GlobalContext);
    return igImageButton(name, (ImTextureID) image, (ImVec2) {(float) (image->width), (float) (image->height)},
                         defaultUV0, defaultUV1, defaultBgCol, defaultTintCol
    );
}

bool rlImGuiImageButtonSize(const char *name, const Texture *image, ImVec2 size) {
    if (!image)
        return false;
    if (GlobalContext)
        igSetCurrentContext(GlobalContext);
    return igImageButton(name, (ImTextureID) image, size,
                         defaultUV0, defaultUV1, defaultBgCol, defaultTintCol
    );
}

void rlImGuiImageSize(const Texture *image, int width, int height) {
    if (!image)
        return;
    if (GlobalContext)
        igSetCurrentContext(GlobalContext);
    igImage((ImTextureID) image, (ImVec2) {(float) (width), (float) (height)},
            defaultUV0, defaultUV1, defaultTintCol, defaultBgCol
    );
}

void rlImGuiImageSizeV(const Texture *image, Vector2 size) {
    if (!image)
        return;
    if (GlobalContext)
        igSetCurrentContext(GlobalContext);
    igImage((ImTextureID) image, (ImVec2) {size.x, size.y},
            defaultUV0, defaultUV1, defaultTintCol, defaultBgCol
    );
}

void rlImGuiImageRect(const Texture *image, int destWidth, int destHeight, Rectangle sourceRect) {
    if (!image)
        return;
    if (GlobalContext)
        igSetCurrentContext(GlobalContext);
    ImVec2 uv0;
    ImVec2 uv1;

    if (sourceRect.width < 0) {
        uv0.x = -((float) sourceRect.x / image->width);
        uv1.x = (uv0.x - (float) (fabs(sourceRect.width) / image->width));
    } else {
        uv0.x = (float) sourceRect.x / image->width;
        uv1.x = uv0.x + (float) (sourceRect.width / image->width);
    }

    if (sourceRect.height < 0) {
        uv0.y = -((float) sourceRect.y / image->height);
        uv1.y = (uv0.y - (float) (fabs(sourceRect.height) / image->height));
    } else {
        uv0.y = (float) sourceRect.y / image->height;
        uv1.y = uv0.y + (float) (sourceRect.height / image->height);
    }

    igImage((ImTextureID) image, (ImVec2) {
            (float) (destWidth),
            (float) (destHeight)}, uv0, uv1, defaultTintCol, defaultBgCol);
}

void rlImGuiImageRenderTexture(const RenderTexture *image) {
    if (!image)
        return;
    if (GlobalContext)
        igSetCurrentContext(GlobalContext);
    rlImGuiImageRect(&image->texture, image->texture.width, image->texture.height, (Rectangle) {
            0, 0, (float) (image->texture.width), -(float) (image->texture.height)
    });
}

void rlImGuiImageRenderTextureFit(const RenderTexture *image, bool center) {
    if (!image)
        return;
    if (GlobalContext)
        igSetCurrentContext(GlobalContext);

    ImVec2 area;
    igGetContentRegionAvail(&area);

    float scale = area.x / image->texture.width;

    float y = image->texture.height * scale;
    if (y > area.y) {
        scale = area.y / image->texture.height;
    }

    int sizeX = (int) (image->texture.width * scale);
    int sizeY = (int) (image->texture.height * scale);

    if (center) {
        igSetCursorPosX(0);
        igSetCursorPosX(area.x / 2 - sizeX / 2);
        igSetCursorPosY(igGetCursorPosY() + (area.y / 2 - sizeY / 2));
    }

    rlImGuiImageRect(&image->texture, sizeX, sizeY, (Rectangle) {
            0, 0, (float) (image->texture.width), -(float) (image->texture.height)
    });
}

// raw ImGui backend API
bool ImGui_ImplRaylib_Init() {
    SetupGlobals();

    SetupKeymap();

    ImGuiIO *io = igGetIO();
    ImFontAtlas_AddFontDefault(io->Fonts, NULL);

    SetupFontAwesome();

    SetupMouseCursors();

    SetupBackend();

    ReloadFonts();

    return true;
}

void ImGui_ImplRaylib_Shutdown() {
    ImGuiIO *io = igGetIO();

    Texture2D *fontTexture = (Texture2D *) io->Fonts->TexID;

    if (fontTexture && fontTexture->id != 0)
        UnloadTexture(*fontTexture);

    io->Fonts->TexID = 0;
}

void ImGui_ImplRaylib_NewFrame() {
    ImGuiNewFrame(GetFrameTime());
}

void ImGui_ImplRaylib_RenderDrawData(ImDrawData *draw_data) {
    rlDrawRenderBatchActive();
    rlDisableBackfaceCulling();

    for (int l = 0; l < draw_data->CmdListsCount; ++l) {
        const ImDrawList *commandList = draw_data->CmdLists.Data[l];
        const ImDrawVert *vtxBuffer = commandList->VtxBuffer.Data;
        const ImDrawIdx *idxBuffer = commandList->IdxBuffer.Data;

        for (int cmd_i = 0; cmd_i < commandList->CmdBuffer.Size; cmd_i++) {
            const ImDrawCmd cmd = commandList->CmdBuffer.Data[cmd_i];
            EnableScissor(cmd.ClipRect.x - draw_data->DisplayPos.x, cmd.ClipRect.y - draw_data->DisplayPos.y,
                          cmd.ClipRect.z - (cmd.ClipRect.x - draw_data->DisplayPos.x),
                          cmd.ClipRect.w - (cmd.ClipRect.y - draw_data->DisplayPos.y));
            if (cmd.UserCallback != NULL) {
                cmd.UserCallback(commandList, &cmd);

                continue;
            }

            ImGuiRenderTriangles(cmd.ElemCount, cmd.IdxOffset, &commandList->IdxBuffer, &commandList->VtxBuffer,
                                 cmd.TextureId);
            rlDrawRenderBatchActive();
        }
    }

    rlSetTexture(0);
    rlDisableScissorTest();
    rlEnableBackfaceCulling();
}

bool ImGui_ImplRaylib_ProcessEvents() {
    ImGuiIO *io = igGetIO();

    bool focused = IsWindowFocused();
    if (focused != LastFrameFocused)
        ImGuiIO_AddFocusEvent(io, focused);
    LastFrameFocused = focused;

    // handle the modifyer key events so that shortcuts work
    bool ctrlDown = rlImGuiIsControlDown();
    if (ctrlDown != LastControlPressed)
        ImGuiIO_AddKeyEvent(io, ImGuiMod_Ctrl, ctrlDown);
    LastControlPressed = ctrlDown;

    bool shiftDown = rlImGuiIsShiftDown();
    if (shiftDown != LastShiftPressed)
        ImGuiIO_AddKeyEvent(io, ImGuiMod_Shift, shiftDown);
    LastShiftPressed = shiftDown;

    bool altDown = rlImGuiIsAltDown();
    if (altDown != LastAltPressed)
        ImGuiIO_AddKeyEvent(io, ImGuiMod_Alt, altDown);
    LastAltPressed = altDown;

    bool superDown = rlImGuiIsSuperDown();
    if (superDown != LastSuperPressed)
        ImGuiIO_AddKeyEvent(io, ImGuiMod_Super, superDown);
    LastSuperPressed = superDown;

    // get the pressed keys, they are in event order
    int keyId = GetKeyPressed();
    while (keyId != 0) {
        ImGuiKey keyItr = RaylibKeyMap[(KeyboardKey)(keyId)];
        if (keyItr != 0)
            ImGuiIO_AddKeyEvent(io, keyItr, true);
        keyId = GetKeyPressed();
    }

    // look for any keys that were down last frame and see if they were down and are released
    for (int i = 0; i < KEY_MAP_SIZE; i++) {
        if (RaylibKeyMap[i] == 0) continue;
        if (IsKeyReleased(i))
            ImGuiIO_AddKeyEvent(io, RaylibKeyMap[i], false);
    }

    // add the text input in order
    unsigned int pressed = GetCharPressed();
    while (pressed != 0) {
        ImGuiIO_AddInputCharacter(io, pressed);
        pressed = GetCharPressed();
    }

    return true;
}