#include "bookmouse.hpp"

#include "bookmouse_time.hpp"
#include "file_dialog.hpp"

#include <SDL_opengl.h>
#include <atomic>
#include <fud_assert.hpp>
#include <fud_array.hpp>
#include <fud_directory.hpp>
#include <spdlog/spdlog.h>
#include <vector>

namespace bookmouse {

using fud::assertFail;

constexpr const char* OpenDialogHandle = "Open File";

Bookmouse::Bookmouse() :
    m_sdlContext{}, m_mainWindow{m_sdlContext}, m_glContext{m_mainWindow},
    m_imgui{m_glContext, m_sdlContext, m_mainWindow},
    m_directory{m_directoryName}
{
    /*
     * 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() or
     *   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.
     * auto imguiIO = m_imgui.getIO();
     * imguiIO.Fonts->AddFontDefault();
     * imguiIO.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\segoeui.ttf", 18.0f);
     * imguiIO.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf", 16.0f);
     * imguiIO.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf", 16.0f);
     * imguiIO.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf", 15.0f);
     * ImFont* font = imguiIO.Fonts->AddFontFromFileTTF(
     *    "c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, nullptr,
     * io.Fonts->GetGlyphRangesJapanese()); IM_ASSERT(font != nullptr);
     */
}

int Bookmouse::run()
{
    while (m_running) {
        auto event = pollEvent();
        static_cast<void>(event);

        constexpr uint32_t delayMillis = 10;
        if (SDL_GetWindowFlags(m_mainWindow.window()) & SDL_WINDOW_MINIMIZED) {
            SDL_Delay(delayMillis);
            continue;
        }
        m_imgui.startFrame();
        updateState();
        renderFrame();
    }
    return 0;
}

SDL_Event Bookmouse::pollEvent()
{
    /*
     * 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)) {
        static_cast<void>(m_imgui.processEvent(event));
        if (event.type == SDL_QUIT) {
            m_running = false;
        }
        if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_CLOSE &&
            event.window.windowID == SDL_GetWindowID(m_mainWindow.window())) {
            m_running = false;
        }
    }
    return event;
}

void Bookmouse::updateState()
{
    ImGui::SetNextWindowPos(ImVec2(0.0f, 0.0f));
    ImGui::SetNextWindowSize(m_imgui.getIO().DisplaySize);
    auto stateResult = ImBegin(
        "My First Tool",
        &m_running,
        ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_MenuBar);
    fudAssert(stateResult);

    if (ImMenuBar menuBar{}) {
        IM_ASSERT(menuBar);
        menuing();
    }

    if (m_openDialog) {
        m_openDialog = false;
        m_getContents = true;
        ImGui::OpenPopup(OpenDialogHandle);
    }

    if (ImPopupModal popup{OpenDialogHandle}) {
        IM_ASSERT(popup);
        openDialog();
    }

    // Edit a color stored as 4 floats
    fud::Array<float, 4> my_color{};
    ImGui::ColorEdit4("Color", my_color.data());

    // Generate samples and plot them
    float samples[100];
    for (int idx = 0; idx < 100; idx++) {
        auto num = static_cast<float>(idx);
        auto time = static_cast<float>(ImGetTime());
        samples[idx] = sinf(num * 0.2f + time * 1.5f);
    }
    ImGui::PlotLines("Samples", samples, 100);

    // Display contents in a scrolling region
    ImGui::TextColored(ImVec4(1, 1, 0, 1), "Important Stuff");
    ImText("%04d: Some text", 42);
    ImEnd();
}

void Bookmouse::menuing()
{
    if (ImMenu menu{"File"}) {
        IM_ASSERT(menu);
        if (ImGui::MenuItem("Open Archive", "Ctrl+O")) { /* Do stuff */
            m_openDialog = true;
        }
        if (ImGui::MenuItem("Close", "Ctrl+Q")) {
            m_running = false;
        }
    }

    if (ImMenu menu{"Help"}) {
        IM_ASSERT(menu);
        if (ImGui::MenuItem("About")) {
            spdlog::debug("About");
        }
        ImGui::EndMenu();
    }
}

void Bookmouse::openDialog()
{
    if (m_fileDialog == nullptr) {
        m_fileDialog = std::make_unique<FileDialog>(m_directoryName, m_timeFormat);
        if (!m_fileDialog->valid()) {
            spdlog::error("WHAT {}", m_directoryName.c_str());
            m_openDialog = false;
            ImGui::CloseCurrentPopup();
        }
    }

    auto result = m_fileDialog->pickFiles();

    if (result != std::nullopt) {
        auto selectedFiles = *result;
        for (const auto& name : selectedFiles) {
            spdlog::info("Selected {}", name.c_str());
        }
        m_openDialog = false;
        ImGui::CloseCurrentPopup();
        return;
    }

    if (m_fileDialog->canceled()) {
        m_openDialog = false;
        ImGui::CloseCurrentPopup();
    }
}

void Bookmouse::renderFrame()
{
    m_imgui.render();
}

} // namespace bookmouse