#define USE_OPENGL2
#include "OpenGLWindow/OpenGLInclude.h"
#ifdef _WIN32
#include "OpenGLWindow/Win32OpenGLWindow.h"
#elif defined __APPLE__
#include "OpenGLWindow/MacOpenGLWindow.h"
#else
// assume linux
#include "OpenGLWindow/X11OpenGLWindow.h"
#endif

#ifdef _WIN32
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>
#else
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#endif

#include <cstdio>
#include <cstdlib>
#include <string>
#include <cstring>

#ifdef USE_NATIVEFILEDIALOG
#include <nfd.h>
#endif

#define NK_INCLUDE_FIXED_TYPES
#define NK_INCLUDE_STANDARD_IO
#define NK_INCLUDE_DEFAULT_ALLOCATOR
#define NK_INCLUDE_VERTEX_BUFFER_OUTPUT
#define NK_INCLUDE_FONT_BAKING
#define NK_INCLUDE_DEFAULT_FONT
#define NK_IMPLEMENTATION
#define NK_BTGUI_GL2_IMPLEMENTATION
#include "nuklear.h"
#include "nuklear_btgui_gl2.h"

#include "exr-io.h"

b3gDefaultOpenGLWindow* window = 0;
int gWidth = 512;
int gHeight = 512;
GLuint gTexId;
float gIntensityScale = 1.0;
float gGamma = 1.0;
int gExrWidth, gExrHeight;
float* gExrRGBA;
int gMousePosX, gMousePosY;

struct nk_context* ctx;

#define MAX_VERTEX_BUFFER 512 * 1024
#define MAX_ELEMENT_BUFFER 128 * 1024

void checkErrors(std::string desc) {
  GLenum e = glGetError();
  if (e != GL_NO_ERROR) {
    fprintf(stderr, "OpenGL error in \"%s\": %d (%d)\n", desc.c_str(), e, e);
    exit(20);
  }
}

void keyboardCallback(int keycode, int state) {
  // printf("hello key %d, state %d\n", keycode, state);
  if (keycode == 27) {
    if (window) window->setRequestExit();
  }
}

void mouseMoveCallback(float x, float y) {
  // printf("Mouse Move: %f, %f\n", x, y);

  gMousePosX = (int)x;
  gMousePosY = (int)y;

  // @todo { move to nuklear_btgui_gl2.h }
  nk_btgui_update_mouse_pos((int)x, (int)y);
}
void mouseButtonCallback(int button, int state, float x, float y) {
  nk_btgui_update_mouse_state((button == 0) && (state == 1), 0, 0);
}

void resizeCallback(float width, float height) {
  GLfloat h = (GLfloat)height / (GLfloat)width;
  GLfloat xmax, znear, zfar;

  znear = 1.0f;
  zfar = 1000.0f;
  xmax = znear * 0.5f;

  gWidth = width;
  gHeight = height;
}

GLuint GenTexture(int w, int h, const float* rgba)
{
  // Create floating point RGBA texture
  GLuint texHandle;
  glGenTextures(1, &texHandle);

  glActiveTexture(GL_TEXTURE0);
  glBindTexture(GL_TEXTURE_2D, texHandle);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

  // @todo { Use GL_RGBA32F for internal texture format. }
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_FLOAT, rgba);
  checkErrors("GenTexture");

  return texHandle;
}


bool
LoadShader(
  GLenum shaderType,  // GL_VERTEX_SHADER or GL_FRAGMENT_SHADER(or maybe GL_COMPUTE_SHADER)
  GLuint& shader,
  const char* shaderSourceFilename)
{
  GLint val = 0;

  // free old shader/program
  if (shader != 0) glDeleteShader(shader);

  static GLchar srcbuf[16384];
  FILE *fp = fopen(shaderSourceFilename, "rb");
  if (!fp) {
    fprintf(stderr, "failed to load shader: %s\n", shaderSourceFilename);
    return false;
  }
  fseek(fp, 0, SEEK_END);
  size_t len = ftell(fp);
  rewind(fp);
  len = fread(srcbuf, 1, len, fp);
  srcbuf[len] = 0;
  fclose(fp);

  static const GLchar *src = srcbuf;

  shader = glCreateShader(shaderType);
  glShaderSource(shader, 1, &src, NULL);
  glCompileShader(shader);
  glGetShaderiv(shader, GL_COMPILE_STATUS, &val);
  if (val != GL_TRUE) {
    char log[4096];
    GLsizei msglen;
    glGetShaderInfoLog(shader, 4096, &msglen, log);
    printf("%s\n", log);
    assert(val == GL_TRUE && "failed to compile shader");
  }

  printf("Load shader [ %s ] OK\n", shaderSourceFilename);
  return true;
}

