#include "config.h"
#include "imgui.h"
#include "imgui_impl_sdl2.h"
#include "imgui_impl_opengl3.h"
#include "file_browser.h"
#include "playback.h"
#include "theme.h"
#include "assets.h"
#include "IconsForkAwesome.h"
#include <libintl.h>
#include <iostream>
#include <fstream>
#include <json/json.h>
#include <stdio.h>
#include <numbers>
#include <cmath>
#include <cstdlib>
#include <string>
#include <SDL.h>
#include <SDL_image.h>
#include <filesystem>
#include <SDL_video.h>
#if defined(IMGUI_IMPL_OPENGL_ES2)
#include <SDL_opengles2.h>
#else
#include <SDL_opengl.h>
#endif
#include "license.h"
#include "base85.h"
static const char* NAME = "Neko Player";
#ifdef __EMSCRIPTEN__
#include "../libs/emscripten/emscripten_mainloop_stub.h"
#endif
#include <translation.h>
using namespace std::filesystem;
using namespace std::numbers;
using std::string;
static float accent_color = 280.0;

string PadZeros(string input, size_t required_length) {
    return std::string(required_length - std::min(required_length, input.length()), '0') + input;
}
uint8_t TimeToComponentCount(double time_code) {
    int seconds = (int)time_code;
    int minutes = seconds / 60;
    seconds -= minutes * 60;
    int hours = minutes / 60;
    minutes -= hours * 60;
    if (hours > 0) {
        return 3;
    } else if (minutes > 0) {
        return 2;
    } else {
        return 1;
    }
}
string TimeToString(double time_code, uint8_t min_components = 1) {
    uint8_t components = std::max(TimeToComponentCount(time_code), min_components);
    int seconds = (int)time_code;
    int minutes = seconds / 60;
    seconds -= minutes * 60;
    int hours = minutes / 60;
    minutes -= hours * 60;
    string output = PadZeros(std::to_string(seconds), components < 2 ? 1 : 2);
    if (components >= 2) {
        output = PadZeros(std::to_string(minutes), components == 2 ? 1 : 2) + ":" + output;
    }
    if (components >= 3) {
        output = PadZeros(std::to_string(hours), components == 3 ? 1 : 2) + ":" + output;
    }
    return output;
}

struct FontData {
    const char* data;
    const ImWchar *ranges;
};

ImFont *add_font(vector<FontData> data_vec, int size = 13) {
    ImFont* font = nullptr;
    ImGuiIO& io = ImGui::GetIO();
    for (auto data : data_vec) {
        ImFontConfig font_cfg = ImFontConfig();
        font_cfg.SizePixels = size;
        font_cfg.OversampleH = font_cfg.OversampleV = 1;
        font_cfg.PixelSnapH = true;
        if (font_cfg.SizePixels <= 0.0f)
            font_cfg.SizePixels = 13.0f * 1.0f;
        if (font != nullptr) {
            font_cfg.DstFont = font;
            font_cfg.MergeMode = true;
        }
        //font_cfg.EllipsisChar = (ImWchar)0x0085;
        //font_cfg.GlyphOffset.y = 1.0f * IM_FLOOR(font_cfg.SizePixels / 13.0f);  // Add +1 offset per 13 units

        const char* ttf_compressed_base85 = data.data;
        const ImWchar* glyph_ranges = data.ranges;
        auto new_font = io.Fonts->AddFontFromMemoryCompressedBase85TTF(ttf_compressed_base85, font_cfg.SizePixels, &font_cfg, glyph_ranges);
        if (font == nullptr) font = new_font;
    }
    {
        ImFontConfig config;
        config.MergeMode = true;
        config.GlyphMinAdvanceX = size;
        config.SizePixels = size;
        config.DstFont = font;
        static const ImWchar icon_ranges[] = { ICON_MIN_FK, ICON_MAX_FK, 0 };
        io.Fonts->AddFontFromMemoryCompressedBase85TTF(forkawesome_compressed_data_base85, float(size), &config, icon_ranges);
    }
    return font;
}
// Main code
int main(int, char**)
{
    bindtextdomain("neko_player", LOCALE_DIR);
    #ifdef PORTALS
    g_set_application_name("Neko Player");
    #endif
    bool enable_kms = std::getenv("LAP_KMS") != nullptr;
    SDL_SetHint(SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR, "false");
    SDL_SetHint(SDL_HINT_APP_NAME, NAME);
    // Setup SDL
    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_GAMECONTROLLER) != 0)
    {
        printf("Error: %s\n", SDL_GetError());
        return -1;
    }
    if (std::string(SDL_GetCurrentVideoDriver()) == "KMSDRM") {
        enable_kms = true;
    }
    IMG_Init(IMG_INIT_PNG|IMG_INIT_WEBP);
    const char* prefPath = SDL_GetPrefPath("Catmeow72", NAME);
    Theme::prefPath = prefPath;

    // Decide GL+GLSL versions
