/* view.c 

Laura Toma

What it does:  

 - Contains several functions to generate some test polygons to be
   triangulated.

 - Contains a function to draw a polygon.

 A polygon is stored using an array of vertices, in ccw order, in a
 global variable.  The polygon is not necessarily convex.

 Intended use: Your code will use the test polygons and call the
 function that produces the triangulation with the test polygon as
 argument.  The triangulation can be stored either as a set of
 triangles, or as a set of diagonals. You will probably not use the
 code that displays the test polygon, you will need to render the
 resulting triangulation instead.

*/

#include "geom.h"
#include "rtimer.h"

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <assert.h>

#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif


GLfloat red[3] = {1.0, 0.0, 0.0};
GLfloat green[3] = {0.0, 1.0, 0.0};
GLfloat blue[3] = {0.0, 0.0, 1.0};
GLfloat black[3] = {0.0, 0.0, 0.0};
GLfloat white[3] = {1.0, 1.0, 1.0};
GLfloat gray[3] = {0.5, 0.5, 0.5};
GLfloat yellow[3] = {1.0, 1.0, 0.0};
GLfloat magenta[3] = {1.0, 0.0, 1.0};
GLfloat cyan[3] = {0.0, 1.0, 1.0};

GLint fillmode = 0;



/* forward declarations of functions */
void display(void);
void keypress(unsigned char key, int x, int y);
void main_menu(int value);



/* global variables */
const int WINDOWSIZE = 500; 

//the array of n points storing the test polygon. The variable n
//stores its size. Good practice to initialize it to NULL, espe when
//using asserts on pointers
point2D*  polygon = NULL;
int n;  



//a convex n-gon of given size. The rendering function draw_polygon
//assumes that the points are in teh range [0,WINSIZE] x [0, WINSIZE].
void generate_polygon_ngon() {
  
  printf("generating n-gon of size %d\n", n);
  int i;
  int rad = .7* WINDOWSIZE/2; //note rad can be at most WINDOWSIZE/2
  double theta = 2 * M_PI / n; 
  int center_x = WINDOWSIZE/2; 
  int center_y = WINDOWSIZE/2; 
  for (i=0; i<n; i++) {
    polygon[i].x = center_x + rad * cos(i*theta); 
    polygon[i].y = center_y + rad * sin(i*theta);
  }
}



//a star-like polygon of given size. The rendering function
//draw_polygon
//assumes that the points are in teh range [0,WINSIZE] x [0, WINSIZE].
void generate_polygon_star() {
  
  printf("generating n-gon of size %d\n", n);
  int i;
  //note rad can be at most WINDOWSIZE/2
  int rad1 = .7* WINDOWSIZE/2; //the outer radius
  int rad2 = rad1/2;  //the inner radius
  printf("rad1=%d, rad2=%d\n", rad1, rad2);

  double theta = 2 * M_PI / n; 
  int center_x = WINDOWSIZE/2; 
  int center_y = WINDOWSIZE/2; 
  for (i=0; i<n; i++) {
    int rad = (i%2 ==0)?rad1:rad2; 
    polygon[i].x = center_x + rad * cos(i*theta); 
    polygon[i].y = center_y + rad * sin(i*theta);
  }
}




//a star-like polygon of given size. The rendering function
//draw_polygon
//assumes that the points are in the range [0,WINSIZE] x [0, WINSIZE].
void generate_polygon_star2() {
  
  printf("generating n-gon of size %d\n", n);
  int i;
  //note rad can be at most WINDOWSIZE/2
  int rad1 = .7* WINDOWSIZE/2; //the outer radius
  int rad2 = rad1/2;  //the inner radius

  double theta = 2 * M_PI / n; 
  int center_x = WINDOWSIZE/2; 
  int center_y = WINDOWSIZE/2; 
  for (i=0; i<n; i++) {
    int rad; 
    if ((i%3==0)|| (i%3==1)) rad = rad1; 
    else rad = rad2; 
    polygon[i].x = center_x + rad * cos(i*theta); 
    polygon[i].y = center_y + rad * sin(i*theta);
  }
}





