/*******************************************************************
	       Callbacks for GLUT and sundry utilities
********************************************************************
    Author: Stan Sclaroff, Ashwin Thangali  and John Isidoro
  Comments: Provided for CS480/CS680 programming assignment #1.
********************************************************************/

#include <GL/glut.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

#include "types.h"
#include "funcs.h"

/* global variables -- static for storing state */

static int renderFlags=0;
static int test_case;
static int Nsteps = 18;

static Vertex tri[3];
static Vertex line[2];
static int triangle_vertex_count=0;
static int line_vertex_count=0;
static Color current_color;

/* Macro for copying color */

#define COPYCOLOR(A,B) {(A).r = (B).r;(A).g=(B).g;(A).b=(B).b;}

/* initialize the system */
void init(int width, int height)
{
  initPixelBuffer(width,height);
  clearPixelBuffer();
  current_color.r = current_color.g = current_color.b = 255;  /* white */
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
}

/* display contents of the Pixel buffer */
void display(void)
{
  glRasterPos2i(0, 0);
  glDrawPixels(getPixelBufferWidth(), getPixelBufferHeight(), 
	       GL_RGB, GL_UNSIGNED_BYTE, getPixelBufferAddress());
  glFlush();
}

/* called at initialization and whenever user resizes the window */
void reshape(int w, int h)
{
  int pbWidth = getPixelBufferWidth(), pbHeight = getPixelBufferWidth();

  /* do not allow size of window other than Pixel buffer size */
  if(w != pbWidth || h != pbHeight)
    glutReshapeWindow(pbWidth,pbHeight);

  glViewport(0, 0, (GLsizei) pbWidth, (GLsizei) pbHeight);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluOrtho2D(0.0, (GLdouble) pbWidth, 0.0, 
	     (GLdouble) pbHeight);  
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
}

/* handle mouse button clicks */
void mouseButton(int button, int state, int x, int y)
{
  static int ox,oy;	 
  int screeny; 
  Color color;

  screeny = getPixelBufferHeight() - y;  
  if (state == GLUT_UP)  /* take position on "button up" */
    {
      switch(button){
      case GLUT_LEFT_BUTTON: /* add a triangle vertex */

	/* initial vertex */
	if(triangle_vertex_count==0)
	  {
	    tri[0].x = x;
	    tri[0].y = screeny;
	    COPYCOLOR(tri[0].color,current_color);

	    triangle_vertex_count = 1;
	    setPixel(x,screeny,current_color);
	    glutPostRedisplay();
	  }

        /* second vertex */
	else if(triangle_vertex_count==1)
	  {
	    tri[1].x = x;
	    tri[1].y = screeny;
	    COPYCOLOR(tri[1].color,current_color);
	    
	    setPixel(x,screeny,current_color);
	    triangle_vertex_count = 2;
	    glutPostRedisplay();
	  }

	/* last vertex closes triangle */
        else
	  {
	    tri[2].x = x;
	    tri[2].y = screeny;
	    COPYCOLOR(tri[2].color,current_color);

	    drawTriangle(tri,renderFlags);
	    triangle_vertex_count = 0;
	    glutPostRedisplay();
	  }
	break;

      case GLUT_MIDDLE_BUTTON:  /* unused in this assignment */
	break;

      case GLUT_RIGHT_BUTTON: 	/* line end points */
	if(line_vertex_count==1)
	  {
	    line[1].x = x;
	    line[1].y = screeny;
	    COPYCOLOR(line[1].color,current_color);
    
	    drawLine(line[0],line[1]);
	    line_vertex_count=0;
	    glutPostRedisplay();
	  }
	else if(line_vertex_count==0)
	  {
	    line[0].x = x;
	    line[0].y = screeny;
	    COPYCOLOR(line[0].color,current_color);

	    setPixel(x,screeny,current_color);
	    line_vertex_count=1;
	    glutPostRedisplay();
	  }
	  
      default:
	break;

      }
    }
}

