#include "Lines.h"
#include <cmath>
#include "vgl.h"
#include <vector>

#include <iostream>
using namespace std;

Lines::Lines() {
  int i;

  display = true;
  timeStep = 0;

  return;
}

Lines::~Lines() {
   glDeleteBuffers(2, bufferIDs);
   glDeleteVertexArrays(1, &VAONumber);
   return;
}

void Lines::CreatePoints(int num)  {
    int i;
    Vertex v;
    float theta;
    float dTheta;

    if (num < 3 or num > 300000) {
        num = 300;
    }

    dTheta = 2*M_PI / (num);

    // initial point is the origin.
    v.position[0] = 0;
    v.position[1] = 0;
    v.color[0] = 0;
    v.color[0] = 0;
    v.color[0] = 0;
    points.push_back(v);

    theta = 0;
    for(i=0;i<num;i++) {
       v.position[0] = 0.9 * cos(theta);
       v.position[1] = 0.9 * sin(theta);
       theta += dTheta ;

       v.color[0] = rand()/float(RAND_MAX);
       v.color[1] = rand()/float(RAND_MAX);
       v.color[2] = rand()/float(RAND_MAX);

       // add the point to the list
       points.push_back(v);

       // add the index for the line to the list.
       index.push_back(0);
       index.push_back(ushort(points.size()-1));
    }
}

void Lines::BindLines(GLuint prog, int num) {

  GLint   attribLoc;

  CreatePoints(num);
   
  glGenVertexArrays(1, &VAONumber);

  glBindVertexArray(VAONumber);
  // new code in this area
  glGenBuffers(2,bufferIDs);

  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferIDs[0]);
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, index.size()*sizeof(int),
        index.data(), GL_STATIC_DRAW);

  glBindBuffer(GL_ARRAY_BUFFER, bufferIDs[1]);
  glBufferData(GL_ARRAY_BUFFER, points.size()*sizeof(Vertex),
        points.data(), GL_STATIC_DRAW);

  // end new code 
  //
  attribLoc = glGetAttribLocation(prog, "vPosition");
  glVertexAttribPointer(attribLoc, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
                    BUFFER_OFFSET(offsetof(Vertex,position)));
  glEnableVertexAttribArray(attribLoc);

  attribLoc = glGetAttribLocation(prog, "vColor");
  glVertexAttribPointer(attribLoc, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex)
                   , BUFFER_OFFSET(offsetof(Vertex, color)));
  glEnableVertexAttribArray(attribLoc); 

  // unbind the array
  glBindVertexArray(0);

  tsLoc = glGetUniformLocation(prog, "time");

  return;
}

void Lines::ToggleDisplay() {
   display = !display;
   return;
}

const float TICK_SIZE = 0.01;
const float TIME_MAX = 3;
const float TIME_MIN = 0;

void Lines::TimeStep() {
    static int dir = 1;

    timeStep += dir*TICK_SIZE;
    if(timeStep > TIME_MAX) {
        dir = -1;
	timeStep = TIME_MAX;
    } else if (timeStep < TIME_MIN) {
        timeStep = TIME_MIN;
	dir - 1;
    }
    return;
}

void Lines::Display() {

  if (display) {
      glEnable(GL_LINE_SMOOTH);
      glUniform1f(tsLoc, timeStep);

      glBindVertexArray(VAONumber);
      glDrawElements(GL_LINES, index.size(), GL_UNSIGNED_SHORT, NULL);

      glBindVertexArray(0);
      glDisable(GL_LINE_SMOOTH);
  }

  return;
}