#include <SDL2/SDL_events.h>
#include <SDL2/SDL_scancode.h>
#include <cstddef>

#include "lib/backends/imgui_impl_opengl3.h"
#include "lib/backends/imgui_impl_sdl2.h"
#include "lib/imgui.h"
#include "lib/imgui_internal.h"
#include <cstdint>
#include <iostream>
#include <stdexcept>
#include <stdio.h>

#define STB_IMAGE_IMPLEMENTATION
#include "lib/stb_image.h"

#if defined(__APPLE__)
#include <SDL2/SDL.h>
#if defined(IMGUI_IMPL_OPENGL_ES2)
#include <SDL2/SDL_opengles.h>
#else
#include <SDL2/SDL_opengl.h>
#endif
#else
#include <SDL2/SDL.h>
#if defined(IMGUI_IMPL_OPENGL_ES2)
#include <SDL2/SDL_opengles2.h>
#else
#include <SDL2/SDL_opengl.h>
#endif
#endif

#include "lib/imgui_tex_inspect.h"
#include "lib/backends/tex_inspect_opengl.h"
#include "lib/argparse.hpp"

struct Args : public argparse::Args {
  std::string &fpath = arg("path to the image");
};

struct Texture
{
    ImTextureID texture;
    ImVec2 size;
    int channels;
};

static uint8_t* image = nullptr;

Texture LoadTexture(const char * path)
{
    const int channelCount = 4;
    int imageFileChannelCount;
    int width, height;
    image = (uint8_t *)stbi_load(path, &width, &height, &imageFileChannelCount, channelCount);
    if (image == NULL)
    {
        fprintf(stderr, "%s\nFailed to open %s\n", stbi_failure_reason(), path);

        return {nullptr,{0,0}};
    }

    GLenum dataFormat = GL_RGBA;
    GLuint textureHandle;
    glGenTextures(1, &textureHandle);
    glBindTexture(GL_TEXTURE_2D, textureHandle);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, dataFormat, GL_UNSIGNED_BYTE, image);

    Texture t;
    t.texture = (void*)(uintptr_t)(textureHandle);
    t.size = ImVec2((float)width,(float)height);
    t.channels = channelCount;

    return t;
}

Texture ReloadTexture(ImTextureID id, int width, int height) {
    GLuint tid = (GLuint)(uintptr_t)id;
    glDeleteTextures((GLsizei)1, &tid);

    GLenum dataFormat = GL_RGBA;
    GLuint textureHandle;
    glGenTextures(1, &textureHandle);
    glBindTexture(GL_TEXTURE_2D, textureHandle);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, dataFormat, GL_UNSIGNED_BYTE, image);

    Texture t;
    t.texture = (void*)(uintptr_t)(textureHandle);
    t.size = ImVec2((float)width,(float)height);

    return t;
}

void RotateImage(Texture t) {
  int height = t.size.y;
  int width = t.size.x;
  int channels = t.channels;

  const unsigned int sizeBuffer = width * height * channels; 
  unsigned char *tempBuffer = new unsigned char[sizeBuffer];

  int nidx = 0;
  for (int x = 0; x < width; x++)
  {
    for (int y = height - 1; y >= 0; y--)
    {
      int idx = (x + y * width) * channels;
      for (int i = 0; i < channels; i++)
        tempBuffer[nidx + i] = image[idx + i];

      nidx = nidx + 4;
    }
  }

  memcpy(image, tempBuffer, sizeBuffer);
  delete[] tempBuffer;
}


const int MAX_ANNOATED_TEXELS = 10000;

