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


#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 <exiv2/tags.hpp>
#include <exiv2/version.hpp>
#include <iostream>
#include <stdexcept>
#include <stdio.h>
#include <fstream>

#define STB_IMAGE_IMPLEMENTATION
#include "lib/stb_image.h"
#include <libraw/libraw.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"

#include <exiv2/exiv2.hpp>

#include "lib/histogram.h"
#include <future>
#include <vector>
#include <filesystem>
#include <algorithm>
#include <execinfo.h>
#include <signal.h>
struct Args : public argparse::Args {
  std::string &fpath = arg("path to the image");
};

struct EXIFData {
  std::map<std::string, std::string> all_fields;
  std::string CameraMake;
  std::string CameraModel;
  std::string LensModel;
  std::string ImageOrientation;
  std::string ImageDimensionX;
  std::string ImageDimensiony;
  std::string ISO;
  std::string ShutterSpeed;
  std::string FNumber;
  std::string FocalLength;
  std::string ExposureBias;
  std::string MeteringMode;
  std::string Flash;
  std::string Time;
  std::string TimeTaken;
  std::string TimeTakenOffset;
  std::string GPSLat;
  std::string GPSLatref;
  std::string GPSLon;
  std::string GPSLonref;
};

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

enum class DetectedFileType
{
    RAW,
    JPEG,
    PNG,
    TIFF,
    UNKNOWN
};

void handler(int sig) {
  void *array[10];
  size_t size;

  // get void*'s for all entries on the stack
  size = backtrace(array, 10);

  // print out all the frames to stderr
  fprintf(stderr, "Error: signal %d:\n", sig);
  backtrace_symbols_fd(array, size, STDERR_FILENO);
  exit(1);
}

static uint8_t* image = nullptr;
static std::vector<std::string> image_files;
static int current_image_index = -1;

static DetectedFileType detectFileType(const std::string &filePath)
{
    std::ifstream file(filePath, std::ios::binary);
    if (!file)
        return DetectedFileType::UNKNOWN;

    unsigned char magic[12]; // Read enough bytes for common signatures
    file.read(reinterpret_cast<char *>(magic), sizeof(magic));
    if (!file)
        return DetectedFileType::UNKNOWN;

    // Check common signatures
    if (magic[0] == 0xFF && magic[1] == 0xD8 && magic[2] == 0xFF)
        return DetectedFileType::JPEG;
    if (magic[0] == 0x89 && magic[1] == 'P' && magic[2] == 'N' && magic[3] == 'G')
        return DetectedFileType::PNG;
    if ((magic[0] == 'I' && magic[1] == 'I' && magic[2] == 0x2A && magic[3] == 0x00) || // Little-endian TIFF
        (magic[0] == 'M' && magic[1] == 'M' && magic[2] == 0x00 && magic[3] == 0x2A))   // Big-endian TIFF
    {

        size_t dotPos = filePath.rfind('.');
        if (dotPos != std::string::npos)
        {
            std::string ext = filePath.substr(dotPos);
            std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);

            // Common RAW formats that use TIFF structure
            const char *rawTiffExtensions[] = {
                ".nef", // Nikon
                ".cr2", // Canon
                ".dng", // Adobe/Various
                ".arw", // Sony
                ".srw", // Samsung
                ".orf", // Olympus
                ".pef", // Pentax
                ".raf", // Fuji
                ".rw2"  // Panasonic
            };

            for (const char *rawExt : rawTiffExtensions)
            {
                if (ext == rawExt)
                    return DetectedFileType::RAW;
            }
        }
        return DetectedFileType::TIFF;
    }

    // If no standard signature matches, check extension for RAW as a fallback
    // (LibRaw handles many internal variations)
    size_t dotPos = filePath.rfind('.');
    if (dotPos != std::string::npos)
    {
        std::string ext = filePath.substr(dotPos);
        std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
        const char *rawExtensions[] = {
            ".3fr", ".ari", ".arw", ".bay", ".braw", ".crw", ".cr2", ".cr3", ".cap",
            ".data", ".dcs", ".dcr", ".dng", ".drf", ".eip", ".erf", ".fff", ".gpr",
            ".iiq", ".k25", ".kdc", ".mdc", ".mef", ".mos", ".mrw", ".nef", ".nrw",
            ".obm", ".orf", ".pef", ".ptx", ".pxn", ".r3d", ".raf", ".raw", ".rwl",
            ".rw2", ".rwz", ".sr2", ".srf", ".srw", ".tif", ".x3f" // Note: .tif can be RAW or regular TIFF
        };
        for (const char *rawExt : rawExtensions)
        {
            if (ext == rawExt)
                return DetectedFileType::RAW;
        }
        // Special case: Leica .dng can also be loaded by LibRaw
        if (ext == ".dng")
            return DetectedFileType::RAW;
    }

    return DetectedFileType::UNKNOWN;
}


