#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <GL/glut.h>
#include <unistd.h>
#include <sys/resource.h>
#include <sys/time.h>
#include "forms.h"

/*
   Playpen for learning about displaying images using gl, glut, and in stereo
*/
#define TRUE   1
#define FALSE  0
#define ABS(x) (x < 0 ? -(x) : (x))
#define MIN(x,y) (x < y ? x : y)
#define MAX(x,y) (x > y ? x : y)

void HandleDisplay(void);
void CreateMenus(void);
void CreateEnvironment(void);
void HandleReshape(int,int);
void HandleKeyboard(unsigned char key,int x, int y);
void HandleSpecialKeyboard(int key,int x, int y);
void HandleMouse(int,int,int,int);
void HandleMainMenu(int);
void HandleVisibility(int vis);
void HandleIdle(void);
void GiveUsage(char *);
int ReadImages(char *,char *);

/* Miscellaneous Flags */
int stereo     = FALSE;
int fullscreen = FALSE;
int debug = FALSE;
#define FLIP TRUE

#define RAW 0
#define PPM 1
#define RLE 2

unsigned char left[600][800][3];
unsigned char right[600][800][3];
unsigned char row[800][3];

int main(int argc,char **argv)
{
   int i;

   if (argc < 3) {
      GiveUsage(argv[0]);
      exit(-1);
   }

   for (i=1;i<argc-2;i++) {
      if (strstr(argv[i],"-h") != NULL) {
         GiveUsage(argv[0]);
         exit(-1);
      }
      if (strstr(argv[i],"-s") != NULL)
         stereo = TRUE;
      if (strstr(argv[i],"-f") != NULL)
         fullscreen = TRUE;
      if (strstr(argv[i],"-d") != NULL)
         debug = TRUE;
   }
   
   if (!ReadImages(argv[argc-2],argv[argc-1])) 
      ;

   /* Set things up and go */
   glutInit(&argc,argv);
   if (!stereo)
      glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
   else
      glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_STEREO);
   glutCreateWindow("Stereo Image Viewer");
   glutReshapeWindow(800,600);
   if (fullscreen)
      glutFullScreen();
   glutDisplayFunc(HandleDisplay);
   glutReshapeFunc(HandleReshape);
   glutVisibilityFunc(HandleVisibility);
   glutKeyboardFunc(HandleKeyboard);
   glutSpecialFunc(HandleSpecialKeyboard);
   glutMouseFunc(HandleMouse);
   /* glutSetCursor(GLUT_CURSOR_NONE); */
   CreateEnvironment();
   CreateMenus();

   glutMainLoop();
   return(0);
}

/*
   This is where global settings are made, 
   things that will not change per frame
*/
void CreateEnvironment(void)
{
   glEnable(GL_DEPTH_TEST);

   /* Assume RGBA capabilities */
   glDisable(GL_DITHER);

   /* Antialiasing */
   glDisable(GL_LINE_SMOOTH);
   glDisable(GL_POINT_SMOOTH);
   glDisable(GL_POLYGON_SMOOTH); 

   /* Miscellaneous other options */
   glLineWidth(1.0);
   glPointSize(1.0);
   glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
   glFrontFace(GL_CW);
   glDisable(GL_CULL_FACE);
   glClearColor(0.0,0.0,0.0,0.0);         /* Background colour */
   glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
   glEnable(GL_COLOR_MATERIAL);
   glPixelStorei(GL_UNPACK_ALIGNMENT,1);
}

/*
   Handle a window reshape/resize
*/
void HandleReshape(int w,int h)
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glViewport(0,0,(GLsizei)w,(GLsizei)h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   glMatrixMode(GL_MODELVIEW);
}

/*
   Clear the buffers, doing the right thing for stereo
*/
void ClearBuffers(void)
{
   glDrawBuffer(GL_BACK_LEFT);
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   if (stereo) {
      glDrawBuffer(GL_BACK_RIGHT);
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   }
}

/*
   This is the basic display callback routine 
   called to redraw the buffers optionally in stereo
*/
void HandleDisplay(void)
{
   ClearBuffers();

   if (stereo) {

      glDrawBuffer(GL_BACK_RIGHT);
      glRasterPos2i(-1,-1);
      glDrawPixels(800,600,GL_RGB,GL_UNSIGNED_BYTE,right);

      glDrawBuffer(GL_BACK_LEFT);
      glRasterPos2i(-1,-1);
      glDrawPixels(800,600,GL_RGB,GL_UNSIGNED_BYTE,left);

   } else {

      glRasterPos2i(-1,-1);
      glDrawPixels(800,600,GL_RGB,GL_UNSIGNED_BYTE,left);
      
   }

   /* glFlush();  This isn't necessary for double buffers */
   glutSwapBuffers();
}

/*
   Deal with plain key strokes
*/
void HandleKeyboard(unsigned char key,int x, int y)
{
   switch (key) {
   case 27:                            /* ESC          */
   case 'Q':                           /* Quit          */
   case 'q': 
      exit(0); 
      break;
   }
}

