#include "GlutWindow2d.h"
#include <iostream>
using namespace std;
//********************************************************
/*! Basic constructor */
GlutWindow2d::GlutWindow2d(const char *title, int width, int height) : GlutWindow(title, width, height)
{
   //initialize the zoom factor to nothing
   zoomFactor = 1.0;

   //initialize the panning offsets
   panXOffset = 0;
   panYOffset = 0;
   
   drawZoomCircleFlag = false;
   zoomDrawRadius = 0;
}


//********************************************************
/*! Basic destructor */
GlutWindow2d::~GlutWindow2d()
{

}

//********************************************************
/*!
  This performs generic graphics matrix setup operations, and
  will be called if the user resizes the window
  @param w Width of the window
  @param h Height of the window
*/
void GlutWindow2d::reshape(int w, int h)
{
   //need to set the viewable area on the screen to the dimensions of the window 
   glViewport(0,0,w,h);

   //I am setting a state where I am editing the projection matrix...
   glMatrixMode(GL_PROJECTION);
   
   //Clearing the projection matrix...
   glLoadIdentity();
   
   //Creating an orthoscopic view matrix going from -1 -> 1 in each
   //dimension on the screen (x, y, z). 
   //void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);

   glOrtho(-w/2*zoomFactor + panXOffset, w/2*zoomFactor + panXOffset, -h/2*zoomFactor + panYOffset, h/2*zoomFactor + panYOffset, -1, 1);
   //glOrtho(-1, 1, -1, 1, -1, 1);

    
   //Now editing the model-view matrix.
   glMatrixMode(GL_MODELVIEW);

   //Clearing the model-view matrix.
   glLoadIdentity();
   
   windowWidth = w;
   windowHeight = h;
}

//********************************************************
/*!
  This will setup the camera and then call draw().  
*/
void GlutWindow2d::display()
{
   //Now editing the model-view matrix.
   //glMatrixMode(GL_MODELVIEW);
   
   //clear the screen to the clear color (default black)
   glClear(GL_COLOR_BUFFER_BIT);	
   
   //glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   
   //set the default object color to white
   glColor3f(1,1,1);
   
   glPushMatrix();
   
   //position the camera at the correct location
   positionCamera();

   //call the overridden function to draw the current scene
   draw();

   glPopMatrix();

   //force execution of the previous GL commands in finite time
   glFlush();

   glutSwapBuffers();
}

//********************************************************
/*!
  This function is called when an ascii key is pressed.
  @param key The key that was pressed
  @param x The x location of the cursor when the key was pressed
  @param y The y location of the cursor when the key was pressed
*/
void GlutWindow2d::processNormalKeys(unsigned char key,int x, int y)
{ 
   switch(key)
   {
   case 27: //esc
      exit(0);
      
      break;

   case 'r': //resets all of the zoom and pan parameters
      zoomFactor = 1.0;
      panXOffset = 0;
      panYOffset = 0;

      setProjectiveSettings();
      break;
      
   default:
      
      break;
   }

   GlutWindow::processNormalKeys(key, x, y);
}

//********************************************************
/*!
  This function is used to perform actions when one of the non-ascii keys
  are presed.  In the base class, the arrow keys are used to move the 
  center of the field of view around in the plane, while PAGE_UP & 
  PAGE_DOWN are used to change the Z value of the center of view.

  If you would like to perform other options with the special keys, then 
  when overriding this function, you may want to consider calling 
  GlutWindow2d::processSpecialKeys(key, x, y) in the overridden function
  to maintain the same base functionality.

  @param key The key that was pressed
  @param x The x location of the cursor when the key was pressed
  @param y The y location of the cursor when the key was pressed     
*/
void GlutWindow2d::processSpecialKeys(int key,int x, int y)
{
   switch(key)
   {
   case GL_UP_KEY:
      
      break;

   case GL_DOWN_KEY:
     
      break;

   case GL_LEFT_KEY:
      
      break;

   case GL_RIGHT_KEY:
      
      break;

   case GL_PUP_KEY:
      
      break;

   case GL_PDN_KEY:
      
      break;

   default:
      break;
   }
   
   //Redraw the scene occurs in the base process special keys
   GlutWindow::processSpecialKeys(key, x, y);
}

//********************************************************
/*!
  This is used in conjunction with mouseMotion to provide the camera 
  movement.  Moving the mouse with the left button down rotates the camera 
  around a fixed point (specified by viewX, viewY, viewZ).  Moving the 
  mouse with the right button down zooms the camera in and out
  
  If you would like to perform other operations with the mouse, override
  this function, you may want to consider calling Glut_Window::mouse() 
  in that routine to maintain the mouse interface.
  @param button The button that was pressed
  @param x The x location of the cursor when the button was pressed
  @param y The y location of the cursor when the button was pressed     
*/
void GlutWindow2d::mouse(int button, int state, int x, int y)
{
   if(state == GLUT_UP) 
   {
      buttonDown = -1;
      //enable the flag to not draw the zoom circle
      drawZoomCircleFlag = false;
   }
   else
   {
      //store the button
      buttonDown = button;
      switch(buttonDown)
      {
      case 0:
         //adjust the mouse positions to be from the center of the screen
         mouseStartX = x - windowWidth/2;
         mouseStartY = (windowHeight - y) - windowHeight/2;
         mouseStartZoom = zoomFactor;
         
         //store the current radius for drawing purposes
         zoomDrawRadius = sqrt(x*x + y*y);
         //enable the flag to draw the zoom circle
         drawZoomCircleFlag = true;
         break;
         
      case 2:
         mousePanXOffset = panXOffset;
         mousePanYOffset = panYOffset;

         mouseStartX = x;
         mouseStartY = y;
         
         break;
      }
   }  

   GlutWindow::mouse(button, state, x, y);
}

