// Copyright (C) 2015 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "anbox/graphics/emugl/TextureDraw.h"
#include "anbox/graphics/emugl/DispatchTables.h"
#include "anbox/logger.h"

#include <math.h>
#include <string.h>
#include <vector>

#include <stdio.h>

// M_PI isn't defined in C++ (when strict ISO compliance is enabled)
#ifndef M_PI
#define M_PI 3.14159265358979323846264338327
#endif

namespace {

// Helper function to create a new shader.
// |shaderType| is the shader type (e.g. GL_VERTEX_SHADER).
// |shaderText| is a 0-terminated C string for the shader source to use.
// On success, return the handle of the new compiled shader, or 0 on failure.
GLuint createShader(GLint shaderType, const char* shaderText) {
  // Create new shader handle and attach source.
  GLuint shader = s_gles2.glCreateShader(shaderType);
  if (!shader) {
    return 0;
  }
  const GLchar* text = static_cast<const GLchar*>(shaderText);
  const GLint textLen = ::strlen(shaderText);
  s_gles2.glShaderSource(shader, 1, &text, &textLen);

  // Compiler the shader.
  GLint success;
  s_gles2.glCompileShader(shader);
  s_gles2.glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
  if (success == GL_FALSE) {
    s_gles2.glDeleteShader(shader);
    return 0;
  }

  return shader;
}

// No scaling / projection since we want to fill the whole viewport with
// the texture, hence a trivial vertex shader.
const char kVertexShaderSource[] =
    "attribute vec4 position;\n"
    "attribute vec2 inCoord;\n"
    "varying lowp vec2 outCoord;\n"
    "void main(void) {\n"
    "  gl_Position.x = position.x;\n"
    "  gl_Position.y = position.y;\n"
    "  gl_Position.zw = position.zw;\n"
    "  outCoord = inCoord;\n"
    "}\n";

// Similarly, just interpolate texture coordinates.
const char kFragmentShaderSource[] =
    "varying lowp vec2 outCoord;\n"
    "uniform sampler2D texture;\n"

    "void main(void) {\n"
    "  gl_FragColor = texture2D(texture, outCoord);\n"
    "}\n";

// Hard-coded arrays of vertex information.
struct Vertex {
  float pos[3];
  float coord[2];
};

const Vertex kVertices[] = {
    {{+1, -1, +0}, {+1, +1}},
    {{+1, +1, +0}, {+1, +0}},
    {{-1, +1, +0}, {+0, +0}},
    {{-1, -1, +0}, {+0, +1}},
};

const GLubyte kIndices[] = {0, 1, 2, 2, 3, 0};
const GLint kIndicesLen = sizeof(kIndices) / sizeof(kIndices[0]);

}  // namespace

TextureDraw::TextureDraw(EGLDisplay)
    : mVertexShader(0),
      mFragmentShader(0),
      mProgram(0),
      mPositionSlot(-1),
      mInCoordSlot(-1),
      mTextureSlot(-1) {
  // Create shaders and program.
  mVertexShader = createShader(GL_VERTEX_SHADER, kVertexShaderSource);
  mFragmentShader = createShader(GL_FRAGMENT_SHADER, kFragmentShaderSource);

  mProgram = s_gles2.glCreateProgram();
  s_gles2.glAttachShader(mProgram, mVertexShader);
  s_gles2.glAttachShader(mProgram, mFragmentShader);

  GLint success;
  s_gles2.glLinkProgram(mProgram);
  s_gles2.glGetProgramiv(mProgram, GL_LINK_STATUS, &success);
  if (success == GL_FALSE) {
    GLchar messages[256];
    s_gles2.glGetProgramInfoLog(mProgram, sizeof(messages), 0, &messages[0]);
    ERROR("Could not create/link program: %s", messages);
    s_gles2.glDeleteProgram(mProgram);
    mProgram = 0;
    return;
  }

  s_gles2.glUseProgram(mProgram);

  // Retrieve attribute/uniform locations.
  mPositionSlot = s_gles2.glGetAttribLocation(mProgram, "position");
  s_gles2.glEnableVertexAttribArray(mPositionSlot);

  mInCoordSlot = s_gles2.glGetAttribLocation(mProgram, "inCoord");
  s_gles2.glEnableVertexAttribArray(mInCoordSlot);

  mTextureSlot = s_gles2.glGetUniformLocation(mProgram, "texture");

  // Create vertex and index buffers.
  s_gles2.glGenBuffers(1, &mVertexBuffer);
  s_gles2.glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
  s_gles2.glBufferData(GL_ARRAY_BUFFER, sizeof(kVertices), kVertices,
                       GL_STATIC_DRAW);

  s_gles2.glGenBuffers(1, &mIndexBuffer);
  s_gles2.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer);
  s_gles2.glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(kIndices), kIndices,
                       GL_STATIC_DRAW);
}