void drawTestCase()
{  
  /* clear the window and vertex state */
  clearPixelBuffer();
  triangle_vertex_count = 0;
  line_vertex_count = 0;

  switch (test_case){
  case 0:
    lineTestPattern1(); 
    break;
  case 1:
    lineTestPattern2(); 
    break;
  case 2:
    lineTestPattern3(); 
    break;
  case 3:
    triTestPattern1(0); /*single color polygon*/
    break;
  case 4:
    triTestPattern1(SMOOTH_SHADING_BIT); /*smooth shaded polygon*/
    break;
  case 5:
    triTestPattern2(0); /*single color polygon*/
    break;
  case 6:
    triTestPattern2(SMOOTH_SHADING_BIT); /*smooth shaded polygon*/
    break;
  }		
  glutPostRedisplay();
}

/* handles input from the keyboard */
void keyboard(unsigned char key, int x, int y)
{
  Color color;
 
  switch(key){

  case 'c':
  case 'C': 
    /* c or C key = clear state, clear buffer */
    clearPixelBuffer();
    triangle_vertex_count = 0;
    line_vertex_count = 0;
    glutPostRedisplay();
    break;

  case 'q':
  case 'Q':
  case 27:  
    /* Esc, q, or Q key = Quit */
    exit(0);
    break;

  case 'l':
  case 'L':
    /* l or L key = line test pattern */
    if( test_case > 2 ) 
      test_case = 0;
    else
      test_case = (test_case + 1 )%3;
    drawTestCase();
    break;

  case 't':
  case 'T': 
    /* t or T key = triangle test pattern */
    if( test_case < 3 ) 
      test_case = 3;
    else
      test_case = (test_case + 1 - 3)%4 + 3;
    drawTestCase();
    break;

  case 's':
  case 'S': 
    renderFlags^=SMOOTH_SHADING_BIT;
    printf("Renderflags = %d",renderFlags);
    break;

  case 'x':
  case 'X': 
    renderFlags^=TEXTURE_MAPPING_BIT; 
    break;

  case 'r':
  case 'R':
    current_color.r+=16;
    current_color.r&=255;
    printf("Color is now %d,%d,%d\n",
	   current_color.r,current_color.g,current_color.b);
    break;
  case 'g':
  case 'G':
    current_color.g+=16;
    current_color.g&=255;
    printf("Color is now %d,%d,%d\n",
	   current_color.r,current_color.g,current_color.b);
    break;
  case 'b':
  case 'B':
    current_color.b+=16;
    current_color.b&=255;
    printf("Color is now %d,%d,%d\n",
	   current_color.r,current_color.g,current_color.b);
    break;

  case '<':  
    Nsteps = Nsteps / 2;
    if( Nsteps < 3 ) Nsteps = 3;
    printf( "Nsteps = %d \n", Nsteps);
    drawTestCase();
    break;
  case '>':
    Nsteps = Nsteps * 2;
    if( Nsteps > 1000 ) Nsteps = 1000;
    printf( "Nsteps = %d \n", Nsteps);
    drawTestCase();
    break;

  default:
    break;

  }
}


#define PI 3.1415927
#ifndef M_PI
#define M_PI 3.1415927
#endif

/* draw a test line pattern to see if all quadrants and +/- slopes work */
void lineTestPattern1(void)
{
  float theta,delta;
  float radius;
  int cx,cy,x,y;
  int i,n_steps = ( Nsteps == 18 )?9:Nsteps;
  Vertex v0,v1,v2;

  delta = -PI/n_steps;
  radius = getPixelBufferWidth()*0.45;

  /* center of pattern */
  v0.x = cx = getPixelBufferWidth()/2.0;
  v0.y = cy = getPixelBufferHeight()/2.0;
  v0.color.r = v0.color.g = 255;
  v0.color.b = 0;

  for(i=0,theta=0;i<n_steps;++i,theta += delta)
    {
      x = sin(theta)*radius;
      y = cos(theta)*radius;

      v1.x = cx+x;
      v1.y = cy+y;

      v2.x = cx-x;
      v2.y = cy-y;

      v1.color.r = v2.color.r = 0; 
      v1.color.g = v2.color.b = (GLubyte)((n_steps-i)*255.0/n_steps);
      v1.color.b = v2.color.g = 0; 

      drawLine(v0,v1);
      drawLine(v0,v2);
    }
}