EXIFData printExifData(const std::string& imagePath) {
    EXIFData d;
    d.CameraMake = "NULL";
    try {
        // Load the image
        #if EXIV2_TEST_VERSION(0,28,0)
        Exiv2::Image::UniquePtr img = Exiv2::ImageFactory::open(imagePath);
        #else
        Exiv2::Image::AutoPtr img = Exiv2::ImageFactory::open(imagePath);
        #endif
        if (img.get() == 0) {
            std::cerr << "Error: Could not open image file " << imagePath << std::endl;
            return d;
        }
        img->readMetadata();

        // Get the Exif data
        Exiv2::ExifData &exifData = img->exifData();
        if (exifData.empty()) {
            std::cerr << "No EXIF data found in file " << imagePath << std::endl;
            return d;
        }

        for (auto i = exifData.begin(); i != exifData.end(); ++i) {
          d.all_fields[i->key()] = i->value().toString();
        }

        // Helper function to print EXIF data if available
        auto printExifValue = [&exifData](const char* key, std::string *d) {
            Exiv2::ExifKey exifKey(key);
            Exiv2::ExifData::const_iterator pos = exifData.findKey(exifKey);
            if (pos != exifData.end()) {
                *d = pos->value().toString();
            }
        };

        // Print common EXIF data
        printExifValue("Exif.Image.Make", &d.CameraMake);
        printExifValue("Exif.Image.Model", &d.CameraModel);
        printExifValue("Exif.Photo.LensModel", &d.LensModel);

        printExifValue("Exif.Image.Orientation", &d.ImageOrientation);
    //
        printExifValue("Exif.Photo.ExposureTime", &d.ShutterSpeed);
        printExifValue("Exif.Photo.FNumber", &d.FNumber);
        printExifValue("Exif.Photo.ISOSpeedRatings", &d.ISO);
        printExifValue("Exif.Photo.FocalLength", &d.FocalLength);
        printExifValue("Exif.Photo.ExposureBiasValue", &d.ExposureBias);
        printExifValue("Exif.Photo.MeteringMode", &d.MeteringMode);
        printExifValue("Exif.Photo.Flash", &d.Flash);

        printExifValue("Exif.Image.DateTime", &d.Time);
        printExifValue("Exif.Photo.DateTimeOriginal", &d.TimeTaken);
        printExifValue("Exif.Photo.OffsetTime", &d.TimeTakenOffset);
        printExifValue("Exif.Photo.PixelXDimension", &d.ImageDimensionX);
        printExifValue("Exif.Photo.PixelYDimension", &d.ImageDimensiony);

        printExifValue("Exif.GPSInfo.GPSLatitudeRef", &d.GPSLatref);
        printExifValue("Exif.GPSInfo.GPSLatitude", &d.GPSLat);
        printExifValue("Exif.GPSInfo.GPSLongitudeRef", &d.GPSLonref);
        printExifValue("Exif.GPSInfo.GPSLongitude", &d.GPSLon);


/*
Exif.Image.Make                              0x010f Ascii       5  SONY
Exif.Image.Model                             0x0110 Ascii      10  ILCE-7RM5

Exif.Image.Orientation                       0x0112 Short       1  8
Exif.Photo.PixelXDimension                   0xa002 Long        1  9504
Exif.Photo.PixelYDimension                   0xa003 Long        1  6336

Exif.Photo.ExposureTime                      0x829a Rational    1  1/400
Exif.Photo.FNumber                           0x829d Rational    1  56/10
Exif.Photo.ISOSpeedRatings                   0x8827 Short       1  100
Exif.Photo.FocalLength                       0x920a Rational    1  400/10
Exif.Photo.ExposureBiasValue                 0x9204 SRational   1  -10/10
Exif.Photo.MeteringMode                      0x9207 Short       1  5
Exif.Photo.Flash                             0x9209 Short       1  16

Exif.Image.DateTime                          0x0132 Ascii      20  2024:06:07 08:58:07
Exif.Photo.DateTimeOriginal                  0x9003 Ascii      20  2024:06:07 08:58:07
Exif.Photo.OffsetTime                        0x9010 Ascii       7  -05:00

Exif.GPSInfo.GPSLatitudeRef                  0x0001 Ascii       2  N
Exif.GPSInfo.GPSLatitude                     0x0002 Rational    3  40/1 43/1 32231/1000
Exif.GPSInfo.GPSLongitudeRef                 0x0003 Ascii       2  W
Exif.GPSInfo.GPSLongitude                    0x0004 Rational    3  73/1 59/1 16688/1000
*/

    } catch (Exiv2::Error& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

  return d;
}

Texture ReloadTexture(Texture tin, int width, int height) {
    GLuint tid = (GLuint)(uintptr_t)tin.texture;
    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);
    t.exif = tin.exif;
    t.channels = tin.channels;

    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;
}