//********************************************************
/*!
  This routine is called whenever a mouse movement event has occured.
  If you are overriding it, consider calling Glut_Window::mouse_motion()
  in your descendant classes, to maintain the mouse interface
  @param x The x location of the mouse
  @param y The y location of the mouse
*/
void GlutWindow2d::mouseMotion(int x, int y)
{
   switch (buttonDown) 
   {
   case -1:

      return;

   case 2:
      panXOffset = mousePanXOffset + (mouseStartX - x)*zoomFactor;
      //the y pan offset update equation is negative since y goes from 0 to windowHeight from top to bottom
      panYOffset = mousePanYOffset - (mouseStartY - y)*zoomFactor;
   
      setProjectiveSettings();
      
      break;

   case 0:
      //adjust the mouse positions to be from the center of the screen
      x -= windowWidth/2;
      y = (windowHeight - y) - windowHeight/2;

      double origDist = sqrt(mouseStartX*mouseStartX + mouseStartY*mouseStartY);
      double currDist = sqrt(x*x + y*y);

      //store the current radius for drawing purposes
      zoomDrawRadius = currDist;
      
      //adjust the zoom factor based upon the ratio of the radii
      zoomFactor = mouseStartZoom*(origDist/currDist);
      
      
      setProjectiveSettings();
      
      break;


   
   }

   //redraw occurs in the base
   GlutWindow::mouseMotion(x, y);
}

//********************************************************
/*!
  Overide this function to change the location from which the scene is 
  rendered.  It currently uses information from the mouse and the special 
  keyboard keys to set its direction
*/
void GlutWindow2d::positionCamera()
{

}

//********************************************************

void GlutWindow2d::init()
{
   char *dummy_argv[1];
   int dummy_argc = 1;
   dummy_argv[0] = new char[64];
   strcpy(dummy_argv[0], "dummy");
   
   //Initialize glut
   glutInit(&dummy_argc, dummy_argv);
   
   //set the display mode to double-buffered, R
   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
   
   //set the window size
   glutInitWindowSize(windowWidth, windowHeight);

   //set the window position
   glutInitWindowPosition(10,10);
   
   // Create the window and save the window ID 
   windowID = glutCreateWindow(myTitle);
   
   //Disabling the depth test (z will not be used in 2D)
   glDisable(GL_DEPTH_TEST);    
   
   //Sets the clear color for when OpenGL clears the entire screen
   glClearColor(0, 0, 0, 1.0f);   

   delete [] dummy_argv[0];
}

//********************************************************

/*! Draws the zoom circle when changing the zoom factor */
void GlutWindow2d::drawZoomCircle()
{
   glColor3f(0.5,0.5,0.5);
   glBegin(GL_LINE_LOOP);
   for(unsigned int theta = 0; theta < 360; theta += 1)
      glVertex2f(cos(theta*M_PI/180)*zoomDrawRadius*zoomFactor + panXOffset, sin(theta*M_PI/180)*zoomDrawRadius*zoomFactor + panYOffset);
   
   glEnd();
}

//********************************************************

/*! Set the projection parameters */
void GlutWindow2d::setProjectiveSettings()
{
   //update the zoom
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity(); 
   glOrtho(-windowWidth/2*zoomFactor + panXOffset, windowWidth/2*zoomFactor + panXOffset, -windowHeight/2*zoomFactor + panYOffset, windowHeight/2*zoomFactor + panYOffset, -1, 1);
   //put it back in GL_MODELVIEW
   glMatrixMode(GL_MODELVIEW);
}

//********************************************************
/*!
  This will draw the given string to the screen at the location given by
  x,y- (relative to the current window properties).
  the color defaults to a gray
*/
void GlutWindow2d::drawText2d(const char *txt, float x, float y, float r, float g, float b, void *font)
{
   if(font == NULL)
      font = GLUT_BITMAP_HELVETICA_10;

   GLboolean lightingOn; 
   GLenum error;
   
   lightingOn = glIsEnabled(GL_LIGHTING);        /* lighting on? */
   
   if(lightingOn) 
      glDisable(GL_LIGHTING);
   
   glPushAttrib(GL_TRANSFORM_BIT); // Save the current matrix mode
   
   glPushAttrib(GL_COLOR_BUFFER_BIT);       /* save current colour */
   
   glColor3f(r, g, b);
   
   glRasterPos3f(x, y, 0);
   
   for(unsigned int i = 0; i < strlen(txt); i++)
      glutBitmapCharacter(font, txt[i]);

   glPopAttrib();
   
   glPopAttrib(); // Restore the original matrix mode

   if(lightingOn)
      glEnable(GL_LIGHTING);
   
   error = glGetError();
   
   if (error != GL_NO_ERROR)
      std::cout << gluErrorString(error) << std::endl;
}