bool
LinkShader(
  GLuint& prog,
  GLuint& vertShader,
  GLuint& fragShader)
{
  GLint val = 0;
  
  if (prog != 0) {
    glDeleteProgram(prog);
  }

  prog = glCreateProgram();

  glAttachShader(prog, vertShader);
  glAttachShader(prog, fragShader);
  glLinkProgram(prog);

  glGetProgramiv(prog, GL_LINK_STATUS, &val);
  assert(val == GL_TRUE && "failed to link shader");

  printf("Link shader OK\n");

  return true;
}

void
Render(GLuint prog_id, int w, int h)
{
  glDisable(GL_DEPTH_TEST);

  glUseProgram(prog_id);

  glActiveTexture(GL_TEXTURE0);
  glBindTexture(GL_TEXTURE_2D, gTexId);

  glEnable(GL_TEXTURE_2D);
  GLint texLoc = glGetUniformLocation(prog_id, "tex");
  assert(texLoc >= 0);
  glUniform1i(texLoc, 0); // TEXTURE0

  GLint intensityScaleLoc = glGetUniformLocation(prog_id, "intensity_scale");
  if (intensityScaleLoc >= 0) {
    glUniform1f(intensityScaleLoc, gIntensityScale);
  }

  GLint gammaLoc = glGetUniformLocation(prog_id, "gamma");
  if (gammaLoc >= 0) {
    glUniform1f(gammaLoc, gGamma);
  }

  GLint pos_id = glGetAttribLocation(prog_id, "in_position");
  assert(pos_id >= 0);
  GLint texcoord_id = glGetAttribLocation(prog_id, "in_texcoord");
  assert(texcoord_id >= 0);

  const float vertices[] = {-1, -1, -1, 1, 1, 1, 1, -1};
  const float texcoords[] = {0, 1, 0, 0, 1, 0, 1, 1};

  glVertexAttribPointer(pos_id, 2, GL_FLOAT, GL_FALSE, 0, (const void*)(vertices));
  glVertexAttribPointer(texcoord_id, 2, GL_FLOAT, GL_FALSE, 0, (const void*)(texcoords));

  glEnableVertexAttribArray(pos_id);
  glEnableVertexAttribArray(texcoord_id);

  glDrawArrays(GL_QUADS, 0, 4);

  glDisableVertexAttribArray(pos_id);
  glDisableVertexAttribArray(texcoord_id);

  checkErrors("render");

  glUseProgram(0);
  checkErrors("UseProgram(0)");

  glEnable(GL_DEPTH_TEST);
  glDisable(GL_TEXTURE_2D);
}

void InspectPixel(float rgba[4], int x, int y) {
  if (x < 0) x = 0;
  if (x > (gExrWidth-1)) x = gExrWidth - 1;

  if (y < 0) y = 0;
  if (y > (gExrHeight-1)) y = gExrHeight - 1;

  rgba[0] = gExrRGBA[4 * (y * gExrWidth + x) + 0];
  rgba[1] = gExrRGBA[4 * (y * gExrWidth + x) + 1];
  rgba[2] = gExrRGBA[4 * (y * gExrWidth + x) + 2];
  rgba[3] = gExrRGBA[4 * (y * gExrWidth + x) + 3];
}