bool TextureDraw::draw(GLuint texture) {
  if (!mProgram) {
    ERROR(" No program");
    return false;
  }

  // TODO(digit): Save previous program state.

  GLenum err;

  s_gles2.glUseProgram(mProgram);
  err = s_gles2.glGetError();
  if (err != GL_NO_ERROR) {
    ERROR("Could not use program error 0x%x", err);
  }

  // Setup the |position| attribute values.
  s_gles2.glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
  err = s_gles2.glGetError();
  if (err != GL_NO_ERROR) {
    ERROR("Could not bind GL_ARRAY_BUFFER error=0x%x", err);
  }

  s_gles2.glEnableVertexAttribArray(mPositionSlot);
  s_gles2.glVertexAttribPointer(mPositionSlot, 3, GL_FLOAT, GL_FALSE,
                                sizeof(Vertex), 0);
  err = s_gles2.glGetError();
  if (err != GL_NO_ERROR) {
    ERROR("Could glVertexAttribPointer with mPositionSlot error 0x%x", err);
  }

  // Setup the |inCoord| attribute values.
  s_gles2.glEnableVertexAttribArray(mInCoordSlot);
  s_gles2.glVertexAttribPointer(
      mInCoordSlot, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
      reinterpret_cast<GLvoid*>(static_cast<uintptr_t>(sizeof(float) * 3)));

  // setup the |texture| uniform value.
  s_gles2.glActiveTexture(GL_TEXTURE0);
  s_gles2.glBindTexture(GL_TEXTURE_2D, texture);
  s_gles2.glUniform1i(mTextureSlot, 0);

  // Validate program, just to be sure.
  s_gles2.glValidateProgram(mProgram);
  GLint validState = 0;
  s_gles2.glGetProgramiv(mProgram, GL_VALIDATE_STATUS, &validState);
  if (validState == GL_FALSE) {
    GLchar messages[256];
    s_gles2.glGetProgramInfoLog(mProgram, sizeof(messages), 0, &messages[0]);
    ERROR("Could not run program: %s", messages);
    return false;
  }

  // Do the rendering.
  s_gles2.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer);
  err = s_gles2.glGetError();
  if (err != GL_NO_ERROR) {
    ERROR("Could not glBindBuffer(GL_ELEMENT_ARRAY_BUFFER) error 0x%x", err);
  }

  s_gles2.glDrawElements(GL_TRIANGLES, kIndicesLen, GL_UNSIGNED_BYTE, 0);
  err = s_gles2.glGetError();
  if (err != GL_NO_ERROR) {
    ERROR("Could not glDrawElements() error 0x%x", err);
  }

  // TODO(digit): Restore previous program state.

  return true;
}

TextureDraw::~TextureDraw() {
  s_gles2.glDeleteBuffers(1, &mIndexBuffer);
  s_gles2.glDeleteBuffers(1, &mVertexBuffer);

  if (mFragmentShader) {
    s_gles2.glDeleteShader(mFragmentShader);
  }
  if (mVertexShader) {
    s_gles2.glDeleteShader(mVertexShader);
  }
}