Texture LoadImage(const char * path) {
    const int channelCount = 4;
    int imageFileChannelCount;
    int width, height;

    // Detect File type
    DetectedFileType fileType = detectFileType(path);

    if (fileType == DetectedFileType::RAW) {
        LibRaw iProcessor;
        iProcessor.open_file(path);
        iProcessor.unpack();
        iProcessor.imgdata.params.use_camera_wb = 1;
        iProcessor.dcraw_process();

        libraw_processed_image_t *processed_image = iProcessor.dcraw_make_mem_image();
        if (processed_image == NULL) {
            fprintf(stderr, "Failed to process RAW file %s\n", path);
            return {nullptr,{0,0}};
        }

        width = processed_image->width;
        height = processed_image->height;
        imageFileChannelCount = processed_image->colors;

        image = new uint8_t[width * height * channelCount];
        
        if (processed_image->bits == 16) {
            for (int i = 0; i < width * height; ++i) {
                image[i * channelCount + 0] = processed_image->data[i * imageFileChannelCount + 0] / 256;
                image[i * channelCount + 1] = processed_image->data[i * imageFileChannelCount + 1] / 256;
                image[i * channelCount + 2] = processed_image->data[i * imageFileChannelCount + 2] / 256;
                image[i * channelCount + 3] = 255; // Alpha channel
            }
        } else { // 8-bit
            for (int i = 0; i < width * height; ++i) {
                image[i * channelCount + 0] = processed_image->data[i * imageFileChannelCount + 0];
                image[i * channelCount + 1] = processed_image->data[i * imageFileChannelCount + 1];
                image[i * channelCount + 2] = processed_image->data[i * imageFileChannelCount + 2];
                image[i * channelCount + 3] = 255; // Alpha channel
            }
        }
        
        iProcessor.dcraw_clear_mem(processed_image);

    } else {
      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}};
      }
    }
    auto exif = printExifData(path);

    Texture t;
    t.size = ImVec2((float)width,(float)height);
    t.channels = channelCount;
    t.exif = exif;
    return t;
}

Texture LoadTexture(Texture tin) {
    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, tin.size.x, tin.size.y, 0, dataFormat, GL_UNSIGNED_BYTE, image);

    Texture t = tin;
    t.texture = (void*)(uintptr_t)(textureHandle);

    if (t.exif.ImageOrientation == "3") {
      RotateImage(t);
      ReloadTexture(t, t.size.x, t.size.y);
      t = ReloadTexture(t, t.size.y, t.size.x);
      RotateImage(t);
      t = ReloadTexture(t, t.size.y, t.size.x);
    } else if (t.exif.ImageOrientation == "6") {
      RotateImage(t);
      t = ReloadTexture(t, t.size.y, t.size.x);
    } else if (t.exif.ImageOrientation == "8") {
      RotateImage(t);
      t = ReloadTexture(t, t.size.y, t.size.x);
      RotateImage(t);
      t = ReloadTexture(t, t.size.y, t.size.x);
      RotateImage(t);
      t = ReloadTexture(t, t.size.y, t.size.x);
    }

    return t;
}


const int MAX_ANNOATED_TEXELS = 10000;