// Main code
int main(int argc, char* argv[]) {
  // Setup SDL
  if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_GAMECONTROLLER) !=
      0) {
    printf("Error: %s\n", SDL_GetError());
    return -1;
  }

  bool TOOLTIP_ENABLED = false;
  bool GRID_ENABLED = false;
  bool AA_ENABLED = true;
  bool SHOW_HELP = false;
  int MODE = 0;

  // 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);
  SDL_WindowFlags window_flags =
      (SDL_WindowFlags)(SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE |
                        SDL_WINDOW_ALLOW_HIGHDPI);
  SDL_Window *window =
      SDL_CreateWindow("tview", SDL_WINDOWPOS_CENTERED,
                       SDL_WINDOWPOS_CENTERED, 1280, 720, window_flags);
  if (window == nullptr) {
    printf("Error: SDL_CreateWindow(): %s\n", SDL_GetError());
    return -1;
  }

  SDL_GLContext gl_context = SDL_GL_CreateContext(window);
  SDL_GL_MakeCurrent(window, gl_context);
  SDL_GL_SetSwapInterval(1); // Enable vsync

  // Setup Dear ImGui context
  IMGUI_CHECKVERSION();
  ImGui::CreateContext();
  ImGuiIO &io = ImGui::GetIO();
  (void)io;
  io.ConfigFlags |=
      ImGuiConfigFlags_NavEnableKeyboard;           // Enable Keyboard Controls
  ImGuiTexInspect::ImplOpenGL3_Init(); // Or DirectX 11 equivalent (check your chosen backend header file)
  ImGuiTexInspect::Init();
  ImGuiTexInspect::CreateContext();
  ImGui::StyleColorsDark();
  ImGuiStyle &style = ImGui::GetStyle();
  ImGui_ImplSDL2_InitForOpenGL(window, gl_context);
  ImGui_ImplOpenGL3_Init(glsl_version);

  ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
  Texture t;
  auto flags = ImGuiTexInspect::InspectorFlags_FillVertical | ImGuiTexInspect::InspectorFlags_FillHorizontal;

  try {
    auto args = argparse::parse<Args>(argc, argv, true);
    t = LoadTexture(args.fpath.c_str());
  } catch (const std::runtime_error &e) {
    std::cerr << "failed to parse arguments: " << e.what() << std::endl;
    return -1;
  }

  // Main loop
  bool done = false;
  while (!done)
  {

    // Poll and handle events (inputs, window resize, etc.)
    SDL_Event event;
    while (SDL_PollEvent(&event)) {
      ImGui_ImplSDL2_ProcessEvent(&event);
      if (event.type == SDL_WINDOWEVENT &&
          event.window.event == SDL_WINDOWEVENT_CLOSE &&
          event.window.windowID == SDL_GetWindowID(window))
        done = true;

      switch (event.type) {
        case SDL_QUIT:
          done = true;
          break;
        case SDL_KEYDOWN:
        switch (event.key.keysym.scancode) {
            case SDL_SCANCODE_G:
              GRID_ENABLED = !GRID_ENABLED;
              break;
            case SDL_SCANCODE_T:
              TOOLTIP_ENABLED = !TOOLTIP_ENABLED;
              break;
            case SDL_SCANCODE_A:
              AA_ENABLED = !AA_ENABLED;
              break;
            case SDL_SCANCODE_H:
              showHelp = !showHelp;
              break;
            case SDL_SCANCODE_D:
              mode = (mode + 1) % 5;
              break;
            case SDL_SCANCODE_R:
              RotateImage(t);
              t = ReloadTexture(t.texture, t.size.y, t.size.x);
              break;
            case SDL_SCANCODE_Q:
              done = true;
              break;
            default:
              break;
        }
      }
    }

    // Start the Dear ImGui frame
    ImGui_ImplOpenGL3_NewFrame();
    ImGui_ImplSDL2_NewFrame();
    ImGui::NewFrame();
    {
#ifdef IMGUI_HAS_VIEWPORT
      ImGuiViewport *viewport = ImGui::GetMainViewport();
      ImGui::SetNextWindowPos(viewport->WorkPos);
      ImGui::SetNextWindowSize(viewport->WorkSize);
      ImGui::SetNextWindowViewport(viewport->ID);
#else
      ImGui::SetNextWindowPos(ImVec2(0.0f, 0.0f));
      ImGui::SetNextWindowSize(ImGui::GetIO().DisplaySize);
#endif


      ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
      ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
      ImGui::SetNextWindowPos(viewport->Pos);
      ImGui::SetNextWindowSize(viewport->Size);
      ImGui::Begin("Main", NULL,
                   ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoResize);
      auto wSize = ImGui::GetContentRegionAvail();
      if (t.texture != 0) {

        if (!TOOLTIP_ENABLED) {
          flags = flags | ImGuiTexInspect::InspectorFlags_NoTooltip;
        }

        ImGuiTexInspect::BeginInspectorPanel(
          "Inspector",
          t.texture,
          t.size,
          flags,
          ImGuiTexInspect::SizeExcludingBorder(wSize)
        );

        if (GRID_ENABLED) {
            CurrentInspector_ClearFlags(ImGuiTexInspect::InspectorFlags_NoGrid);
        }else {
            CurrentInspector_SetFlags(ImGuiTexInspect::InspectorFlags_NoGrid);
        }

        if (TOOLTIP_ENABLED) {
            CurrentInspector_ClearFlags(ImGuiTexInspect::InspectorFlags_NoTooltip);
        }else {
            CurrentInspector_SetFlags(ImGuiTexInspect::InspectorFlags_NoTooltip);
        }

        if (AA_ENABLED) {
            CurrentInspector_ClearFlags(ImGuiTexInspect::InspectorFlags_NoForceFilterNearest);
        }else {
            CurrentInspector_SetFlags(ImGuiTexInspect::InspectorFlags_NoForceFilterNearest);
        }

        switch(mode) {
          case 1:
            ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::Arrow().UsePreset(ImGuiTexInspect::Arrow::NormalMap), maxAnnotatedTexels);
            break;
          case 2:
            ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::ValueText(ImGuiTexInspect::ValueText::Format::HexString), maxAnnotatedTexels);
            break;
          case 3:
            ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::ValueText(ImGuiTexInspect::ValueText::Format::BytesDec), maxAnnotatedTexels);
            break;
          case 4:
            ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::ValueText(ImGuiTexInspect::ValueText::Format::Floats), maxAnnotatedTexels);
            break;
          default:
            break;
        }


        ImGuiTexInspect::EndInspectorPanel();
      }
      ImGui::End();
      ImGui::PopStyleVar();
      ImGui::PopStyleVar();

      if (showHelp){
        ImGui::OpenPopup("HelpPopup");
        showHelp = !showHelp;
      }

      if (ImGui::BeginPopup("HelpPopup")) {
        ImGui::Text("tview Help");
        ImGui::Separator();
        ImGui::Text("r - rotate 90 deg clockwise");
        ImGui::Text("g - toggle grid");
        ImGui::Text("a - toggle filtering");
        ImGui::Text("t - toggle tooltip");
        ImGui::Text("d - cycle pixel detail mode");
        ImGui::Separator();
        ImGui::Text("modes:");
        ImGui::Text("\tOff");
        ImGui::Text("\tGradient Arrow");
        ImGui::Text("\tHex Code");
        ImGui::Text("\tRGB Values");
        ImGui::Text("\tFloat Values");
        ImGui::Separator();
        ImGui::Text("h - show help popup");
        ImGui::Text("q - quit");
        ImGui::Separator();
        ImGui::Text("click anywhere to continue");
        ImGui::EndPopup();
      }
    }

    // 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());
    SDL_GL_SwapWindow(window);
  }

  if (image != nullptr) {
    stbi_image_free(image);
  }

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

  SDL_GL_DeleteContext(gl_context);
  SDL_DestroyWindow(window);
  SDL_Quit();

  return 0;
}