int main(int argc, char** argv) {

  const char *filename = NULL;
  const char *layername = NULL;

#ifdef USE_NATIVEFILEDIALOG
  if (argc < 2) {
    nfdchar_t *outPath = NULL;
    nfdresult_t result = NFD_OpenDialog( "exr", NULL, &outPath );
    if ( result == NFD_OKAY )
    {
        puts("Success!");
        filename = strdup(outPath);
    }
    else if ( result == NFD_CANCEL )
    {
        puts("User pressed cancel.");
        exit(-1);
    }
    else 
    {
        printf("Error: %s\n", NFD_GetError() );
        exit(-1);
    }
  } else {
    filename = argv[1];
    if (argc > 2) {
      layername = argv[2];
    }
  }
#else
  if (argc < 2) {
    printf("Usage: exrview input.exr [layer name]\n");
    exit(-1);
  }
  filename = argv[1];
  if (argc > 2) {
    layername = argv[2];
  }
#endif

  {
    bool ret = exrio::GetEXRLayers(filename);
    if (!ret) {
      exit(-1);
    }
  }

  {
    bool ret = exrio::LoadEXRRGBA(&gExrRGBA, &gExrWidth, &gExrHeight, filename, layername);
    if (!ret) {
      exit(-1);
    }
  }

  window = new b3gDefaultOpenGLWindow;
  b3gWindowConstructionInfo ci;
#ifdef USE_OPENGL2
  ci.m_openglVersion = 2;
#endif
  ci.m_width = gExrWidth;
  ci.m_height = gExrHeight;
  window->createWindow(ci);

  char title[1024];
  sprintf(title, "%s (%d x %d)", filename, gExrWidth, gExrHeight);
  window->setWindowTitle(title);

#ifndef __APPLE__
#ifndef _WIN32
  //some Linux implementations need the 'glewExperimental' to be true
  glewExperimental = GL_TRUE;
#endif
  if (glewInit() != GLEW_OK) {
	  fprintf(stderr, "Failed to initialize GLEW\n");
	  exit(-1);
  }

  if (!GLEW_VERSION_2_1) {
	  fprintf(stderr, "OpenGL 2.1 is not available\n");
	  exit(-1);
  }
#endif


  checkErrors("init");

  window->setMouseButtonCallback(mouseButtonCallback);
  window->setMouseMoveCallback(mouseMoveCallback);
  checkErrors("mouse");
  window->setKeyboardCallback(keyboardCallback);
  checkErrors("keyboard");
  window->setResizeCallback(resizeCallback);
  checkErrors("resize");

  struct nk_color background;
  background = nk_rgb(28,48,62);


  {
    // Upload EXR image to OpenGL texture.
    gTexId = GenTexture(gExrWidth, gExrHeight, gExrRGBA);
    if (gTexId == 0) {
      fprintf(stderr, "OpenGL texture error\n");
      exit(-1);
    }
  }


  /* GUI */
  ctx = nk_btgui_init(window, NK_BTGUI3_DEFAULT);
  /* Load Fonts: if none of these are loaded a default font will be used  */
  {
    struct nk_font_atlas* atlas;
    nk_btgui_font_stash_begin(&atlas);
    /*struct nk_font *droid = nk_font_atlas_add_from_file(atlas,
     * "../../../extra_font/DroidSans.ttf", 14, 0);*/
    /*struct nk_font *roboto = nk_font_atlas_add_from_file(atlas,
     * "../../../extra_font/Roboto-Regular.ttf", 14, 0);*/
    /*struct nk_font *future = nk_font_atlas_add_from_file(atlas,
     * "../../../extra_font/kenvector_future_thin.ttf", 13, 0);*/
    /*struct nk_font *clean = nk_font_atlas_add_from_file(atlas,
     * "../../../extra_font/ProggyClean.ttf", 12, 0);*/
    /*struct nk_font *tiny = nk_font_atlas_add_from_file(atlas,
     * "../../../extra_font/ProggyTiny.ttf", 10, 0);*/
    /*struct nk_font *cousine = nk_font_atlas_add_from_file(atlas,
     * "../../../extra_font/Cousine-Regular.ttf", 13, 0);*/
    struct nk_font *droid = nk_font_atlas_add_from_file(atlas,
     "./DroidSans.ttf", 14, 0);
    nk_btgui_font_stash_end();
    if (droid) {
      nk_style_set_font(ctx, &droid->handle);
    }

    // Color
    struct nk_color table[NK_COLOR_COUNT];
    table[NK_COLOR_TEXT] = nk_rgba(210, 210, 210, 255);
    table[NK_COLOR_WINDOW] = nk_rgba(57, 67, 71, 245);
    table[NK_COLOR_HEADER] = nk_rgba(51, 51, 56, 230);
    table[NK_COLOR_BORDER] = nk_rgba(46, 46, 46, 255);
    table[NK_COLOR_BUTTON] = nk_rgba(48, 48, 48, 255);
    table[NK_COLOR_BUTTON_HOVER] = nk_rgba(58, 93, 121, 255);
    table[NK_COLOR_BUTTON_ACTIVE] = nk_rgba(63, 98, 126, 255);
    table[NK_COLOR_TOGGLE] = nk_rgba(50, 58, 61, 255);
    table[NK_COLOR_TOGGLE_HOVER] = nk_rgba(45, 53, 56, 255);
    table[NK_COLOR_TOGGLE_CURSOR] = nk_rgba(48, 83, 111, 255);
    table[NK_COLOR_SELECT] = nk_rgba(57, 67, 61, 255);
    table[NK_COLOR_SELECT_ACTIVE] = nk_rgba(48, 83, 111, 255);
    table[NK_COLOR_SLIDER] = nk_rgba(50, 58, 61, 255);
    table[NK_COLOR_SLIDER_CURSOR] = nk_rgba(48, 83, 111, 245);
    table[NK_COLOR_SLIDER_CURSOR_HOVER] = nk_rgba(53, 88, 116, 255);
    table[NK_COLOR_SLIDER_CURSOR_ACTIVE] = nk_rgba(58, 93, 121, 255);
    table[NK_COLOR_PROPERTY] = nk_rgba(50, 58, 61, 255);
    table[NK_COLOR_EDIT] = nk_rgba(50, 58, 61, 225);
    table[NK_COLOR_EDIT_CURSOR] = nk_rgba(210, 210, 210, 255);
    table[NK_COLOR_COMBO] = nk_rgba(50, 58, 61, 255);
    table[NK_COLOR_CHART] = nk_rgba(50, 58, 61, 255);
    table[NK_COLOR_CHART_COLOR] = nk_rgba(48, 83, 111, 255);
    table[NK_COLOR_CHART_COLOR_HIGHLIGHT] = nk_rgba(255, 0, 0, 255);
    table[NK_COLOR_SCROLLBAR] = nk_rgba(50, 58, 61, 255);
    table[NK_COLOR_SCROLLBAR_CURSOR] = nk_rgba(48, 83, 111, 255);
    table[NK_COLOR_SCROLLBAR_CURSOR_HOVER] = nk_rgba(53, 88, 116, 255);
    table[NK_COLOR_SCROLLBAR_CURSOR_ACTIVE] = nk_rgba(58, 93, 121, 255);
    table[NK_COLOR_TAB_HEADER] = nk_rgba(48, 83, 111, 255);
    nk_style_from_table(ctx, table);
  }

  checkErrors("start");

  GLuint vert_id = 0, frag_id = 0, prog_id = 0;
  {
    bool ret = LoadShader(GL_VERTEX_SHADER, vert_id, "shader.vert");
    if (!ret) {
      fprintf(stderr, "Failed to compile vertex shader.\n");
      exit(-1);
    }
  }
  checkErrors("vertex shader load");

  {
    bool ret = LoadShader(GL_FRAGMENT_SHADER, frag_id, "shader.frag");
    if (!ret) {
      fprintf(stderr, "Failed to compile fragment shader.\n");
      exit(-1);
    }
  }
  checkErrors("fragment shader load");

  {
    bool ret = LinkShader(prog_id, vert_id, frag_id);
    if (!ret) {
      fprintf(stderr, "Failed to link shader.\n");
      exit(-1);
    }
  }
  checkErrors("link shader");


  while (!window->requestedExit()) {
    window->startRendering();

    glClear(GL_COLOR_BUFFER_BIT);

    checkErrors("begin frame");
    nk_btgui_new_frame();

    float pixel[4];
    InspectPixel(pixel, gMousePosX, gMousePosY);

    /* GUI */
    {
      //struct nk_panel layout;
      if (nk_begin(ctx, "UI", nk_rect(50, 50, 350, 250),
                   NK_WINDOW_BORDER | NK_WINDOW_MOVABLE | NK_WINDOW_SCALABLE |
                       NK_WINDOW_MINIMIZABLE | NK_WINDOW_TITLE)) {
        nk_layout_row_static(ctx, 30, 300, 1);
        //if (nk_button_label(ctx, "button", NK_BUTTON_DEFAULT))
        //  fprintf(stdout, "button pressed\n");

        nk_label(ctx, "Intensity", NK_TEXT_LEFT);
        if (nk_slider_float(ctx, 0, &gIntensityScale, 10.0, 0.1f)) {
            fprintf(stdout, "Intensity: %f\n", gIntensityScale);
        }
        nk_label(ctx, "Display gamma", NK_TEXT_LEFT);
        if (nk_slider_float(ctx, 0, &gGamma, 10.0, 0.01f)) {
            fprintf(stdout, "Gamma: %f\n", gGamma);
        }

        nk_label(ctx, "RAW pixel value", NK_TEXT_LEFT);
        char txt[1024];
        sprintf(txt, "(%d, %d) = %f, %f, %f, %f", gMousePosX, gMousePosY, pixel[0], pixel[1], pixel[2], pixel[3]);
        nk_text(ctx, txt, strlen(txt), NK_TEXT_LEFT);

#if 0
        nk_layout_row_dynamic(ctx, 25, 1);
        nk_property_int(ctx, "Compression:", 0, &property, 100, 10, 1);

        {
          struct nk_panel combo;
          nk_layout_row_dynamic(ctx, 20, 1);
          nk_label(ctx, "background:", NK_TEXT_LEFT);
          nk_layout_row_dynamic(ctx, 25, 1);
          if (nk_combo_begin_color(ctx, &combo, background, 400)) {
            nk_layout_row_dynamic(ctx, 120, 1);
            background = nk_color_picker(ctx, background, NK_RGBA);
            nk_layout_row_dynamic(ctx, 25, 1);
            background.r =
                (nk_byte)nk_propertyi(ctx, "#R:", 0, background.r, 255, 1, 1);
            background.g =
                (nk_byte)nk_propertyi(ctx, "#G:", 0, background.g, 255, 1, 1);
            background.b =
                (nk_byte)nk_propertyi(ctx, "#B:", 0, background.b, 255, 1, 1);
            background.a =
                (nk_byte)nk_propertyi(ctx, "#A:", 0, background.a, 255, 1, 1);
            nk_combo_end(ctx);
          }
        }
#endif
      }
      nk_end(ctx);
    }

    /* Draw */
    {
      float bg[4];
      nk_color_fv(bg, background);
      glViewport(0, 0, window->getWidth(), window->getHeight());
      glClear(GL_COLOR_BUFFER_BIT);
      glClearColor(bg[0], bg[1], bg[2], bg[3]);

      Render(prog_id, window->getWidth(), window->getHeight());

      /* IMPORTANT: `nk_glfw_render` modifies some global OpenGL state
       * with blending, scissor, face culling and depth test and defaults
       * everything
       * back into a default state. Make sure to either save and restore or
       * reset your own state after drawing rendering the UI. */
      nk_btgui_render(NK_ANTI_ALIASING_ON, MAX_VERTEX_BUFFER,
                      MAX_ELEMENT_BUFFER);
    }

    window->endRendering();
  }

  nk_btgui_shutdown();

  delete window;

  return EXIT_SUCCESS;
}