/* draw test line pattern 2: a flower with five petals */
void lineTestPattern2(void)
{
  float theta,d_theta,d_petal,petal,radius,p;
  int cx,cy;
  int i;
  int n_steps =( Nsteps == 18 )?64:4*Nsteps;
  Vertex v0,v1;

  d_theta = 2.0*PI / n_steps;
  d_petal = 12.0*PI / n_steps;

  cx = getPixelBufferWidth()/2.0;
  cy = getPixelBufferHeight()/2.0;

  radius = 0.75 * ((cx < cy) ? cx : cy);
  p = radius*0.25;

  /* draw the outer petals first */

  v0.x = cx;
  v0.y = (int)floor(0.5 + radius + p) + cy;
  v0.color.r = 255;
  v0.color.g = (GLubyte)(128+sin(2*PI)*127.0);
  v0.color.b = (GLubyte)(128+cos(2*PI)*127.0);

  for(petal=d_petal,theta=d_theta,i=0;i<=n_steps;++i,theta+=d_theta,petal+=d_petal)
    {
      v1.x = (int)floor(0.5 + radius*sin(theta) + p*sin(petal)) + cx;
      v1.y = (int)floor(0.5 + radius*cos(theta) + p*cos(petal)) + cy;

      v1.color.r = 255;
      v1.color.g = (GLubyte)(128+sin(theta*5)*127.0);
      v1.color.b = (GLubyte)(128+cos(theta*5)*127.0);
      drawLine(v0,v1);

      v0.x = v1.x;
      v0.y = v1.y;
      COPYCOLOR(v0.color,v1.color);
    }

  /* draw circle at center */
  radius *= 0.5;
  v0.x = cx;
  v0.y = (int)floor(0.5 + radius) + cy;

  /* color = orange */
  v1.color.r = v0.color.r = 255;
  v1.color.g = v0.color.g = 97;
  v1.color.b = v0.color.b = 0; 

  for(theta=d_theta,i=0;i<=n_steps;++i,theta+=d_theta)
    {
      v1.x = (int)floor(0.5 + radius*sin(theta)) + cx;
      v1.y = (int)floor(0.5 + radius*cos(theta)) + cy;

      drawLine(v0,v1);

      v0.x = v1.x;
      v0.y = v1.y;
    }
}

void lineTestPattern3(void)
{
  float theta,delta;
  int i,cx,cy;
  float radius;
  int n_steps = Nsteps;
  Vertex tri[3];

  delta = 2*PI/n_steps;
  radius = getPixelBufferWidth()*0.45;
  cx = getPixelBufferWidth()/2.0;
  cy = getPixelBufferHeight()/2.0;
  
  for(i=0,theta=0;i<n_steps;++i,theta += delta)
    {
      tri[0].x = cx+sin(theta)*radius;
      tri[0].y = cy+cos(theta)*radius;
      tri[0].color.r = 127+127*sin(theta);
      tri[0].color.g = 127+127*sin(theta+(2*PI/3));
      tri[0].color.b = 127+127*sin(theta+(4*PI/3));
      
      tri[1].x = cx+sin(theta+delta)*radius;
      tri[1].y = cy+cos(theta+delta)*radius;
      tri[1].color.r = 127+127*sin(theta+delta);
      tri[1].color.g = 127+127*sin(theta+delta+(2*PI/3));
      tri[1].color.b = 127+127*sin(theta+delta+(4*PI/3));
      
      tri[2].x = cx;	
      tri[2].y = cy;	
      tri[2].color.r = 255;
      tri[2].color.g = 255;
      tri[2].color.b = 255;
      
      drawLine(tri[0],tri[1]);
      drawLine(tri[1],tri[2]);
      drawLine(tri[0],tri[2]);
    }
}

