#include <GL/glut.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#define WINDOW "image"
#define UP 101
#define DOWN 103
#define RIGHT 102
#define LEFT 100
#define MAX 200
 
int NX, NY, MAXNZ, sets;
int foo;

void do_byteswap_f32( float arr[], int nel ), global(), local( int, int );
void readnames( char[] ), readarray( float[], char[], int ), readjet();
void TimerFunction( int );

float data[MAX*MAX], mxval, mnval, jet[MAX][MAX];
float globalmx=0, globalmn=100;
int win[MAX], ilev=1, howmany, count=0, glo=0, usr=0, anim=0;
char fns[MAX][MAX];

void menu(int value){
 int i;

 switch( value ){
  case 1: usr=glo=0;         // unset glo & usr, sets local max/min
          local( count, ilev ); // reads new array, set local max/min 
          break;
  case 2: glo=1;         // enables global max/min  
          usr=0;         // unsets usr 
          mxval=globalmx;     // sets max to globalmx
          mnval=globalmn;     // sets min to globalmn
          break;
  case 3: usr=1;             // switch to user-set max/min 
          glo=0;             // unset glo
          printf( "Max=" );  scanf( "%f", &mxval );  // prompt for new max/min
          printf( "Min=" );  scanf( "%f", &mnval );
          break;
 }
 for( i=0; i<sets; i++){
  glutSetWindow(win[i]);
  glutPostRedisplay(); // display with new values
 }
}

void display(void){
 int i, j, ioff; 
 float r, g, b, num, k, y;
 char str[MAX]; 
 glClear( GL_COLOR_BUFFER_BIT );  // background to black

 ioff=0;                    // ioff will count thru both i&j b/c data is 1D
 for( j=0; j<NY; j++ )
  for( i=0; i<NX; i++ ){
   r=g=b=0;                 // set color values to black
   if( data[ioff]==0 );     // if data=0, values stay black
   else{
    if( data[ioff]<mnval )  num=0;  // if data is less than min, =min
    else{
     if( data[ioff]>mxval )  num=63; // if data is more than max, =max
     else 
      num=63*( data[ioff]-mnval )/( mxval-mnval );  //scale num from 0-63
    }
    r=jet[(int)num][0];  // set red val
    g=jet[(int)num][1];  // set green val
    b=jet[(int)num][2];  // set blue val  
   }

   glColor3f( r, g, b );      // put r, g, b into effect
   glRectf( i, j, i+1, j+1 ); // draws a square for data value 
   ioff++;                    
  } 

  glColor3f( 1, 1, 1 );       // set color to white
  glRectf( NX, 0, NX+1, NY+1 );    // draws a border
  for( i=0; i<64; i++ ){       //draws color bar    
   glColor3f( jet[i][0], jet[i][1], jet[i][2]);         //sets color
   k=(float)i;                // turns i into a float
   y=(float)NY/64;            // sets height of rectangles
   glRectf( NX+10, y*k, NX+20, (k+1)*y );    // draws rectangle 
  } 

  glColor3f( 1, 1, 1 );     // color to white

  sprintf( str, "%.4e", mxval );      // labels color bar with max val
  glRasterPos2f( NX+2, NY-1 );        // sets where to write to 
  for( i=0; i<strlen( str ); i++)     // writes each character
   glutBitmapCharacter( GLUT_BITMAP_HELVETICA_12, str[i] );

  str[0]='\0';         // sets str to null

  sprintf( str, "%.4e", mnval );      // labels color bar with min val
  glRasterPos2f( NX+2, 1 );           // sets where to write to
  for( i=0; i<strlen( str ); i++ )    // writes each character
   glutBitmapCharacter( GLUT_BITMAP_HELVETICA_12, str[i] );
 
  glRectf( 0, NY, NX, NY+1 );        // draws a border  
  glRasterPos2f( 1, NY+6 );            // sets where to write to
  for( i=0; i<strlen( fns[count] ); i++ ) // labels current file name
   glutBitmapCharacter( GLUT_BITMAP_HELVETICA_18, fns[count][i] ); 

  str[0]='\0';   // sets str to null
  
  sprintf( str, "Level %d", ilev );   // labels current level 
  glRasterPos2f( 1, NY+3 );           // sets where to write to
  for( i=0; i<strlen( str ); i++ )    // writes each character
   glutBitmapCharacter( GLUT_BITMAP_HELVETICA_18, str[i] ); 

  str[0]='\0';   //sets str to null
 
  if( glo )                   // labels how max/min have been set
   sprintf( str, "Global" );  // if glo is set, display Global
  if( usr ) 
   sprintf( str, "User-set" );  // if usr is set, display User-set
  if( !usr && !glo ) 
   sprintf( str, "Local" );    // else display Local 
  glRasterPos2f( NX+12, NY+3);
  for( i=0; i<strlen( str ); i++ )  // write each char of label
   glutBitmapCharacter( GLUT_BITMAP_HELVETICA_18, str[i] ); 

  str[0]='\0';
  
  if( anim ){                  // tell user if autoplay is on
   sprintf( str, "Autoplay" );
   glRasterPos2f( NX-8, NY+3 );
   for(i=0; i<strlen( str ); i++ )  // write each char of label
    glutBitmapCharacter( GLUT_BITMAP_HELVETICA_18, str[i] );
  }
 
 glutSwapBuffers();  
 glFlush(); 
}