#if defined(IMGUI_IMPL_OPENGL_ES2)
    // GL ES 2.0 + GLSL 100
    const char* glsl_version = "#version 100";
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
#elif defined(__APPLE__)
    // GL 3.2 Core + GLSL 150
    const char* glsl_version = "#version 150";
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG); // Always required on Mac
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
#else
    // GL 3.0 + GLSL 130
    const char* glsl_version = "#version 130";
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
#endif

    // From 2.0.18: Enable native IME.
#ifdef SDL_HINT_IME_SHOW_UI
    SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");
#endif

    // Create window with graphics context
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
    SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
    int window_width = 475;
    int window_height = 354;
    SDL_WindowFlags window_flags = (SDL_WindowFlags)(SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
    SDL_Window* window = SDL_CreateWindow(NAME, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, window_width, window_height, window_flags);
    SDL_SetWindowMinimumSize(window, window_width, window_height);
    if (enable_kms) {
        SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
    }
    const vector<unsigned char> icon_data = DecodeBase85(icon_compressed_data_base85);
    SDL_Surface* icon = IMG_Load_RW(SDL_RWFromConstMem(icon_data.data(), icon_data.size()), 1);
    SDL_SetWindowIcon(window, icon);
    SDL_GLContext gl_context = SDL_GL_CreateContext(window);
    SDL_GL_MakeCurrent(window, gl_context);

    // Setup Dear ImGui context
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGuiIO& io = ImGui::GetIO(); (void)io;
    io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
    io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
    //io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
    io.IniFilename = strdup((std::string(prefPath) + "imgui.ini").c_str());
    if (enable_kms) {
        io.MouseDrawCursor = true;
    }
    //io.ConfigViewportsNoAutoMerge = true;
    //io.ConfigViewportsNoTaskBarIcon = true;

    //ImGui::StyleColorsLight();

    // Setup Platform/Renderer backends
    ImGui_ImplSDL2_InitForOpenGL(window, gl_context);
    ImGui_ImplOpenGL3_Init(glsl_version);

    // Load Fonts
    // - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them.
    // - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple.
    // - If the file cannot be loaded, the function will return a nullptr. Please handle those errors in your application (e.g. use an assertion, or display an error and quit).
    // - The fonts will be rasterized at a given size (w/ oversampling) and stored into a texture when calling ImFontAtlas::Build()/GetTexDataAsXXXX(), which ImGui_ImplXXXX_NewFrame below will call.
    // - Use '#define IMGUI_ENABLE_FREETYPE' in your imconfig file to use Freetype for higher quality font rendering.
    // - Read 'docs/FONTS.md' for more instructions and details.
    // - Remember that in C/C++ if you want to include a backslash \ in a string literal you need to write a double backslash \\ !
    //io.Fonts->AddFontDefault();
    //io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\segoeui.ttf", 18.0f);
    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf", 16.0f);
    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf", 16.0f);
    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf", 15.0f);
    //ImFont* font = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, nullptr, io.Fonts->GetGlyphRangesJapanese());
    //IM_ASSERT(font != nullptr);
    add_font({FontData {notosans_regular_compressed_data_base85, io.Fonts->GetGlyphRangesDefault()}, FontData {notosansjp_regular_compressed_data_base85, io.Fonts->GetGlyphRangesJapanese()}});
    ImFont *title = add_font({FontData {notosans_thin_compressed_data_base85, io.Fonts->GetGlyphRangesDefault()}, FontData {notosansjp_thin_compressed_data_base85, io.Fonts->GetGlyphRangesJapanese()}}, 48);

    // Our state
    bool show_demo_window = false;
    ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);

    FileBrowser fileDialog(false, ImGuiFileBrowserFlags_NoTitleBar|ImGuiFileBrowserFlags_NoMove|ImGuiFileBrowserFlags_NoResize);
    fileDialog.SetTitle(_TR_CTX("File dialog title", "Open..."));
    fileDialog.SetTypeFilters(_TR_CTX("File dialog filter name", "Audio files"), { ".wav", ".ogg", ".mp3", ".qoa", ".flac", ".xm", ".mod"});
    std::string userdir = std::getenv(
    #ifdef _WIN32
    "UserProfile"
    #else
    "HOME"
    #endif
    );
    fileDialog.SetPwd(path(userdir) / path("Music"));
    fileDialog.SetWindowSize(window_width, window_height);
    //fileDialog.SetWindowPos(0, 0);
    Playback *playback = new Playback();
    float position = 0.0;
    // Main loop
    bool done = false;
    Theme *theme = new Theme(false);
    bool prefs_window = false;
    bool theme_editor = false;
    bool stopped = true;
    bool vsync = false;
    bool about_window = false;
    currentLanguage = "osdefault";
    int framerate = 60;
    {
        Json::Value config;
        std::ifstream stream;
        stream.open(path(prefPath) / "config.json");
        if (stream.is_open()) {
            stream >> config;
            if (config.isMember("theme_name")) {
                path themePath = theme->themeDir / config["theme_name"].asString();
                if (exists(themePath)) {
                    delete theme;
                    theme = new Theme(themePath);
                }
            }
            if (config.isMember("accent_color")) {
                accent_color = config["accent_color"].asFloat();
            }
            if (config.isMember("demo_window")) {
                show_demo_window = config["demo_window"].asBool();
            }
            if (config.isMember("vsync")) {
                vsync = config["vsync"].asBool();
            }
            if (config.isMember("framerate")) {
                framerate = config["framerate"].asUInt();
            }
            if (config.isMember("lang")) {
                currentLanguage = config["lang"].asString();
            }
            stream.close();
        } 
        if (is_empty(Theme::themeDir)) {
            path lightPath = Theme::themeDir / "light.json";
            path darkPath = Theme::themeDir / "dark.json";
            if (!exists(lightPath)) {
                Theme light(false);
                light.Save(lightPath);
            }
            if (!exists(darkPath)) {
                Theme dark(true);
                dark.Save(darkPath);
            }
            delete theme;
            theme = new Theme(darkPath);
        }
    }
    SDL_GL_SetSwapInterval(vsync ? 1 : 0);
    theme->Apply(accent_color);