// Main code
int main(int argc, char* argv[]) {
  signal(SIGSEGV, handler);
  Texture t;
  std::string current_fpath;

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

  std::filesystem::path p(current_fpath);
  auto parent_path = p.parent_path();
  for (const auto& entry : std::filesystem::directory_iterator(parent_path)) {
      if (entry.is_regular_file()) {
          if (detectFileType(entry.path().string()) != DetectedFileType::UNKNOWN) {
              image_files.push_back(entry.path().string());
          }
      }
  }
  std::sort(image_files.begin(), image_files.end());
  auto it = std::find(image_files.begin(), image_files.end(), current_fpath);
  if (it != image_files.end()) {
      current_image_index = std::distance(image_files.begin(), it);
  }
  // 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;
  bool SHOW_EXIF = false;
  bool SHOW_HISTOGRAM = false;
  int MODE = 0;
  bool histogram_ready = false;
  std::future<Texture> image_load_future;

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

  float image_w = t.size.x;
  float image_h = t.size.y;
  if (t.exif.ImageOrientation == "6" || t.exif.ImageOrientation == "8") {
    std::swap(image_w, image_h);
  }

  float aspect_ratio = image_w / image_h;
  int viewer_h = image_h;
  int viewer_w = image_w;
  const int max_h = 1200;

  if (viewer_h > max_h) {
      viewer_h = max_h;
      viewer_w = max_h * aspect_ratio;
  }

  int ww = viewer_w * 1.25;
  int wh = viewer_h * 1.25;

  SDL_Window *window =
      SDL_CreateWindow("tview", SDL_WINDOWPOS_CENTERED,
                       SDL_WINDOWPOS_CENTERED, ww, wh, 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();
  ImGui::GetIO().IniFilename = NULL;
  (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.18f, 0.18f, 0.18f, 1.00f);
  std::vector<ImVec4> background_colors = {
    ImVec4(0.0f, 0.0f, 0.0f, 1.00f),
    ImVec4(0.18f, 0.18f, 0.18f, 1.00f),
    ImVec4(0.5f, 0.5f, 0.5f, 1.00f),
    ImVec4(255.0f, 255.0f, 255.0f, 255.00f),
    ImVec4(0.75f, 0.75f, 0.75f, 1.00f)
  };
  int background_color_index = 1;

  auto flags = ImGuiTexInspect::InspectorFlags_FillVertical | ImGuiTexInspect::InspectorFlags_FillHorizontal;

  t = LoadTexture(t);
  ImGuiTexInspect::SetInitialZoom(0.80f);
  Histogram histogram = Histogram(t.size.x, t.size.y, t.channels);
  auto histogram_future = std::async(std::launch::async, [&]() {
    histogram.Load(image);
    histogram_ready = true;
  });

  // Main loop
  bool done = false;
  while (!done)
  {
    if (image_load_future.valid()) {
        auto status = image_load_future.wait_for(std::chrono::seconds(0));
        if (status == std::future_status::ready) {
            auto new_texture_data = image_load_future.get();
            GLuint textureID = (GLuint)(uintptr_t)t.texture;
            glDeleteTextures(1, &textureID);
            t = new_texture_data;
            t = LoadTexture(t);
            histogram = Histogram(t.size.x, t.size.y, t.channels);
            histogram_ready = false;
            histogram_future = std::async(std::launch::async, [&]() {
                histogram.Load(image);
                histogram_ready = true;
            });
        }
    }

    // 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:

        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_SLASH:
              SHOW_HELP = !SHOW_HELP;
              break;
            case SDL_SCANCODE_D:
              MODE = (MODE + 1) % 5;
              break;
            case SDL_SCANCODE_R:
              RotateImage(t);
              t = ReloadTexture(t, t.size.y, t.size.x);
              break;
            case SDL_SCANCODE_Q:
              done = true;
              break;
            case SDL_SCANCODE_E:
              SHOW_EXIF = !SHOW_EXIF;
              break;
            case SDL_SCANCODE_H:
              SHOW_HISTOGRAM = !SHOW_HISTOGRAM;
              break;
            case SDL_SCANCODE_B:
              background_color_index = (background_color_index + 1) % background_colors.size();
              clear_color = background_colors[background_color_index];
              break;
            case SDL_SCANCODE_LEFT:
                if (current_image_index > 0) {
                    current_image_index--;
                } else {
                    current_image_index = image_files.size() - 1;
                }
                if (!image_load_future.valid() || image_load_future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
                    image_load_future = std::async(std::launch::async, [&]() {
                        return LoadImage(image_files[current_image_index].c_str());
                    });
                }
                break;
            case SDL_SCANCODE_RIGHT:
                if (current_image_index < (int)image_files.size() - 1) {
                    current_image_index++;
                } else {
                    current_image_index = 0;
                }
                if (!image_load_future.valid() || image_load_future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
                    image_load_future = std::async(std::launch::async, [&]() {
                        return LoadImage(image_files[current_image_index].c_str());
                    });
                }
                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 | ImGuiWindowFlags_NoBringToFrontOnFocus);
      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)
        );

        CurrentInspector_SetAlphaMode(
          ImGuiTexInspect::InspectorAlphaMode_CustomColor
        );
        ImGuiTexInspect::CurrentInspector_SetCustomBackgroundColor(clear_color);

        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), MAX_ANNOATED_TEXELS);
            break;
          case 2:
            ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::ValueText(ImGuiTexInspect::ValueText::Format::HexString), MAX_ANNOATED_TEXELS);
            break;
          case 3:
            ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::ValueText(ImGuiTexInspect::ValueText::Format::BytesDec), MAX_ANNOATED_TEXELS);
            break;
          case 4:
            ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::ValueText(ImGuiTexInspect::ValueText::Format::Floats), MAX_ANNOATED_TEXELS);
            break;
          default:
            break;
        }


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

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

      if (ImGui::BeginPopup("HelpPopup")) {
        ImGui::Text("tview Help");
        ImGui::Separator();
        ImGui::Text("b - cycle background color");
        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("	Off");
        ImGui::Text("	Gradient Arrow");
        ImGui::Text("	Hex Code");
        ImGui::Text("	RGB Values");
        ImGui::Text("	Float Values");
        ImGui::Separator();
        ImGui::Text("? - show help popup");
        ImGui::Text("h - toggle color histogram");
        ImGui::Text("e - toggle EXIF info");
        ImGui::Separator();
        ImGui::Text("q - quit");
        ImGui::Separator();
        ImGui::Text("click anywhere to continue");
        ImGui::EndPopup();
      }
      if (SHOW_EXIF) {
        if (t.exif.CameraMake != "NULL") {
          ImGuiWindowClass topmost;
          topmost.ClassId = ImHashStr("TopMost");
          topmost.ViewportFlagsOverrideSet = ImGuiViewportFlags_TopMost;
          ImGui::SetNextWindowClass(&topmost);
          ImGui::SetNextWindowSize(ImVec2(600, 600), ImGuiCond_FirstUseEver);
          ImGui::Begin("EXIF", &SHOW_EXIF, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoFocusOnAppearing);
          if(ImGui::BeginTable("Hardware", 2, ImGuiTableFlags_Resizable)) {
            ImGui::TableSetupColumn("Field", ImGuiTableColumnFlags_WidthFixed, ImGuiTableColumnFlags_NoHide, 150.0f);
            ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextWrapped("Make");
            ImGui::TableSetColumnIndex(1);
            ImGui::TextWrapped("%s", t.exif.CameraMake.c_str());

            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextWrapped("Model");
            ImGui::TableSetColumnIndex(1);
            ImGui::TextWrapped("%s", t.exif.CameraModel.c_str());

            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextWrapped("Lens");
            ImGui::TableSetColumnIndex(1);
            ImGui::TextWrapped("%s", t.exif.LensModel.c_str());

            ImGui::EndTable();
          }

          ImGui::Separator();

          if(ImGui::BeginTable("Photo", 2, ImGuiTableFlags_Resizable)) {
            ImGui::TableSetupColumn("Field", ImGuiTableColumnFlags_WidthFixed, ImGuiTableColumnFlags_NoHide, 150.0f);
            ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextWrapped("Shutter Speed");
            ImGui::TableSetColumnIndex(1);
            ImGui::TextWrapped("%s", t.exif.ShutterSpeed.c_str());

            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextWrapped("F-Stop");
            ImGui::TableSetColumnIndex(1);
            ImGui::TextWrapped("%s", t.exif.FNumber.c_str());

            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextWrapped("ISO");
            ImGui::TableSetColumnIndex(1);
            ImGui::TextWrapped("%s", t.exif.ISO.c_str());

            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextWrapped("Focal Length");
            ImGui::TableSetColumnIndex(1);
            ImGui::TextWrapped("%s", t.exif.FocalLength.c_str());

            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextWrapped("Exposure Comp");
            ImGui::TableSetColumnIndex(1);
            ImGui::TextWrapped("%s", t.exif.ExposureBias.c_str());

            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextWrapped("Metering Mode");
            ImGui::TableSetColumnIndex(1);
            ImGui::TextWrapped("%s", t.exif.MeteringMode.c_str());

            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextWrapped("Flash");
            ImGui::TableSetColumnIndex(1);
            ImGui::TextWrapped("%s", t.exif.Flash.c_str());

            ImGui::EndTable();
          }

          ImGui::Separator();

          if(ImGui::BeginTable("Meta", 2, ImGuiTableFlags_Resizable)) {
            ImGui::TableSetupColumn("Field", ImGuiTableColumnFlags_WidthFixed, ImGuiTableColumnFlags_NoHide, 150.0f);
            ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextWrapped("Date");
            ImGui::TableSetColumnIndex(1);
            ImGui::TextWrapped("%s %s", t.exif.TimeTaken.c_str(), t.exif.TimeTakenOffset.c_str());


            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextWrapped("Dimensions");
            ImGui::TableSetColumnIndex(1);
            ImGui::TextWrapped("%sx%s", t.exif.ImageDimensionX.c_str(), t.exif.ImageDimensiony.c_str());

            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextWrapped("Orientation");
            ImGui::TableSetColumnIndex(1);
            ImGui::TextWrapped("%s", t.exif.ImageOrientation.c_str());

            ImGui::EndTable();
          }

          ImGui::Separator();

          if(ImGui::BeginTable("Location", 2, ImGuiTableFlags_Resizable)) {
            ImGui::TableSetupColumn("Field", ImGuiTableColumnFlags_WidthFixed, ImGuiTableColumnFlags_NoHide, 150.0f);
            ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextWrapped("Latitude");
            ImGui::TableSetColumnIndex(1);
            ImGui::TextWrapped("%s %s", t.exif.GPSLat.c_str(), t.exif.GPSLatref.c_str());


            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextWrapped("Longitude");
            ImGui::TableSetColumnIndex(1);
            ImGui::TextWrapped("%s %s", t.exif.GPSLon.c_str(), t.exif.GPSLonref.c_str());

            ImGui::EndTable();
          }

          ImGui::Separator();
          if(ImGui::BeginTable("All EXIF", 2, ImGuiTableFlags_Resizable)) {
            ImGui::TableSetupColumn("Field", ImGuiTableColumnFlags_WidthFixed, ImGuiTableColumnFlags_NoHide, 150.0f);
            ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
            for (auto const& [key, val] : t.exif.all_fields)
            {
              ImGui::TableNextRow();
              ImGui::TableSetColumnIndex(0);
              ImGui::TextWrapped("%s", key.c_str());
              ImGui::TableSetColumnIndex(1);
              ImGui::TextWrapped("%s", val.c_str());
            }
            ImGui::EndTable();
          }

          ImGui::Separator();
          ImGui::Text("Press e to hide");

          ImGui::End();
        } else {
          ImGuiWindowClass topmost;
          topmost.ClassId = ImHashStr("TopMost");
          topmost.ViewportFlagsOverrideSet = ImGuiViewportFlags_TopMost;
          ImGui::SetNextWindowClass(&topmost);
          ImGui::SetNextWindowSize(ImVec2(200, 50), ImGuiCond_FirstUseEver);
          ImGui::Begin("EXIF", &SHOW_EXIF, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_AlwaysAutoResize);
          ImGui::Text("No EXIF data available.");
          ImGui::End();
        }
    }


      if (SHOW_HISTOGRAM) {
        ImGuiWindowClass topmost;
        topmost.ClassId = ImHashStr("TopMost");
        topmost.ViewportFlagsOverrideSet = ImGuiViewportFlags_TopMost;
        ImGui::SetNextWindowClass(&topmost);
        ImGui::Begin("Histogram", NULL, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize  | ImGuiWindowFlags_NoFocusOnAppearing);
        if (histogram_ready) {
          histogram.Draw();
          ImGui::Separator();
          ImGui::Text("Press c to hide");
        } else {
          ImGui::Text("Loading...");
        }

        ImGui::End();
      }
    }


    // Rendering
    ImGui::Render();
    glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y);
    glClearColor(clear_color.x, clear_color.y, clear_color.z, 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;
}