void key( unsigned char key, int x, int y ){   //called on key press
 int i;
 
 switch(key){
  case 'q':   exit(0);     //quits on 'q'
              break;
  case 'r':   count=0; 
              ilev=1;
              if( glo || usr )
               readarray( data, fns[count], ilev ); 
              else                           
               local( count, ilev );        
              for( i=0; i<sets; i++){ 
               glutSetWindow(win[i]);
               glutPostRedisplay();            
              }
              break;
  case 'a':   anim++;            // switches autoplay off/on  
              anim=anim%2;       // when a is pressed repeatedly 
              for( i=0; i<sets; i++){ 
               glutSetWindow(win[i]);
               glutPostRedisplay();            
              }
              break;
 } 
}

void TimerFunction( int value ){
 int i;

 switch(value){          // increments in the correct direction
  case DOWN : if( ilev<MAXNZ ) 
               ilev++;    // if down arrow pressed, moves down levels       
              break;
  case UP   : if( ilev>1 )    
               ilev--;    // if up arrow is pressed, moves up levels
              break;
  case LEFT : if( count>0 )      
               count--;   // if left arrow is pressed, moves back in time
              break;
  case RIGHT: if( count<howmany-1 )
               count++;   // if right arrow is pressed, moves forward in time
              break;
 }
 
 if( glo || usr )         // if glo or usr is set, read new array w/o 
  readarray( data, fns[count], ilev );  // calculating new max/min
 else                                 // if local max/min is set
  local( count, ilev );               // read new array, calculate new max/min 

 for( i=0; i<sets; i++){
  glutSetWindow(win[i]);
  glutPostRedisplay();                 // display with new values
 }

 switch( value ){    
  case DOWN : if( ilev<MAXNZ )        // sets limit that you can go down
               glutTimerFunc( 100, TimerFunction, value ); // recalls itself
              break;
  case UP   : if( ilev>1 )   // sets limit that you can go up
               glutTimerFunc( 100, TimerFunction, value ); // recalls itself 
              break;
  case LEFT : if( count>0 )  // sets limit that you can go left
               glutTimerFunc( 100, TimerFunction, value ); // recalls itself
              break;
  case RIGHT: if( count<howmany-1 )  // sets limit that you can go right
               glutTimerFunc( 100, TimerFunction, value ); // recalls itself
              break;
 } 
}

void specialkey( int key, int x, int y ){
 int i;

 if( anim )     // if animation is set, call the timer function
  glutTimerFunc( 100, TimerFunction, key);

 switch(key){
  case DOWN   :  if( ilev<MAXNZ ) // if you haven't reached the bottom
                  ilev++;         // keep going down
                 break;
  case UP     :  if( ilev>1 )     // if you haven't reached the top
                  ilev--;         // keep going up
                 break;
  case RIGHT  :  if( count<howmany-1 ) // if you haven't reached the last file
                  count++;             // keep going right
                 break;
  case LEFT   :  if( count>0 )         // if you haven't reached the first file
                  count--;             // keep going left
                 break;
 }
  if( glo || usr )  // if global or user-set max/min
   readarray(data, fns[count], ilev); // read new array w/o new max/min
  else             // if local max/min set
   local(count, ilev);  // read new array and calculate local max/min

 for(i=0; i<sets; i++){
  glutSetWindow(win[i]);
  glutPostRedisplay();  // display with new values
 }
}