void triTestPattern1(int flags)
{
  float theta,delta;
  int i,cx,cy;
  float radius;
  int n_steps = Nsteps;
  Vertex tri[3];

  delta = 2*PI/n_steps;
  radius = getPixelBufferWidth()*0.45;
  cx = getPixelBufferWidth()/2.0;
  cy = getPixelBufferHeight()/2.0;
  
  for(i=0,theta=0;i<n_steps;++i,theta += delta)
    {
      tri[0].x = cx+sin(theta)*radius;
      tri[0].y = cy+cos(theta)*radius;
      tri[0].color.r = 127+127*sin(theta);
      tri[0].color.g = 127+127*sin(theta+(2*PI/3));
      tri[0].color.b = 127+127*sin(theta+(4*PI/3));
      
      tri[1].x = cx+sin(theta+delta)*radius;
      tri[1].y = cy+cos(theta+delta)*radius;
      tri[1].color.r = 127+127*sin(theta+delta);
      tri[1].color.g = 127+127*sin(theta+delta+(2*PI/3));
      tri[1].color.b = 127+127*sin(theta+delta+(4*PI/3));
      
      tri[2].x = cx;	
      tri[2].y = cy;	
      tri[2].color.r = 255;
      tri[2].color.g = 255;
      tri[2].color.b = 255;
      
      drawTriangle(tri,flags);      
    }
}

void drawTris(float ** tris, int numTris, int flags){
  int i,j,k,l;
  Vertex tri[3];
  k=0;
  for(i=0;i<numTris;i++){
    for(j=0;j<3;j++){
      l=0;
      tri[j].x = tris[k][l++];
      tri[j].y = tris[k][l++];
      tri[j].color.r = (unsigned char)tris[k][l++];
      tri[j].color.g = (unsigned char)tris[k][l++];
      tri[j].color.b = (unsigned char)tris[k][l++];
      k++;
    }
    drawTriangle(tri,flags);
  }
}

void getCol(float x,float y, float z, float rad, float * col, float * n,
	    float minz, float maxz);

#define getColorSetTris  \
	getCol(x,y,z,rbase,col,NULL,0,rbase); \
	tris[j][0] = cx + x; tris[j][1] = cy+y; \
	tris[j][2] = col[0]; tris[j][3] = col[1]; tris[j][4] = col[2]; \
	j++;

void triTestPattern2(int flags){
  static int prevNsteps = 0;
  static float ** tris = NULL;
  static int numTris=0, numAllocTris=0;
  int i,j,k,l;
  float rbase,cx,cy;
  int n_lat_steps = Nsteps/2;
  int n_long_steps = Nsteps;
  float theta, alpha, theta1, alpha1, theta_step, alpha_step;
  float r,r1,x,y,z,z1,z2, * col;
 
  if( tris == NULL || prevNsteps != Nsteps ){
    prevNsteps = Nsteps;
    for( i =0; i< numAllocTris; i++)
      free(tris[i]);
    free(tris);
    numAllocTris = 6 * n_long_steps * n_lat_steps;
    tris = (float**)malloc( numAllocTris * sizeof(float*));
    for( i =0; i< numAllocTris; i++)
      tris[i] = (float*)malloc( 5 * sizeof(float));
    col = (float*)malloc( 3 * sizeof(float));

    cx = getPixelBufferWidth()/2.0;
    rbase = getPixelBufferWidth()*0.45;
    cy = getPixelBufferHeight()/2.0;

    theta_step = M_PI * 2.0 / n_long_steps;
    alpha_step = M_PI /(2.0 * n_lat_steps);
    alpha = 0;
    j=0;
    numTris = 0;
    for(i=0;i<n_lat_steps-1;i++){  

      alpha1 = alpha+alpha_step;
      r = rbase * cos(alpha); 
      r1 = rbase * cos(alpha1); 
      z1 = rbase * sin(alpha);
      z2 = rbase * sin(alpha1);
      theta = 0;

      for(k=0;k<n_long_steps;k++){ 
	theta1 = theta + theta_step;

	x = r * cos(theta); y = r * sin(theta); z = z1;
	getColorSetTris 
	  x = r * cos(theta1); y = r * sin(theta1); z = z1;
	  getColorSetTris 
	    x = r1 * cos(theta); y = r1 * sin(theta); z = z2;
	    getColorSetTris 
	      numTris++;
			
	    x = r1 * cos(theta); y = r1 * sin(theta); z = z2;
	    getColorSetTris 
	      x = r1 * cos(theta1); y = r1 * sin(theta1); z = z2;
	      getColorSetTris 
		x = r * cos(theta1); y = r * sin(theta1); z = z1;
		getColorSetTris 
		  numTris++;

		theta += theta_step;
      }
      alpha += alpha_step;
    }
    r = rbase * cos(alpha); 
    z1 = rbase * sin(alpha);
    z2 = rbase;
    theta = 0;
    for(i=0;i<n_long_steps;i++){ 
      theta1 = theta + theta_step;
      x = r * cos(theta); y = r * sin(theta); z = z1;
      getColorSetTris 
	x = r * cos(theta1); y = r * sin(theta1); z = z1;
	getColorSetTris 
	  x = 0; y = 0; z = z2;
	  getColorSetTris 
	    numTris++;
	  theta += theta_step;
    }
    free(col);
  }
  drawTris(tris,numTris, flags);
}

