/*
 * Copyright (C) 2019 cyclopsian

 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:

 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include "wdisplays.h"

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <epoxy/gl.h>
#include <wayland-util.h>

#define CANVAS_MARGIN 100

#define BT_UV_VERT_SIZE (2 + 2)
#define BT_UV_QUAD_SIZE (6 * BT_UV_VERT_SIZE)
#define BT_UV_MAX (BT_COLOR_QUAD_SIZE * HEADS_MAX)

#define BT_COLOR_VERT_SIZE (2 + 4)
#define BT_COLOR_QUAD_SIZE (6 * BT_COLOR_VERT_SIZE)
#define BT_COLOR_MAX (BT_COLOR_QUAD_SIZE * HEADS_MAX)

struct wd_gl_data {
  GLuint color_program;
  GLuint color_vertex_shader;
  GLuint color_fragment_shader;
  GLuint color_position_attribute;
  GLuint color_color_attribute;
  GLuint color_screen_size_uniform;

  GLuint texture_program;
  GLuint texture_vertex_shader;
  GLuint texture_fragment_shader;
  GLuint texture_position_attribute;
  GLuint texture_uv_attribute;
  GLuint texture_screen_size_uniform;
  GLuint texture_texture_uniform;
  GLuint texture_color_transform_uniform;

  GLuint buffers[2];

  unsigned texture_count;
  GLuint textures[HEADS_MAX];

  float tris[BT_COLOR_MAX];
};

static const char *color_vertex_shader_src = "\
attribute vec2 position;\n\
attribute vec4 color;\n\
varying vec4 color_out;\n\
uniform vec2 screen_size;\n\
void main(void) {\n\
  vec2 screen_pos = (position / screen_size * 2. - 1.) * vec2(1., -1.);\n\
  gl_Position = vec4(screen_pos, 0., 1.);\n\
  color_out = color;\n\
}";

static const char *color_fragment_shader_src = "\
varying vec4 color_out;\n\
void main(void) {\n\
  gl_FragColor = color_out;\n\
}";

static const char *texture_vertex_shader_src = "\
attribute vec2 position;\n\
attribute vec2 uv;\n\
varying vec2 uv_out;\n\
uniform vec2 screen_size;\n\
void main(void) {\n\
  vec2 screen_pos = (position / screen_size * 2. - 1.) * vec2(1., -1.);\n\
  gl_Position = vec4(screen_pos, 0., 1.);\n\
  uv_out = uv;\n\
}";

static const char *texture_fragment_shader_src = "\
varying vec2 uv_out;\n\
uniform sampler2D texture;\n\
uniform mat4 color_transform;\n\
void main(void) {\n\
  gl_FragColor = texture2D(texture, uv_out) * color_transform;\n\
}";

static GLuint gl_make_shader(GLenum type, const char *src) {
  GLuint shader = glCreateShader(type);
  glShaderSource(shader, 1, &src, NULL);
  glCompileShader(shader);
  GLint status;
  glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
  if (status == GL_FALSE) {
    GLsizei length;
    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
    GLchar *log = "Failed";
    if (length > 0) {
      log = malloc(length);
      glGetShaderInfoLog(shader, length, NULL, log);
    }
    fprintf(stderr, "glCompileShader: %s\n", log);
    if (length > 0) {
      free(log);
    }
  }
  return shader;
}

static void gl_link_and_validate(GLint program) {
  GLint status;

  glLinkProgram(program);
  glGetProgramiv(program, GL_LINK_STATUS, &status);
  if (status == GL_FALSE) {
    GLsizei length;
    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length);
    GLchar *log = malloc(length);
    glGetProgramInfoLog(program, length, NULL, log);
    fprintf(stderr, "glLinkProgram: %s\n", log);
    free(log);
    return;
  }
  glValidateProgram(program);
  glGetProgramiv(program, GL_VALIDATE_STATUS, &status);
  if (status == GL_FALSE) {
    GLsizei length;
    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length);
    GLchar *log = malloc(length);
    glGetProgramInfoLog(program, length, NULL, log);
    fprintf(stderr, "glValidateProgram: %s\n", log);
    free(log);
  }
}

struct wd_gl_data *wd_gl_setup(void) {
  struct wd_gl_data *res = calloc(1, sizeof(struct wd_gl_data));
  res->color_program = glCreateProgram();

  res->color_vertex_shader = gl_make_shader(GL_VERTEX_SHADER,
      color_vertex_shader_src);
  glAttachShader(res->color_program, res->color_vertex_shader);
  res->color_fragment_shader = gl_make_shader(GL_FRAGMENT_SHADER,
      color_fragment_shader_src);
  glAttachShader(res->color_program, res->color_fragment_shader);
  gl_link_and_validate(res->color_program);

  res->color_position_attribute = glGetAttribLocation(res->color_program,
      "position");
  res->color_color_attribute = glGetAttribLocation(res->color_program,
      "color");
  res->color_screen_size_uniform = glGetUniformLocation(res->color_program,
      "screen_size");

  res->texture_program = glCreateProgram();

  res->texture_vertex_shader = gl_make_shader(GL_VERTEX_SHADER,
      texture_vertex_shader_src);
  glAttachShader(res->texture_program, res->texture_vertex_shader);
  res->texture_fragment_shader = gl_make_shader(GL_FRAGMENT_SHADER,
      texture_fragment_shader_src);
  glAttachShader(res->texture_program, res->texture_fragment_shader);
  gl_link_and_validate(res->texture_program);

  res->texture_position_attribute = glGetAttribLocation(res->texture_program,
      "position");
  res->texture_uv_attribute = glGetAttribLocation(res->texture_program,
      "uv");
  res->texture_screen_size_uniform = glGetUniformLocation(res->texture_program,
      "screen_size");
  res->texture_texture_uniform = glGetUniformLocation(res->texture_program,
      "texture");
  res->texture_color_transform_uniform = glGetUniformLocation(
      res->texture_program, "color_transform");

  glGenBuffers(2, res->buffers);
  glBindBuffer(GL_ARRAY_BUFFER, res->buffers[0]);
  glBufferData(GL_ARRAY_BUFFER, BT_UV_MAX * sizeof(float),
      NULL, GL_DYNAMIC_DRAW);

  glBindBuffer(GL_ARRAY_BUFFER, res->buffers[1]);
  glBufferData(GL_ARRAY_BUFFER, BT_COLOR_MAX * sizeof(float),
      NULL, GL_DYNAMIC_DRAW);

  return res;
}

static const GLfloat TRANSFORM_RGB[16] = {
  1, 0, 0, 0,
  0, 1, 0, 0,
  0, 0, 1, 0,
  0, 0, 0, 1};

static const GLfloat TRANSFORM_BGR[16] = {
  0, 0, 1, 0,
  0, 1, 0, 0,
  1, 0, 0, 0,
  0, 0, 0, 1};

#define PUSH_POINT(_start, _a, _b) \
    *((_start)++) = (_a);\
    *((_start)++) = (_b);

#define PUSH_COLOR(_start, _a, _b, _c, _d) \
    *((_start)++) = (_a);\
    *((_start)++) = (_b);\
    *((_start)++) = (_c);\
    *((_start)++) = (_d);

#define PUSH_POINT_UV(_start, _a, _b, _c, _d) \
    PUSH_COLOR(_start, _a, _b, _c, _d)

void wd_gl_render(struct wd_gl_data *res, struct wd_render_data *info,
    uint64_t tick) {
  unsigned int tris = 0;

  unsigned int head_count = wl_list_length(&info->heads);
  if (head_count >= HEADS_MAX) {
    head_count = HEADS_MAX;
  }

  if (head_count > res->texture_count) {
    glGenTextures(head_count - res->texture_count,
        res->textures + res->texture_count);
    for (int i = res->texture_count; i < head_count; i++) {
      glBindTexture(GL_TEXTURE_2D, res->textures[i]);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    }
    glBindTexture(GL_TEXTURE_2D, 0);
    res->texture_count = head_count;
  }

  struct wd_render_head_data *head;
  int i = 0;
  wl_list_for_each_reverse(head, &info->heads, link) {
    float *tri_ptr = res->tris + i * BT_UV_QUAD_SIZE;
    float x1 = head->x1;
    float y1 = head->y1;
    float x2 = head->x2;
    float y2 = head->y2;

    float t1 = head->y_invert ? 1.f : 0.f;
    float t2 = head->y_invert ? 0.f : 1.f;

    PUSH_POINT_UV(tri_ptr, x1, y1, 0.f, t1)
    PUSH_POINT_UV(tri_ptr, x2, y1, 1.f, t1)
    PUSH_POINT_UV(tri_ptr, x1, y2, 0.f, t2)
    PUSH_POINT_UV(tri_ptr, x1, y2, 0.f, t2)
    PUSH_POINT_UV(tri_ptr, x2, y1, 1.f, t1)
    PUSH_POINT_UV(tri_ptr, x2, y2, 1.f, t2)

    tris += 6;
    i++;
    if (i >= HEADS_MAX) {
      break;
    }
  }

  glClearColor(info->bg_color[0], info->bg_color[1], info->bg_color[2], 1.f);
  glClear(GL_COLOR_BUFFER_BIT);

  float screen_size[2] = { info->viewport_width, info->viewport_height };

  if (tris > 0) {
    glUseProgram(res->texture_program);
    glBindBuffer(GL_ARRAY_BUFFER, res->buffers[0]);
    glBufferSubData(GL_ARRAY_BUFFER, 0,
        tris * BT_UV_VERT_SIZE * sizeof(float), res->tris);
    glEnableVertexAttribArray(res->texture_position_attribute);
    glEnableVertexAttribArray(res->texture_uv_attribute);
    glVertexAttribPointer(res->texture_position_attribute,
        2, GL_FLOAT, GL_FALSE,
        BT_UV_VERT_SIZE * sizeof(float), (void *) (0 * sizeof(float)));
    glVertexAttribPointer(res->texture_uv_attribute, 2, GL_FLOAT, GL_FALSE,
        BT_UV_VERT_SIZE * sizeof(float), (void *) (2 * sizeof(float)));
    glUniform2fv(res->texture_screen_size_uniform, 1, screen_size);
    glUniform1i(res->texture_texture_uniform, 0);
    glActiveTexture(GL_TEXTURE0);

    i = 0;
    wl_list_for_each_reverse(head, &info->heads, link) {
      glBindTexture(GL_TEXTURE_2D, res->textures[i]);
      if (head->updated_at == tick) {
        glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, head->tex_stride / 4);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
            head->tex_width, head->tex_height,
            0, GL_RGBA, GL_UNSIGNED_BYTE, head->pixels);
        glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, 0);
      }
      glUniformMatrix4fv(res->texture_color_transform_uniform, 1, GL_FALSE,
        head->swap_rgb ? TRANSFORM_RGB : TRANSFORM_BGR);
      glDrawArrays(GL_TRIANGLES, i * 6, 6);
      i++;
      if (i >= HEADS_MAX) {
        break;
      }
    }
  }

  tris = 0;

  int j = 0;
  i = 0;
  wl_list_for_each_reverse(head, &info->heads, link) {
    if (head->hovered || tick < head->transition_begin + HOVER_USECS) {
      float *tri_ptr = res->tris + j++ * BT_COLOR_QUAD_SIZE;
      float x1 = head->x1;
      float y1 = head->y1;
      float x2 = head->x2;
      float y2 = head->y2;

      float *color = info->selection_color;
      float d = fminf(
          (tick - head->transition_begin) / (double) HOVER_USECS, 1.f);
      if (!head->hovered) {
        d = 1.f - d;
      }
      d *= 2.f;
      if (d <= 1.f) {
        d = d * d;
      } else {
        d -= 1.f;
        d = d * (2.f - d) + 1.f;
      }
      d /= 2.f;
      float alpha = color[3] * d * .5f;

      PUSH_POINT(tri_ptr, x1, y1)
      PUSH_COLOR(tri_ptr, color[0], color[1], color[2], alpha)
      PUSH_POINT(tri_ptr, x2, y1)
      PUSH_COLOR(tri_ptr, color[0], color[1], color[2], alpha)
      PUSH_POINT(tri_ptr, x1, y2)
      PUSH_COLOR(tri_ptr, color[0], color[1], color[2], alpha)
      PUSH_POINT(tri_ptr, x1, y2)
      PUSH_COLOR(tri_ptr, color[0], color[1], color[2], alpha)
      PUSH_POINT(tri_ptr, x2, y1)
      PUSH_COLOR(tri_ptr, color[0], color[1], color[2], alpha)
      PUSH_POINT(tri_ptr, x2, y2)
      PUSH_COLOR(tri_ptr, color[0], color[1], color[2], alpha)

      tris += 6;
    }
    i++;
    if (i >= HEADS_MAX) {
      break;
    }
  }

  if (tris > 0) {
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glUseProgram(res->color_program);
    glBindBuffer(GL_ARRAY_BUFFER, res->buffers[1]);
    glBufferSubData(GL_ARRAY_BUFFER, 0,
        tris * BT_COLOR_VERT_SIZE * sizeof(float), res->tris);
    glEnableVertexAttribArray(res->color_position_attribute);
    glEnableVertexAttribArray(res->color_color_attribute);
    glVertexAttribPointer(res->color_position_attribute, 2, GL_FLOAT, GL_FALSE,
        BT_COLOR_VERT_SIZE * sizeof(float), (void *) (0 * sizeof(float)));
    glVertexAttribPointer(res->color_color_attribute, 4, GL_FLOAT, GL_FALSE,
        BT_COLOR_VERT_SIZE * sizeof(float), (void *) (2 * sizeof(float)));
    glUniform2fv(res->color_screen_size_uniform, 1, screen_size);
    glDrawArrays(GL_TRIANGLES, 0, tris);
    glDisable(GL_BLEND);
  }
}

void wd_gl_cleanup(struct wd_gl_data *res) {
  glDeleteBuffers(2, res->buffers);
  glDeleteShader(res->texture_fragment_shader);
  glDeleteShader(res->texture_vertex_shader);
  glDeleteProgram(res->texture_program);

  glDeleteShader(res->color_fragment_shader);
  glDeleteShader(res->color_vertex_shader);
  glDeleteProgram(res->color_program);

  free(res);
}