void global(){  // calculates the max/min for the total data set
 FILE* fp;
 int i, j;
 
 for( i=0; i<howmany; i++ )   // cycles through each file
  for( j=0; j<MAXNZ; j++ ){   // cycles through each level for each file
   local( i, j );             // calculates local/max/min for specific data set 
   if( mxval > globalmx )  globalmx = mxval;   // sets highest value to globalmx
   if( mnval < globalmn )  globalmn = mnval;   // sets lowest value to globalmn
  }
}

void local( int time, int lev ){  // calculates local max/min
 int i;
 
 mxval=0;  
 mnval=100;
 readarray( data, fns[time], lev ); // read new array of data
 for( i=0;i<NX*NY;i++ ){
  if( data[i] > mxval )  mxval=data[i]; // set largest val to mxval 
  if( data[i] < mnval )  mnval=data[i]; // set smallest val to mnval 
 }
}

void readnames( char filename[] ){  // reads in list of filenames containing data
 FILE* fp;
 int i=0;
 
 fp=fopen( filename, "r" );    // opens list
 while( !feof(fp) ){           // reads until the end of the file 
  fscanf( fp, "%s",fns[i] );   // places filename into an array of strings 
  i++;                         // counts how many filenames there are  
 } 
 fclose( fp );                 // close file
 howmany=i-1;                 
}

void readjet(){  //reads in color scale values
 
 FILE* fp;
 int i, j; 
  
 fp=fopen( "jet.dat", "r" );  // opens file containing values
 for( i=0; i<64; i++ )       // reads in 64 sets of r, g, b values
  for( j=0; j<3; j++ )
   fscanf( fp, "%f", &jet[i][j] );
 fclose( fp );              // closes file
}


void readarray( float arr[], char filename[], int il ){   // reads new data
 FILE *fp;
 int i;
 
 fp=fopen( filename, "r" );  // opens the file containing data
 fseek( fp, (il-1)*NX*NY*4, SEEK_SET ); // seeks to the correct level using ilev
 fread( arr, sizeof( arr[0] ), NX*NY, fp );  // reads in data to fill one level 
 fclose( fp );                         // close file
 do_byteswap_f32( arr,NX*NY );          // swaps the binary data 
}

void do_byteswap_f32( float arr[], int nel ) // switches endian
{
   int i;
   char src[4];
   char trg[4];
   for( i=0; i<nel; i++ ){
    memcpy( src, &(arr[i]), 4);
    trg[0]=src[3];
    trg[1]=src[2];
    trg[2]=src[1];
    trg[3]=src[0];
    memcpy( &(arr[i]), trg, 4);
   }
}
int main( int argc, char *argv[] ){
 int i, x, y, tmp;
 char filename[MAX];

 printf( "Please enter x, y and z dimensions\n" );   
 scanf( "%d %d %d", &NX, &NY, &MAXNZ );   //user-set NX, NY, NZ
 printf( "Please enter filename\n" );
 scanf( "%s", filename );   //filename contains names of data files 
 printf( "how many data sets?\n" );
 scanf( "%d", &sets);

 readjet();                        // stores color values
 readnames( filename );            // gets list of filenames to read from
 global();                         // calculates max and min for all data
 local( count, ilev );             // sets curr data array, finds local max/min                

 glutInit( &argc, argv );         // initializes stuff
 glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); 
 glutInitWindowSize( 1400/3, ((NY+15)*1400)/((NX+25)*3) ); // sets window size from NX, NY

 for(i=0; i<sets; i++){
  x=(i%3)*(1400/3);
  y=(i/3)*((NY+15)*1400)/((NX+25)*3);
  glutInitWindowPosition( x, y ); 
  win[i]=glutCreateWindow( WINDOW );     // window is created
  glClearColor( 0, 0, 0, 0 );    // sets clear color to black
  gluOrtho2D( 0, NX+25, 0, NY+15 );  // sets how data is mapped to window
  glutDisplayFunc( display );
  glutKeyboardFunc( key );   // called on key press
  glutSpecialFunc( specialkey );  // called on special key press (arrow keys)

  glutCreateMenu( menu );   // adds a menu
   glutAddMenuEntry( "Local Color Scale", 1 );   // describes choices
   glutAddMenuEntry( "Global Color Scale", 2 );
   glutAddMenuEntry( "User-Set Color Scale", 3 );
  glutAttachMenu( GLUT_RIGHT_BUTTON );  // menu called on right click
 }

 glutMainLoop();
 return 0;
}