#include <GL/glew.h>
#include <GL/freeglut.h>
#include <iostream>

#include <vector>
#include <cmath>

using namespace std;

struct PointT {
    GLfloat data[3];
};

// these are the points to make up the circle
vector<PointT> points;

// The number of points in the circle
int Circle_Points;
GLenum Shape_Mode;
float Center_X, Center_Y;
float X_Min, X_Max, Y_Min, Y_Max;

void  RedoViewport(void);

// Drawing routine.
void drawScene(void) {
   int i;

   glClear(GL_COLOR_BUFFER_BIT);

   glColor3f(0,0,0);
   glBegin(GL_POLYGON);
      glVertex2f(0,0);
      glVertex2f(0,100);
      glVertex2f(100,100);
      glVertex2f(100,0);
   glEnd();
   // this is just a box for reference.

   glColor3f(1.0,0.0,0.0);


   glBegin(Shape_Mode);
      for(i=0;i<points.size();i++) {
          glVertex3fv(points[i].data);
      }
   glEnd();

   glFlush(); 

   return;
}

void MakePoints() {
     float theta;
     float r = 30;
     float dTheta  = M_PI/Circle_Points;
     float x,y;

     PointT point;

     points.clear();

     point.data[2] = 0.0;


     for(theta=0; theta<2*M_PI; theta+= dTheta) {
          x = r*cos(theta) + Center_X;
          y = r*sin(theta) + Center_Y;

	  point.data[0] = x;
	  point.data[1] = y;

	  points.push_back(point);
     }

     cout << endl;
     cout << "New Circle " << endl;
     cout << "Radius = " << r << endl;
     cout << "Center is (" << Center_X << ", " << Center_Y << ")" << endl;
     cout << "There are " << points.size() << " points " << endl;
     cout << endl;

     return;
}

void reset(void) {

     glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
     Circle_Points =  10;
     Center_X = 50;
     Center_Y = 50;
     Shape_Mode = GL_POLYGON;
     X_Min = 0;
     X_Max = 100;
     Y_Min = 0;
     Y_Max = 100;
     MakePoints();
     RedoViewport();
     return;
}

// Initialization routine.
void setup(void) {
   reset();

   glPointSize(2);
   glClearColor(1.0, 1.0, 1.0, 0.0); 

   return;
}


void RedoViewport(void) {
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   glOrtho(X_Min, X_Max, Y_Min, Y_Max, -1.0, 1.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();

   cout << "The View Window is now (" << X_Min << ", " << Y_Min << ") X (";
   cout << X_Max << ", " << Y_Max << ")" << endl;;
   return;
}

// OpenGL window reshape routine.
void resize(int w, int h) {
   int min = w;
   if (min > h) {
       min = h;
   }
   glViewport(0, 0, min, min);
   RedoViewport();

   return;
}

void NextShape() {

   cout << "The shape is now ";
   switch(Shape_Mode) {

        case GL_POLYGON :
	    Shape_Mode = GL_POINTS;
	    cout << "Line Points";
	    break;
	case GL_POINTS :
	    Shape_Mode = GL_LINES;
	    cout << "Line Lines";
	    break;
	case GL_LINES:
	    Shape_Mode = GL_LINE_STRIP;
	    cout << "Line Strip";
	    break;
	case GL_LINE_STRIP:
	    Shape_Mode = GL_LINE_LOOP;
	    cout << "Line Loop";
	    break;
	case GL_LINE_LOOP:
	    Shape_Mode = GL_TRIANGLES;
	    cout << "Triangles";
	    break;
	case GL_TRIANGLES:
	    Shape_Mode = GL_TRIANGLE_STRIP;
	    cout << "Triangle Strip";
	    break;
	case GL_TRIANGLE_STRIP:
	    Shape_Mode = GL_TRIANGLE_FAN;
	    cout << "Triangle Fan";
	    break;
	case GL_TRIANGLE_FAN:
	    Shape_Mode = GL_QUADS;
	    cout << "Quads ";
	    break;
	case GL_QUADS:
	    Shape_Mode = GL_QUAD_STRIP;
	    cout << "Quad Strip";
	    break;
	case GL_QUAD_STRIP:
	default:
	    Shape_Mode = GL_POLYGON;
	    cout << "Polygon";
   }

   cout << endl;
   return;
}


// Keyboard input processing routine.
void keyInput(unsigned char key, int x, int y)
{
   bool redisplay = true;
   int i;
   static bool fill=false;


   switch(key) 
   {

      case 'l':
          X_Min -= 10.0;
          Y_Min -= 10.0;
	  RedoViewport();
          break;
      case 'L':
          X_Min += 10.0;
          Y_Min += 10.0;
	  RedoViewport();
          break;
      case 'u':
          X_Max -= 10.0;
          Y_Max -= 10.0;
	  RedoViewport();
          break;
      case 'U':
          X_Max += 10.0;
          Y_Max += 10.0;
	  RedoViewport();
          break;
      case 'x': 
         Center_X -= 10;
	 MakePoints();
	 break;
      case 'X': 
         Center_X += 10;
	 MakePoints();
	 break;
      case 'y': 
         Center_Y -= 10;
	 MakePoints();
	 break;
      case 'Y': 
         Center_Y += 10;
	 MakePoints();
	 break;
      case 'r':
         reset();
	 break;
      case 's':
         NextShape();
	 break;
      case 'P':
         Circle_Points ++;
	 MakePoints();
	 break;

      case 'm':
         fill = !fill ;
	 if (fill) {
             glPolygonMode(GL_FRONT_AND_BACK, GL_LINE );
	 } else {
             glPolygonMode(GL_FRONT_AND_BACK, GL_FILL );
	 }
      case 'p':
         if (Circle_Points > 4) {
	    Circle_Points --;
	    MakePoints();
	 }
	 break;

      case 'q':
      case 'Q':
      case 27:
         redisplay = false;
         exit(0);
         break;
      default:
         redisplay = false;
         cout << "Keypress " << key << " does not have an assigned action " 
	      << endl;
         break;
   }

   if (redisplay) {
      glutPostRedisplay();
   }
}

// Main routine.
int main(int argc, char **argv) {
   glutInit(&argc, argv);

   glutInitContextVersion(3,0);
   glutInitContextProfile(GLUT_CORE_PROFILE);
   //glutInitContextProfile(GLUT_COMPATIBILITY_PROFILE);

   glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); 
   glutInitWindowSize(500, 500);
   glutCreateWindow("My Circle");
   glutDisplayFunc(drawScene); 
   glutReshapeFunc(resize);  
   glutKeyboardFunc(keyInput);

   glewExperimental = GL_TRUE;
   glewInit();

   setup(); 
   
   glutMainLoop(); 
}