#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, setsx, setsy;

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

float data[MAX][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 initfns[MAX][MAX], fns[MAX][MAX][MAX];

void menu(int value){
 int i;

 switch( value ){
  case 1: usr=glo=0;         // unset glo & usr, sets local max/min
          glutPostRedisplay();
          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
          glutPostRedisplay(); // display with new values
          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 );
          glutPostRedisplay(); // display with new values
          break;
 }
}

void display(void){
 int i, j, ioff, q; 
 float r, g, b, num, k, y;
 char str[MAX]; 

 for( q=0; q<setsx*setsy; q++ ){    //runs display func for each window
  glutSetWindow( win[q] ); 
  glClear( GL_COLOR_BUFFER_BIT );  // background to black
  if( glo || usr )
   readarray( data[q], fns[q][count], ilev ); 
  else                           
   local( q, count, ilev );        

  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[q][ioff]==0 );     // if data=0, values stay black
    else{
     if( data[q][ioff]<mnval )  num=0;  // if data is less than min, =min
     else{
      if( data[q][ioff]>mxval )  num=63; // if data is more than max, =max
      else 
       num=63*( data[q][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
  glRectf( 0, NY, NX, 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, "%.2e", mxval );      // labels color bar with max val
  bitmap( str, NX+2, NY-1 );
  
  sprintf( str, "%.2e", mnval );      // labels color bar with min val
  bitmap( str, NX+2, 1 );

  sprintf( str, "Level %d", ilev );   // labels current level 
  bitmap( str, 1, NY+3);

  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 
  bitmap( str, NX+12, NY+3);
  
  if( anim ){                  // tell user if autoplay is on
   sprintf( str, "Autoplay" );
   bitmap( str, NX-15, NY+3 );
  }

  bitmap( fns[q][count], 1, NY+6 );  // labels current file
 
  glutSwapBuffers();  
  glFlush(); 
 }
}

void bitmap( char str[], int x, int y ){
 int i;

 glRasterPos2f( x, y );
 for( i=0; i<strlen( str ); i++) 
  glutBitmapCharacter( GLUT_BITMAP_HELVETICA_12, str[i] );
}

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;
              glutPostRedisplay();            
              break;
  case 'a':   anim++;            // switches autoplay off/on  
              anim=anim%2;       // when a is pressed repeatedly 
              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;
 }
 
 glutPostRedisplay();            

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

void global(){  // calculates the max/min for the total data set
 FILE* fp;
 int h, i, j;
 for( h=0; h<setsx*setsy; h++) // cycles through each data set
  for( i=0; i<howmany; i++ )   // cycles through each time 
   for( j=0; j<MAXNZ; j++ ){   // cycles through each level for each file
    local( h, 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 i, int time, int lev ){  // calculates local max/min
 int j;
 
 mxval=0;  
 mnval=100;
 readarray( data[i], fns[i][time], lev ); // read new array of data
 for( j=0; j<NX*NY; j++ ){
  if( data[i][j] > mxval )  mxval=data[i][j]; // set largest val to mxval 
  if( data[i][j] < mnval )  mnval=data[i][j]; // set smallest val to mnval 
 }
}

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

void parentfunc(){
 glClear( GL_COLOR_BUFFER_BIT );  // background to black
 glutSwapBuffers();
 glFlush();
}

int main( int argc, char *argv[] ){
 int i, tmpx, tmpy, winx, winy, parent;
 char filename[MAX];

 sscanf(argv[1], "%dx%d", &winx, &winy);
 winy-=20;
 
 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( "Please enter dimensions of data sets.\n" );
 scanf( "%dx%d", &setsx, &setsy);

 readjet();                        // stores color values
 readnames( filename );   // gets list of filenames to read from
 global();                         // calculates max and min for all data

 glutInit( &argc, argv );
 glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); 
 glutInitWindowSize( winx, winy ); 
 glutInitWindowPosition( 10, 10 );
 parent=glutCreateWindow( WINDOW );

 glClearColor( 0, 0, 0, 0 );    // sets clear color to black
 gluOrtho2D( 0, winx , winy, 0 );  // sets how data is mapped to window
 glutDisplayFunc( display );
 glutKeyboardFunc( key );   // called on key press
 glutSpecialFunc( specialkey );  // called on special key press (arrow keys)

 for( i=0; i<setsx*setsy; i++ ){
  tmpx = (i%setsx)*(winx/setsx);
  tmpy = (i/setsx)*(winy/setsy); 

  local( i, count, ilev );      // sets curr data array, finds local max/min 

  win[i]=glutCreateSubWindow( parent, tmpx, tmpy, winx/setsx, winy/setsy ); 
  gluOrtho2D( 0, NX+35, 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;
}