#include "demo.hpp"

#include "gl_context.hpp"
#include "imgui_context.hpp"
#include "sdl_context.hpp"
#include "sdl_main_window.hpp"
#include "stb_image.h"

#include <SDL.h>
#include <SDL_opengl.h>
#include <cstdio>
#include <fud_c_file.hpp>
#include <fud_string.hpp>
#include <imgui/imgui.h>
#include <imgui/imgui_impl_opengl3.h>
#include <imgui/imgui_impl_sdl2.h>
#include <spdlog/spdlog.h>
#include <vector>

#include <fud_assert.hpp>

namespace bookmouse {

using fud::assertFail;

// Simple helper function to load an image into a OpenGL texture with common settings
bool LoadTextureFromMemory( // force newline
    const void* data,
    size_t data_size,
    GLuint* out_texture,
    int* out_width,
    int* out_height)
{
    // Load from file
    int width = 0;
    int height = 0;
    int channelsInFile = 4;
    unsigned char* image_data = stbi_load_from_memory( // force
        (const unsigned char*)data,
        (int)data_size,
        &width,
        &height,
        nullptr,
        4);
    if (image_data == nullptr) {
        spdlog::error("Failed to get data from");
        return false;
    }

    spdlog::info( // force
        "Got result: {} pixels per row of {} scanlines with {} channels",
        width,
        height,
        channelsInFile);

    // Create a OpenGL texture identifier
    GLuint imageTexture;
    glGenTextures(1, &imageTexture);
    glBindTexture(GL_TEXTURE_2D, imageTexture);

    // Setup filtering parameters for display
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    // Upload pixels into texture
    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
    glTexImage2D( // force
        GL_TEXTURE_2D,
        0,
        GL_RGBA,
        width,
        height,
        0,
        GL_RGBA,
        GL_UNSIGNED_BYTE,
        image_data);
    stbi_image_free(image_data);

    *out_texture = imageTexture;
    *out_width = width;
    *out_height = height;

    return true;
}

// Open and read a file, then forward to LoadTextureFromMemory()
bool LoadTextureFromFile( // force
    const fud::String& filename,
    GLuint* out_texture,
    int* out_width,
    int* out_height)
{
    fud::CBinaryFile inFile{filename, fud::CFileMode::ReadOnly};
    auto fileResult = inFile.open();
    using fud::FudStatus;
    if (fileResult == FudStatus::Failure) {
        spdlog::error("can't open {}", filename.c_str());
        // return err(ImageError::FileError);
        return false;
    }

    auto fileSizeResult = inFile.size();
    if (fileSizeResult.isError()) {
        spdlog::error( // force
            "bad file size {} {}",
            filename.c_str(),
            FudStatusToString(fileSizeResult.getError()));
        return false;
    }
    auto fileSize = fileSizeResult.getOkay();

    auto* filePtr = inFile.file();
    if (filePtr == nullptr) {
        spdlog::error("File associated with {} returned nullptr", filename.c_str());
        // return err(ImageError::FileError);
        return false;
    }

    std::vector<char> fileData{};
    fileData.resize(fileSize);

    auto readResult = inFile.read(fileData.data(), fileSize, fileSize);
    if (readResult.status != FudStatus::Success) {
        spdlog::error( // force
            "bad read {} {}", filename.c_str(), FudStatusToString(readResult.status));
        return false;
    }

    bool ret = LoadTextureFromMemory( // force
        fileData.data(), fileSize, out_texture, out_width, out_height);
    return ret;
}

int demo(const fud::String& m_filename)
{
    SdlContext sdlContext{};

    SdlMainWindow mainWindow{sdlContext};

    GlContext glContext{mainWindow};

    ImguiContext imguiContext{glContext, sdlContext, mainWindow};

    // Setup Platform/Renderer backends
    int my_image_width = 0;
    int my_image_height = 0;
    GLuint my_image_texture = 0;
    bool ret = LoadTextureFromFile( // force
        m_filename, &my_image_texture, &my_image_width, &my_image_height);
    fudAssert(ret);

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

    // Main loop
    bool done = false;
    while (!done) {
        // 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 && event.window.event == SDL_WINDOWEVENT_CLOSE &&
                event.window.windowID == SDL_GetWindowID(mainWindow.window())) {
                done = true;
            }
        }
        if (SDL_GetWindowFlags(mainWindow.window()) & SDL_WINDOW_MINIMIZED) {
            SDL_Delay(10);
            continue;
        }

        // Start the Dear ImGui frame
        ImGui_ImplOpenGL3_NewFrame();
        ImGui_ImplSDL2_NewFrame();
        ImGui::NewFrame();

        // 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);

        // 2. Show a simple window that we create ourselves. We use a Begin/End pair to create a named window.
        {
            ImGui::Begin("OpenGL Texture Text");
            ImGui::Text("pointer = %x", my_image_texture);
            ImGui::Text("size = %d x %d", my_image_width, my_image_height);
            ImGui::Image(
                (void*)(intptr_t)my_image_texture,
                ImVec2(static_cast<float>(my_image_width), static_cast<float>(my_image_height)));
            ImGui::End();

            static float f = 0.0f;
            static int counter = 0;

            // Create a window called "Hello, world!" and append into it.
            ImGui::Begin("Hello, world!");

            // Display some text (you can use a format strings too)
            ImGui::Text("This is some useful text.");
            // Edit bools storing our window open/close state
            ImGui::Checkbox("Demo Window", &show_demo_window);
            ImGui::Checkbox("Another Window", &show_another_window);

            // Edit 1 float using a slider from 0.0f to 1.0f
            ImGui::SliderFloat("float", &f, 0.0f, 1.0f);
            // Edit 3 floats representing a color
            ImGui::ColorEdit3("clear color", &clear_color.x);

            // Buttons return true when clicked (most widgets return true when edited/activated)
            if (ImGui::Button("Button"))
                counter++;
            ImGui::SameLine();
            ImGui::Text("counter = %d", counter);

            auto framerate = imguiContext.getIO().Framerate;
            ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / framerate, framerate);
            ImGui::End();
        }

        // 3. Show another simple window.
        if (show_another_window) {
            // Pass a pointer to our bool variable (the window will have a closing button that will clear the bool when
            // clicked)
            ImGui::Begin("Another Window", &show_another_window);
            ImGui::Text("Hello from another window!");
            if (ImGui::Button("Close Me"))
                show_another_window = false;
            ImGui::End();
        }

        // Rendering
        ImGui::Render();
        const auto& imguiIO = imguiContext.getIO();
        glViewport(0, 0, static_cast<int>(imguiIO.DisplaySize.x), static_cast<int>(imguiIO.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());
        SDL_GL_SwapWindow(mainWindow.window());
    }

    // return ImageResult::okay(image);

    return 0;
}

} // namespace bookmouse
// (* 3840 2160) 8294400
// (* 2 2560 1440) 7372800