#include <stdio.h>
#include <stdlib.h>
#include <GL/glew.h>
#include <GL/glut.h>

GLuint program;
GLuint vbo_vertices;
GLUINT vbo_temperature;
GLint attribute_coord2d;
GLint attribute_temperature;

static const GLchar * vertex_shader[] = {
  "attribute vec2 coord2d;" // input vertex position
  "attribute float temperature;" // custom variable along with vertex position
  "varying float  t;" // communicate between the vertex and the fragment shader
  "void main()"
  "{"
  "  t = temperature;"
  "  gl_Position = gl_ModelViewProjectionMatrix*vec4(coord2d, 0.0, 1.0);"
  "}"
};
static const GLchar * fragment_shader[] = {
  "vec3 Cool = vec3(0, 0, 1);" // Red
  "vec3 Hot  = vec3(1, 0, 0);" // Blue
  "varying float t;" // Interpolated by fragment
  "void main()"
  "{"
  "  vec3 color = mix(Cool, Hot, t);"  // use the built-in mix() function
  "  gl_FragColor = vec4(color, 1.0);" // append alpha channel
  "}"
};

void active_vertex_shader_inputs(GLuint prog)
{
  char *name;
  GLint active_attribs, max_length;
  unsigned i;

  glGetProgramiv(prog, GL_ACTIVE_ATTRIBUTES, &active_attribs);
  glGetProgramiv(prog, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_length);

  name = malloc(max_length + 1);
  printf("Active vertex shader inputs:\n");
  for (i = 0; i < active_attribs; i++) {
    GLint size;
    GLenum type;
    
    glGetActiveAttrib(prog, i, max_length + 1, NULL,
                      &size, &type, name);
    printf("Vertex input attribute %s of type %d is at location %d\n", 
           name, type, glGetAttribLocation(prog, name));
  }
  free(name);
}

void create_shaders()
{
  GLuint v, f;

  v = glCreateShader(GL_VERTEX_SHADER);
  f = glCreateShader(GL_FRAGMENT_SHADER);
  glShaderSource(v, 1, vertex_shader, NULL);
  glShaderSource(f, 1, fragment_shader, NULL);
  glCompileShader(v);
  GLint compiled;
  glGetShaderiv(v, GL_COMPILE_STATUS, &compiled );
  if ( !compiled ) {
    GLsizei  maxLength, length;
    glGetShaderiv( v, GL_INFO_LOG_LENGTH, &maxLength );
    GLchar* log = malloc(sizeof(GLchar)*(maxLength+1));
    glGetShaderInfoLog(v,  maxLength, &length, log);
    printf("Vertex Shader compilation failed: %s\n", log);
    free(log);
  }
  glCompileShader(f);
  glGetShaderiv(f, GL_COMPILE_STATUS, &compiled );
  if ( !compiled ) {
    GLsizei  maxLength, length;
    glGetShaderiv( f, GL_INFO_LOG_LENGTH, &maxLength );
    GLchar* log = malloc(sizeof(GLchar)*(maxLength+1));
    glGetShaderInfoLog(f,  maxLength, &length, log);
    printf("Fragment Shader compilation failed: %s\n", log);
    free(log);
  }
  program = glCreateProgram();
  glAttachShader(program, f);
  glAttachShader(program, v);
  glLinkProgram(program);
  GLint linked;
  glGetProgramiv(program, GL_LINK_STATUS, &linked );
  if ( !linked ) {
    GLsizei len;
    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &len );
    GLchar* log = malloc(sizeof(GLchar)*(len+1));
    glGetProgramInfoLog(program, len, &len, log );
    printf("Shader linking failed: %s\n", log);
    free(log);
  }
  glUseProgram(program);


  attribute_coord2d = glGetAttribLocation(program, "coord2d");
  if (attribute_coord2d == -1) {
    fprintf(stderr, "Could not bind attribute coord2d\n");
  }
  glEnableVertexAttribArray(attribute_coord2d);

  attribute_temperature = glGetAttribLocation(program, "temperature");
  if (attribute_temperature == -1) {
    fprintf(stderr, "Could not bind attribute temperature\n");
  }
  glEnableVertexAttribArray(attribute_temperature); // toggle this
  active_vertex_shader_inputs(program);
  
}

void send_buffers_to_GPU(void)
{
  GLuint vertex_array_object;
  glGenVertexArrays(1, &vertex_array_object);
  glBindVertexArray(vertex_array_object);
  
  GLfloat vertices[][2] = {
    { -0.90, -0.90 }, // Triangle 1
    {  0.85, -0.90 },
    { -0.90,  0.85 },
    {  0.90, -0.85 }, // Triangle 2
    {  0.90,  0.90 },
    { -0.85,  0.90 }
  };

  glGenBuffers(1, &vbo_vertices);
  glBindBuffer(GL_ARRAY_BUFFER, vbo_vertices);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

  GLfloat vertex_temperature[] = {0, 1, 0.2, 0.1, 0.5, 0.9};
  glGenBuffers(1, &vbo_temperature);
  glBindBuffer(GL_ARRAY_BUFFER, vbo_temperature);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_temperature),
             vertex_temperature, GL_STATIC_DRAW);
}


void display(void)
{
  glClear(GL_COLOR_BUFFER_BIT);
  
  glBindBuffer(GL_ARRAY_BUFFER, vbo_vertices);
  glVertexAttribPointer(attribute_coord2d, 2, GL_FLOAT, GL_FALSE, 0, NULL);

  glBindBuffer(GL_ARRAY_BUFFER, vbo_temperature);
  glVertexAttribPointer(attribute_temperature, 1, GL_FLOAT, GL_FALSE, 0, NULL);
                          
  glDrawArrays(GL_TRIANGLES, 0, 6); // Draw 6 vertices
  glutSwapBuffers();
}

int main(int argc, char **argv)
{
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
  glutCreateWindow("GLSL Intro");
  glutDisplayFunc(display);
  glewInit();
  if (!glewIsSupported("GL_VERSION_2_0"))
   {
     printf("GLSL not supported\n");
     exit(EXIT_FAILURE);
   }
  glClearColor(0.9,1.0,1.0,1.0);
  send_buffers_to_GPU();
  create_shaders();

  glutMainLoop();
  return EXIT_SUCCESS;
}