#ifdef __EMSCRIPTEN__
    // For an Emscripten build we are disabling file-system access, so let's not attempt to do a fopen() of the imgui.ini file.
    // You may manually call LoadIniSettingsFromMemory() to load settings from your own storage.
    io.IniFilename = nullptr;
    EMSCRIPTEN_MAINLOOP_BEGIN
#else
    while (!done)
#endif
    {/*
        {
            int min_x;
            int min_y;
            SDL_GetWindowMinimumSize(window, &min_x, &min_y);
            int height = ImGui::GetFrameHeightWithSpacing() + ImGui::GetFrameHeight() + (ImGui::GetStyle().WindowPadding.y * 2) + ((ImGui::GetStyle().FramePadding.y * 2) + ImGui::GetFontSize());
            if (height != min_y) {
                min_y = height;
                SDL_SetWindowMinimumSize(window, 475, min_y);
            }
        }*/
        auto next_frame = std::chrono::steady_clock::now() + std::chrono::milliseconds(1000 / framerate);
        position = playback->GetPosition();
        // Poll and handle events (inputs, window resize, etc.)
        // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
        // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
        // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
        // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
        SDL_Event event;
        while (SDL_PollEvent(&event))
        {
            ImGui_ImplSDL2_ProcessEvent(&event);
            if (event.type == SDL_QUIT)
                done = true;
            if (event.type == SDL_WINDOWEVENT) {
                if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
                    window_width = event.window.data1;
                    window_height = event.window.data2;
                    //SDL_GetWindowSize(window, &window_width, &window_height);
                }
                if (event.window.event == SDL_WINDOWEVENT_CLOSE && event.window.windowID == SDL_GetWindowID(window)) {
                    done = true;
                }
            }
        }

        // Start the Dear ImGui frame
        ImGui_ImplOpenGL3_NewFrame();
        ImGui_ImplSDL2_NewFrame();
        ImGui::NewFrame();
        auto dockid = ImGui::DockSpaceOverViewport(nullptr, ImGuiDockNodeFlags_PassthruCentralNode|ImGuiDockNodeFlags_AutoHideTabBar);
        // 1. Show the big demo window (Most of the sample code is in ImGui::ShowDemoWindow()! You can browse its code to learn more about Dear ImGui!).
        if (show_demo_window)
            ImGui::ShowDemoWindow(&show_demo_window);
        if (ImGui::BeginMainMenuBar()) {
            if (ImGui::BeginMenu(_TRI_CTX(ICON_FK_FILE, "Main menu", "File"))) {
                if (ImGui::MenuItem(_TRI_CTX(ICON_FK_FOLDER_OPEN, "Main menu > File", "Open"))) {
                    fileDialog.Open();
                }
                if (ImGui::MenuItem(_TRI_CTX(ICON_FK_WINDOW_CLOSE, "Main menu > File", "Quit"))) {
                    done = true;
                }
                ImGui::EndMenu();
            }
            if (ImGui::BeginMenu(_TRI_CTX(ICON_FK_SCISSORS,"Main menu", "Edit"))) {
                if (ImGui::MenuItem(_TRI_CTX(ICON_FK_COG, "Main menu > Edit", "Preferences..."))) {
                    prefs_window = true;
                }
                ImGui::EndMenu();
            }
            #ifdef DEBUG
            if (ImGui::BeginMenu(_TRI_CTX(ICON_FK_COG, "Main menu (in debug builds)", "Debug"))) {
                if (ImGui::MenuItem(_TR_CTX("Main menu > Debug", "Show ImGui Demo Window"), nullptr, show_demo_window)) {
                    show_demo_window = !show_demo_window;
                }
                ImGui::EndMenu();
            }
            #endif
            if (ImGui::BeginMenu(_TRI_CTX(ICON_FK_INFO_CIRCLE, "Main menu", "Help"))) {
                if (ImGui::MenuItem(_TRI_CTX(ICON_FK_INFO, "Main menu > Help", "About"), nullptr, about_window)) {
                    about_window = !about_window;
                }
                ImGui::EndMenu();
            }
            ImGui::EndMainMenuBar();
        }
        ImGui::SetNextWindowDockID(dockid);
        ImGui::Begin(_TRI_CTX(ICON_FK_PLAY, "Main window title", "Player"), nullptr, 0);
        {
            ImGui::SetCursorPosY(ImGui::GetWindowHeight() - ImGui::GetFrameHeightWithSpacing() - ImGui::GetFrameHeight() - ImGui::GetStyle().WindowPadding.y);
            if (ImGui::Button(playback->IsPaused() ? ICON_FK_PLAY "##Pause" : ICON_FK_PAUSE "##Pause")) {
                playback->Pause();
            }
            ImGui::SameLine();
            if (ImGui::Button(ICON_FK_REFRESH "##Restart")) {
                playback->Seek(0.0);
            }
            ImGui::SameLine();
            const int NEXT_SLIDER_COUNT = 1;
            ImGui::SetNextItemWidth(-(ImGui::GetFontSize() * (1 + (8 * NEXT_SLIDER_COUNT))) - ((ImGui::GetStyle().ItemSpacing.x + ImGui::GetStyle().FramePadding.x) * (NEXT_SLIDER_COUNT + 1)));
            uint8_t components = TimeToComponentCount(playback->GetLength());
            string time_str = TimeToString(position, components);
            if (ImGui::SliderFloat("##Seek", &position, 0.0f, playback->GetLength(), time_str.c_str(), ImGuiSliderFlags_NoRoundToFormat))
                playback->Seek(position);
            ImGui::SameLine();
            if (ImGui::Button(ICON_FK_STOP "##Stop")) {
                playback->Stop();
            }
            ImGui::SameLine();
            ImGui::SetNextItemWidth(ImGui::GetFontSize() * 8);
            if (ImGui::SliderFloat("##Volume", &playback->volume, 0.0, 100.0, ICON_FK_VOLUME_UP ": %.0f%%")) {
                playback->Update();
            }
            const float items = 3.0f;
            const float between_items = items - 1.0f;
            ImGui::PushItemWidth((ImGui::GetWindowWidth() / items) - (ImGui::GetStyle().ItemSpacing.x / (items / between_items)) - ((ImGui::GetStyle().WindowPadding.x / items) * 2.0f));
            if (ImGui::SliderFloat("##Speed", &playback->speed, 0.25, 4.0, _TR_CTX("Playback controls > slider", "Speed: %.2fx"), ImGuiSliderFlags_Logarithmic)) {
                playback->Update();
            }
            ImGui::SameLine();
            if (ImGui::SliderFloat("##Tempo", &playback->tempo, 0.25, 4.0, _TR_CTX("Playback controls > slider", "Tempo: %.2fx"), ImGuiSliderFlags_Logarithmic)) {
                playback->Update();
            }
            ImGui::SameLine();
            if (ImGui::SliderFloat("##Pitch", &playback->pitch, 0.25, 4.0, _TR_CTX("Playback controls > slider", "Pitch: %.2fx"), ImGuiSliderFlags_Logarithmic)) {
                playback->Update();
            }
            ImGui::PopItemWidth();
        }
        ImGui::End();
        if (prefs_window) {
            ImGui::SetNextWindowDockID(dockid);
            ImGui::Begin(_TRI_CTX(ICON_FK_COG, "Window title, window opened by menu item", "Preferences..."), &prefs_window);
            {
                if (ImGui::Checkbox(_TR_CTX("Preference > VSync checkbox", "Enable VSync"), &vsync)) {
                    SDL_GL_SetSwapInterval(vsync ? 1 : 0);
                }
                ImGui::SameLine();
                ImGui::SetNextItemWidth(ImGui::GetWindowWidth() - ImGui::GetCursorPosX() - ImGui::GetStyle().WindowPadding.x);
                ImGui::SliderInt("##Framerate", &framerate, 10, 480, _TR_CTX("Preferences > Framerate slider", "Max framerate without VSync: %d"));
                if (ImGui::Button(_TRI_CTX(ICON_FK_MAGIC, "Preference > Related non-preference button", "Theme Editor"), ImVec2(ImGui::GetWindowWidth() - (ImGui::GetStyle().WindowPadding.x * 2.0f), 0))) {
                    theme_editor = true;
                }
                static char filter[1024] = {0};
                ImGui::Text(_TR_CTX("Preference > Theme selector > Filter label", "Filter:")); ImGui::SameLine();
                ImGui::SetNextItemWidth(ImGui::GetWindowWidth() - ImGui::GetCursorPosX() - ImGui::GetStyle().WindowPadding.x);
                ImGui::InputText("##FilterInput", filter, 1024);
                ImGui::Text(_TR_CTX("Preferences > Theme selector > Selector label", "Select a theme..."));
                ImVec2 ChildSize = ImVec2(ImGui::GetWindowWidth() - (ImGui::GetStyle().WindowPadding.x * 2.0f), -ImGui::GetFrameHeightWithSpacing());
                if (ImGui::BeginChildFrame(ImGui::GetID("##ThemesContainer"), ChildSize)) {
                    ImVec2 TableSize = ImVec2(0, 0);
                    if (ImGui::BeginTable("##Themes", 2, ImGuiTableFlags_SizingFixedFit|ImGuiTableFlags_NoSavedSettings|ImGuiTableFlags_ScrollY, TableSize)) {
                        // Text in TableSetupColumn calls not translated because they're not visible to the user.
                        ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_WidthStretch);
                        ImGui::TableSetupColumn("Remove", 0);
                        for (auto themePath : Theme::availableThemes) {
                            if (themePath.stem().string().starts_with(filter)) {
                                ImGui::TableNextRow();
                                ImGui::TableSetColumnIndex(0);
                                const bool is_selected = themePath == theme->file_path;
                                if (ImGui::Selectable(themePath.stem().generic_string().c_str(), is_selected, 0)) {
                                    delete theme;
                                    theme = new Theme(themePath);
                                    theme->Apply(accent_color);
                                    break;
                                }
                                if (is_selected) {
                                    ImGui::SetItemDefaultFocus();
                                } else {
                                    ImGui::TableSetColumnIndex(1);
                                    if (ImGui::SmallButton((string(ICON_FK_WINDOW_CLOSE "##") + themePath.stem().generic_string()).c_str())) {
                                        std::filesystem::remove(themePath);
                                        Theme::updateAvailableThemes();
                                        break;
                                    }
                                }
                            }
                        }
                        ImGui::EndTable();
                    }
                }
                ImGui::EndChildFrame();    
                ImGui::SetNextItemWidth(ImGui::GetWindowWidth() - (ImGui::GetStyle().WindowPadding.x * 2));
                if (ImGui::SliderFloat("##AccentColor", &accent_color, 0.0, 360.0, _TR_CTX("Preference > Accent hue slider, range 0-360 from HSV algorithm hue component", "Accent color hue: %.0f°"), ImGuiSliderFlags_NoRoundToFormat)) {
                    theme->Apply(accent_color);
		        }
            }
            ImGui::End();
        }
        if (about_window) {
            ImGui::SetNextWindowDockID(dockid);
            if (ImGui::Begin(_TRI_CTX(ICON_FK_INFO, "Window title, window opened by menu item", "About and Licenses"), &about_window)) {
                ImGui::PushFont(title);
                static const string APP_NAME_STR = _TR_CTX("Application name - Japanese word should remain Japanese and stay the same when translating for stylistic purposes.", "ねこ Player");
                ImGui::SetCursorPosX((ImGui::GetWindowWidth() - ImGui::GetFont()->CalcTextSizeA(ImGui::GetFontSize(), FLT_MAX, 0.0f, APP_NAME_STR.c_str()).x) / 2.0f);
                ImGui::Text(APP_NAME_STR.c_str());
                ImGui::PopFont();
                static const string APP_NAME_ROMANIZED = _TR_CTX("Application name - Japanese word should be converted to the translated language's characters. Use an empty string to disable for Japanese.", "(Neko Player)");
                if (APP_NAME_ROMANIZED != "") {
                    ImGui::SetCursorPosX((ImGui::GetWindowWidth() - ImGui::GetFont()->CalcTextSizeA(ImGui::GetFontSize(), FLT_MAX, 0.0f, APP_NAME_ROMANIZED.c_str()).x) / 2.0f);
                    ImGui::Text(APP_NAME_ROMANIZED.c_str());
                }
                static const string VER_STRING = _TR_CTX("Version string format specifier", "Version ") + string(TAG) + _TRS_CTX("Suffix to the version string in the about window, if needed", " ");
                ImGui::SetCursorPosX((ImGui::GetWindowWidth() - ImGui::GetFont()->CalcTextSizeA(ImGui::GetFontSize(), FLT_MAX, 0.0f, VER_STRING.c_str()).x) / 2.0f);
                ImGui::Text(VER_STRING.c_str());
                ImGui::NewLine();
                static vector<LicenseData> projects = {
                    LicenseData(APP_NAME_STR, "MIT"),
                    LicenseData(_TR_CTX("Library name", "SDL Mixer X"), "Zlib"),
                    LicenseData(_TR_CTX("Library name", "JsonCpp"), "MIT"),
                    LicenseData(_TR_CTX("Library name", "SoundTouch"), "LGPL-2.1-only"),
                    LicenseData(_TR_CTX("Library name", "libintl"), "LGPL-2.1-only"),
                    LicenseData(_TR_CTX("Library name", "Dear ImGui"), "MIT"),
                    LicenseData(_TR_CTX("Library name", "imgui-filebrowser"), "MIT"),
                    #ifdef PORTALS
                    LicenseData(_TR_CTX("Library name", "libportal"), "LGPL-3.0-only"), // Only include the license if it applies.
                    #endif
                    LicenseData(_TR_CTX("Library name", "Noto Sans"), "OFL-1.1-RFN"),
                    LicenseData(_TR_CTX("Library name", "Fork Awesome"), "OFL-1.1-RFN"),
                    LicenseData(_TR_CTX("Library name", "IconFontCppHeaders"), "Zlib")
                };
                // Do this in an inner scope so that 'i' isn't accidentally used outside it,
                // and so that 'i' can refer to another variable such as in a for loop.
                {
                    int i = 0;
                    // Use a variable instead of hardcoding so that a #ifdef can change the indices later on.
                    LOAD_LICENSE(projects[i], nekoplayer); i++;
                    LOAD_LICENSE(projects[i], sdl_mixer_x); i++;
                    LOAD_LICENSE(projects[i], jsoncpp); i++;
                    LOAD_LICENSE(projects[i], soundtouch); i++;
                    LOAD_LICENSE(projects[i], libintl); i++;
                    LOAD_LICENSE(projects[i], imgui); i++;
                    LOAD_LICENSE(projects[i], imgui_filebrowser); i++;
                    #ifdef PORTALS
                    LOAD_LICENSE(projects[i], libportal); i++;
                    #endif
                    LOAD_LICENSE(projects[i], notosans); i++;
                    LOAD_LICENSE(projects[i], forkawesome); i++;
                    LOAD_LICENSE(projects[i], icnfntcpphdrs); i++;
                }
                // Left
                static LicenseData selected = projects[0];
                {
                    ImGui::BeginGroup();
                    ImGui::TextUnformatted(_TR_CTX("Project selector label.", "Project"));
                    // Next string is internal.
                    ImGui::BeginChild("project selector", ImVec2(150, 0), true);
                    for (auto project : projects)
                    {
                        if (ImGui::Selectable(project.Project.c_str(), selected.Project == project.Project))
                            selected = project;
                    }
                    ImGui::EndChild();
                    ImGui::EndGroup();
                }
                ImGui::SameLine();
                // Right
                {
                    ImGui::BeginGroup();
                    ImGui::TextUnformatted(_TR_CTX("License viewer label", "License"));
                    // Next string is internal.
                    ImGui::BeginChild("license view", ImVec2(0, 0), true); // *don't* leave room for the nonexistant line below us!
                    ImGui::Text(_TR_CTX("License viewer > information above license - string 1: selected project, string 2: SPDX license identifier", "%s: %s"), selected.Project.c_str(), selected.Spdx.c_str());
                    ImGui::Separator();
                    ImGui::TextWrapped("%s", selected.LicenseContents.c_str());
                    ImGui::EndChild();
                    ImGui::EndGroup();
                }
            }
            ImGui::End();
        }
        if (theme_editor) {
            Theme::ShowEditor(&theme_editor, theme, dockid, window_width, window_height);
            theme->Apply(accent_color);
        }
        if (fileDialog.IsOpened()) {
            fileDialog.SetWindowSize(window_width, window_height);
            fileDialog.SetWindowPos(0, 0);
        }
        fileDialog.Display();

        if (fileDialog.HasSelected()) {
            playback->Start(fileDialog.GetSelected().string());
            SDL_SetWindowTitle(window, (fileDialog.GetSelected().filename().replace_extension("").string() + std::string(" - ") + std::string(NAME)).c_str());
            fileDialog.ClearSelected();
        }
        if (playback->IsStopped() && !stopped) {
            SDL_SetWindowTitle(window, NAME);
        }
        // Rendering
        ImGui::Render();
        glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y);
        glClearColor(clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w, clear_color.w);
        glClear(GL_COLOR_BUFFER_BIT);
        ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

        // Update and Render additional Platform Windows
        // (Platform functions may change the current OpenGL context, so we save/restore it to make it easier to paste this code elsewhere.
        //  For this specific demo app we could also call SDL_GL_MakeCurrent(window, gl_context) directly)
        if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
        {
            SDL_Window* backup_current_window = SDL_GL_GetCurrentWindow();
            SDL_GLContext backup_current_context = SDL_GL_GetCurrentContext();
            ImGui::UpdatePlatformWindows();
            ImGui::RenderPlatformWindowsDefault();
            SDL_GL_MakeCurrent(backup_current_window, backup_current_context);
        }

        SDL_GL_SwapWindow(window);
        if (!vsync) {
            std::this_thread::sleep_until(next_frame);
        }
    }
    // Cleanup
#ifdef __EMSCRIPTEN__
    EMSCRIPTEN_MAINLOOP_END;
#endif
    delete playback;

    // Cleanup
    ImGui_ImplOpenGL3_Shutdown();
    ImGui_ImplSDL2_Shutdown();
    ImGui::DestroyContext();

    SDL_GL_DeleteContext(gl_context);
    SDL_DestroyWindow(window);
    IMG_Quit();
    SDL_Quit();
    {
        Json::Value config;
        std::ofstream stream;
        stream.open(path(prefPath) / "config.json");
        path themePath(theme->file_path);
        themePath = themePath.filename();
        if (!themePath.empty()) {
            config["theme_name"] = themePath.filename().string();
        }
        config["accent_color"] = accent_color;
        config["demo_window"] = show_demo_window;
        config["vsync"] = vsync;
        config["framerate"] = framerate;
        config["lang"] = currentLanguage;
        stream << config;
        stream.close();
    }
    free((void*)io.IniFilename);
    return 0;
}