void getCol(float x,float y, float z, float rad, float * col , float * normal, 
	    float minz, float maxz){
  static float ** lights = NULL, *dotProd = NULL, lightRadius;
  static int numPrevLights = 0;
  static int i,j,k,l,m,n,o;
  static float theta, temp, temp1, temp2;
  static float lvx, lvy, lvz;
  static float cosLightElevation;
  static float distanceScale, lightDistRange;
  static int lightElevation = 5;
  static int lightAzimuth = 0;
  static int numLights = 1;
  if( lights == NULL ){

    for ( i =0; i<numPrevLights; i++){
      free(lights[i]);
    }
    free(lights);
    free(dotProd);
    numPrevLights = numLights;

    lightRadius = getPixelBufferWidth() * 0.5 * 20;
    //printf("Sphere radius = %f Light radius = %f\n", rad, lightRadius);

    lights = (float**) malloc (numLights * sizeof(float*));
    dotProd = (float*) malloc (numLights * sizeof(float));
    for ( i =0; i<numLights; i++){
      lights[i] = (float*) malloc (7 * sizeof(float));
    }
    cosLightElevation = cos(0.1*M_PI*lightElevation);
    theta = 0.1*2*M_PI*lightAzimuth;
    for(i=0;i<numLights;i++){
      lights[i][0] = lightRadius * cos(theta) * cosLightElevation;
      lights[i][1] = lightRadius * sin(theta) * cosLightElevation;
      lights[i][2] = lightRadius * sin(0.1*M_PI*lightElevation);
      lights[i][3] = theta;
      if( numLights == 1 ){
	lights[i][4] = 1;
	lights[i][5] = 1;
	lights[i][6] = 1;
      } else {
	lights[i][4] = 0;
	lights[i][5] = 0;
	lights[i][6] = 0;
	lights[i][4+i] = 1;
      }
      theta += M_PI*2/numLights;
    }
  }
  lightDistRange = maxz - minz;
  for(i=0; i<numLights;i++){
    lvx = (lights[i][0]-x);
    lvy = (lights[i][1]-y);
    lvz = (lights[i][2]-z);
    temp2 = lvx*lvx + lvy*lvy + lvz *lvz;
    temp1 = sqrt(temp2);
    distanceScale =  ( lightRadius - temp1 - minz) / lightDistRange;
    //printf("%0.2f\n",distanceScale);
    if( distanceScale > 1 ) distanceScale = 1;
    if( distanceScale < 0 ) distanceScale = 0;
    temp=0;
    if( normal == NULL ){
      temp += x* lvx;
      temp += y* lvy;
      temp += z* lvz;
      dotProd[i] = distanceScale * temp /( rad * temp1) ;
    } else {
      temp += normal[0] * lvx;
      temp += normal[1] * lvy;
      temp += normal[2] * lvz;
      dotProd[i] = distanceScale * temp / temp1;
    }
  }

  for(j=0;j<3;j++)
    col[j] = 0;

  for(i=0; i<numLights;i++){
    if( dotProd[i] > 0 ){
      temp = dotProd[i];
      for(j=0;j<3;j++)
	col[j] += lights[i][4+j] * temp;
    }
  }
  for(j=0;j<3;j++){
    if( col[j] > 1 ) col[j] = 1;
    col[j] = col[j] * 255;
  }
  i=i;
}