/* ****************************** */
/* print an array of points passed as argument of size n*/
void print_points(point2D* points, int n) {
  assert(points); 
  int i; 
  printf("points: ");
  for (i=0; i<n; i++) {
    printf("[%3d,%3d] ", points[i].x, points[i].y);
  }
  printf("\n");
  fflush(stdout);  //flush stdout, weird sync happens when using gl thread
}




/* ****************************** */
int main(int argc, char** argv) {

  //read number of points from user
  if (argc!=2) {
    printf("usage: viewPoints <nbPoints>\n");
    exit(1); 
  }
  n = atoi(argv[1]); 
  printf("you entered n=%d\n", n);
  assert(n >0); 

  //allocate global polygon array of n points 
  polygon = (point2D*)malloc(n*sizeof(point2D));
  assert(polygon); 

  generate_polygon_ngon();
  //generate_polygon_star();
  //generate_polygon_star2();
  print_points(polygon, n);

  Rtimer rt1; 
  rt_start(rt1); 
  
  //call the function that generates the triangulation
  
  rt_stop(rt1); 
  
  //print the timing 
  char buf [1024]; 
  rt_sprint(buf,rt1);
  printf("Triangulating polygon:  %s\n\n", buf);
  fflush(stdout); 

 
  
  /* initialize GLUT  */
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
  glutInitWindowSize(WINDOWSIZE, WINDOWSIZE);
  glutInitWindowPosition(100,100);
  glutCreateWindow(argv[0]);

  /* register callback functions */
  glutDisplayFunc(display); 
  glutKeyboardFunc(keypress);

  /* init GL */
  /* set background color black*/
  glClearColor(0, 0, 0, 0);   
  /* here we can enable depth testing and double buffering and so
     on */

  
  /* give control to event handler */
  glutMainLoop();
  return 0;
}


/* ****************************** */
/* draw the polygon stored in global variable polygon. The points are
   assumed to be in ccw around the boundary. Draw line segments from
   p[i] to p[i+1]
*/
void draw_polygon(){

  // glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

  //set color 
  glColor3fv(yellow);   
  
  //let's hope someone initialized this 
  assert(polygon);
  int i;
  glBegin(GL_POLYGON);
  for (i=0; i<n; i++) {
    glVertex2f(polygon[i].x,polygon[i].y);
  }
  glEnd();
 
}






/* ****************************** */
void display(void) {

  glClear(GL_COLOR_BUFFER_BIT);
  glMatrixMode(GL_MODELVIEW); 
  glLoadIdentity(); //clear the matrix


  /* the default GL window is [-1,1]x[-1,1] with the origin in the
     center. 

     The points are in the range (0,0) to (WINSIZE,WINSIZE), so they
     need to be mapped to [-1,1]x [-1,1] */
  glScalef(2.0/WINDOWSIZE, 2.0/WINDOWSIZE, 1.0);  
  glTranslatef(-WINDOWSIZE/2, -WINDOWSIZE/2, 0); 
  draw_polygon();

  /* execute the drawing commands */
  glFlush();
}



/* ****************************** */
void keypress(unsigned char key, int x, int y) {
  switch(key) {
  case 'q':
    exit(0);
    break;
  } 
}


/* Handler for window re-size event. Called back when the window first appears and
   whenever the window is re-sized with its new width and height */
void reshape(GLsizei width, GLsizei height) {  // GLsizei for non-negative integer
     
   // Set the viewport to cover the new window
   glViewport(0, 0, width, height);
 
   glMatrixMode(GL_PROJECTION);  // To operate on the Projection matrix
   glLoadIdentity();             // Reset
   gluOrtho2D(0.0, (GLdouble) width, 0.0, (GLdouble) height); 
}