/*
   Deal with special key strokes
   - Arrow keys rotate about the focal position
*/
void HandleSpecialKeyboard(int key,int x, int y)
{
   switch (key) {
   case GLUT_KEY_LEFT:
      break;
   case GLUT_KEY_RIGHT:
      break;
   case GLUT_KEY_UP:
      break;
   case GLUT_KEY_DOWN:
      break;
   }
}

/*
   Handle mouse events
*/
void HandleMouse(int button,int state,int x,int y)
{
   if (state == GLUT_DOWN) {
      HandleIdle();
      if (button == GLUT_LEFT_BUTTON) {
         
      } else if (button == GLUT_MIDDLE_BUTTON) {

      } /* Right button events are passed to menu handlers */
   }
}

/*
   Form the menu
*/
void CreateMenus(void)
{
   int mainmenu;

   mainmenu = glutCreateMenu(HandleMainMenu);
   glutAddMenuEntry("Quit",1);
   glutAttachMenu(GLUT_RIGHT_BUTTON);
}

/*
   Handle the main menu
*/
void HandleMainMenu(int whichone)
{
   const char *fn;
   char fname[256];

   switch (whichone) {
   case 1:
      exit(0); 
      break;
   }
}

/*
   How to handle visibility
*/
void HandleVisibility(int visible)
{
   if (visible == GLUT_VISIBLE) 
      glutIdleFunc(HandleIdle);
   else
      glutIdleFunc(NULL);
}

/*
   What to do on an idle event
*/
void HandleIdle(void)
{
   glutPostRedisplay();
}

/*
   Display the program usage information
*/
void GiveUsage(char *cmd)
{
   fprintf(stderr,"Usage:    %s [-h] [-s] [-f] leftimage rightimage\n",cmd);
   fprintf(stderr,"          -h   this text\n");
   fprintf(stderr,"          -s   stereo mode\n");
   fprintf(stderr,"          -f   full screen mode\n");
   fprintf(stderr,"Key Strokes and Menus:\n");
   fprintf(stderr,"           q - quit\n");
}

/* 
    Read a 800x600 radiance generated ppm, raw, rle images 
*/
int ReadImages(char *leftfile,char *rightfile)
{
   int i,j,k,d,w,h,c;
   char id[32];
   FILE *fptr1,*fptr2;
   int status = TRUE;
   int imagetype = RAW;

   if (strstr(leftfile,".ppm") != NULL)
      imagetype = PPM;
   if (strstr(leftfile,".rle") != NULL)
      imagetype = RLE;

   if ((fptr1 = fopen(leftfile,"r")) == NULL)
      return(FALSE);
   if ((fptr2 = fopen(rightfile,"r")) == NULL)
      return(FALSE);

   if (imagetype == PPM || imagetype == RLE) {

   if (imagetype == PPM && (fscanf(fptr1,"%s",id) != 1 || strcmp(id,"P6") != 0)) {
      fprintf(stderr,"Unexpected file id of \"%s\", expected \"P6\"\n",id);
      status = FALSE;
      goto skip;
   }
   if (imagetype == PPM && (fscanf(fptr2,"%s",id) != 1 || strcmp(id,"P6") != 0)) {
      fprintf(stderr,"Unexpected file id of \"%s\", expected \"P6\"\n",id);
      status = FALSE;
      goto skip;
   }

   if (fscanf(fptr1,"%d %d",&w,&h) != 2 || w != 800 || h != 600) {
      fprintf(stderr,"Unexpected image size of %dx%d, expected 800x600\n",w,h);
      status = FALSE;
      goto skip;
   }
   if (fscanf(fptr2,"%d %d",&w,&h) != 2 || w != 800 || h != 600) {
      fprintf(stderr,"Unexpected image size of %dx%d, expected 800x600\n",w,h);
      status = FALSE;
      goto skip;
   }

   if (imagetype == PPM && (fscanf(fptr1,"%d",&d) != 1 || d != 255)) {
      fprintf(stderr,"Unexpected image depth of %d, expected 255\n",d);
      status = FALSE;
      goto skip;
   }
   if (imagetype == PPM && (fscanf(fptr2,"%d",&d) != 1 || d != 255)) {
      fprintf(stderr,"Unexpected image depth of %d, expected 255\n",d);
      status = FALSE;
      goto skip;
   }

      while ((c = fgetc(fptr1)) != EOF && c != '\n')
         ;
      while ((c = fgetc(fptr2)) != EOF && c != '\n')
         ;

   }

   if (fread(left,sizeof(unsigned char),800*600*3,fptr1) != 800*600*3) {
      fprintf(stderr,"Error reading left image data\n");
      status = FALSE;
      goto skip;
   }
   if (FLIP) {
      for (j=0;j<300;j++) {
         memcpy(row,left[j],800*3);
         memcpy(left[j],left[599-j],800*3);
         memcpy(left[599-j],row,800*3);
      }
   }

   if (fread(right,sizeof(unsigned char),800*600*3,fptr2) != 800*600*3) {
      fprintf(stderr,"Error reading right image data\n");
      status = FALSE;
      goto skip;
   }
   if (FLIP) {
      for (j=0;j<300;j++) {
         memcpy(row,right[j],800*3);
         memcpy(right[j],right[599-j],800*3);
         memcpy(right[599-j],row,800*3);
      }
   }


skip:
   fclose(fptr2);
   fclose(fptr1);
   return(status);
}