#include "primitive.h"

primitive_t * primitiveCreate(int32_t verticeCount) {
  primitive_t *primitive = malloc(sizeof(primitive_t));

  primitive->verticeCount = verticeCount;

  size_t sizeIndices = sizeof(uint32_t) * verticeCount;
  size_t sizePositions = sizeof(float) * verticeCount * PRIMITIVE_POSITIONS_PER_VERTICE;
  size_t sizeCoordinates = sizeof(float) * verticeCount * PRIMITIVE_COORDINATES_PER_VERTICE;

  //Setup Vertex Array Object
  glGenVertexArrays(1, &primitive->vertexArray);
  glBindVertexArray(primitive->vertexArray);

  // Create some buffers, one for the vertex data, one for the indices
  GLuint buffer[2];
  glGenBuffers(2, &buffer);

  primitive->vertexBuffer = buffer[0];
  primitive->indexBuffer = buffer[1];
  
  //Buffer an empty set of data then buffer each component
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, primitive->indexBuffer);
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeIndices, GL_DYNAMIC_DRAW);

  glBindBuffer(GL_ARRAY_BUFFER, primitive->vertexBuffer);
  glBufferData(GL_ARRAY_BUFFER, sizePositions+sizeCoordinates, 0, GL_DYNAMIC_DRAW);

  // Setup the attrib pointers
  glVertexAttribPointer(0, PRIMITIVE_POSITIONS_PER_VERTICE, GL_FLOAT, GL_FALSE, 0, (void *)0);
  glVertexAttribPointer(1, PRIMITIVE_COORDINATES_PER_VERTICE, GL_FLOAT, GL_FALSE, 0, (void *)0);
  glEnableVertexAttribArray(0);
  glEnableVertexAttribArray(1);

  return primitive;
}

void primitiveBufferVertices(primitive_t *primitive,
  int32_t position, int32_t count, vertice_t *vertices
) {
  // Memory
  size_t lengthPositions, lengthCoordinates, offsetPositions, offsetCoordinates;
  float *positions, *coordinates;
  int32_t i;

  // Setup the size of the memory that the positions and coordinates will use
  lengthPositions = sizeof(float) * PRIMITIVE_POSITIONS_PER_VERTICE * count;
  offsetPositions = sizeof(float) * PRIMITIVE_POSITIONS_PER_VERTICE * position;

  lengthCoordinates  = sizeof(float) * PRIMITIVE_POSITIONS_PER_VERTICE * count;
  offsetCoordinates = (
    (sizeof(float) * PRIMITIVE_POSITIONS_PER_VERTICE * primitive->verticeCount)+
    (sizeof(float) * PRIMITIVE_COORDINATES_PER_VERTICE * position)
  );

  // Create some memory
  positions = malloc(lengthPositions);
  coordinates = malloc(lengthCoordinates);

  // Now copy the positions and coordinates from the vertices into the buffer
  for(i = 0; i < count; i++) {
    positions[i * PRIMITIVE_POSITIONS_PER_VERTICE] = vertices[i]->x;
    positions[i * PRIMITIVE_POSITIONS_PER_VERTICE + 1] = vertices[i]->y;
    positions[i * PRIMITIVE_POSITIONS_PER_VERTICE + 2] = vertices[i]->z;

    coordinates[i * PRIMITIVE_COORDINATES_PER_VERTICE] = vertices[i]->u;
    coordinates[i * PRIMITIVE_COORDINATES_PER_VERTICE + 1] = vertices[i]->v;
  }

  // Buffer the data into the GPU
  glBufferSubData(GL_ARRAY_BUFFER, offsetPositions, lengthPositions, positions);
  glBufferSubData(GL_ARRAY_BUFFER, offsetCoordinates, lengthCoordinates, positions);

  // Free the vertices.
  free(positions);
  free(coordinates);
}

void primitiveBufferIndices(primitive_t *primitive, 
  int32_t position, int32_t count, int32_t *indices
) {

}