#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <fcntl.h>
#include <assert.h>
#include <zlib.h>
#include <ctype.h>
#include "cement.h"
#include "pnmutils.h"
#include "file.h"
#include "powLookup.h"
#include "jpeg-6b/jpeglib.h"
#include "readlut.h"

/* Functions need in the library and the executable */
static inline double createValue(unsigned char a,double weight);

static int verbose=0;

#ifndef OBJECT_COMPILE
/* Functions only needed in the executable */
void usage(char *string);
void parse_commandline(int argc, char ** argv,
                       char ** input_filename,
                       double *R,
                       double *G,
                       double *B,
                       char ** output_filename,
                       char ** lut_filename);

void mystatus_lut(char *action, char *filename, char *lut, double R,double G, double B, double complete);
#endif
#ifdef NOTDEFINED
/*
 * this function doesn't return on error, it aborts.
 * 
 * the filename provided is opened and read into the global
 * double vector 'powLookupTable[]', overwriting the default 
 * values therein.  the variables 'p' and 'powLookupExponent' 
 * are zeroed.
 *
 * the input text file:
 * 1) should always have "L0\n" as the first three bytes.
 * 2) can have any comments delimited by '#' and '\n'
 * 3) blank lines are ignored
 * 4) an input line has: index value [0..255], whitespace, lightspace value
 * 5) all index values from 0 to 255 must be assigned a value for now.
 *    since we know the response function for a reasonable camera should be 
 *    at least semimonotonic, we could fill in gaps etc... not today.
 */
void readlut(char *lut_filename, double *p, double *powLookupExponent)
{

    // some variables used in reading a text file lut
    File *lutfile;
    double x;
    int i, j, k, lineno, maxlinelength=1024, lutsize=256;
    boolean isCommentLine, postWhitespace, *lutset, lutsetall;
    char *s;

    /* maali may 9 2000 */
    if(lut_filename !=NULL) 
    {
        if ((lutfile = fileopen(lut_filename, "r"))==NULL)
        {
            fprintf(stderr, "Unable to open %s.\n", lut_filename);
            exit(EXIT_FAILURE);
        } else 
        {
           /* read in lut.  things we want to add:
            * 3) header info (may be in comments) 
            *    e.g. name of assoc. imaging device
            */
            isCommentLine=FALSE; postWhitespace=FALSE; 
            maxlinelength=1024; lineno=0;
            
            // allocate and initialize 'lutset' and 's'
            lutset=((boolean*)malloc(lutsize*sizeof(boolean)));
            for (i=0; i<lutsize; i++) lutset[i]=FALSE;
            
            s=((char*)malloc(maxlinelength*sizeof(char)));
            if((!fileread(s,3,1,lutfile))||(s[0]!='L')
                            ||(s[1]!='0')||(s[2]!='\n'))
            {
                fprintf(stderr, "Unable to read header ('L0\\n') from %s.\n", 
                                lut_filename);
                exit(EXIT_FAILURE);
            } 
            for(i=0;i<lutsize;i++)  // while max_i < lutsize
            {
                do  // while comment or blank lines
                {
                    isCommentLine=FALSE; postWhitespace=FALSE; 
	                k=0; // memset(s, 0, maxlinelength); // paranoia not reqd
                    do // while !(eol or eof or kolumn>max) 
                    {
                        s[k]=filegetc(lutfile);
                        if (s[k]=='#') 
                        {
                           if (!postWhitespace) { isCommentLine=TRUE; }
                           s[k] = 0; 
                           while((!fileeof(lutfile))
                               &&(filegetc(lutfile)!='\n')) 
                           { 
                              /* here we could process info from comments */
                           } 
                           break;
                        }
                        if (!isspace(s[k])) postWhitespace=TRUE;
                        k++;
                    } while((s[k-1]!='\n')
                          &&(!fileeof(lutfile))
                          &&(k<maxlinelength-1)) ;
                    s[k-1]=0;
	                lineno++;
                 
                    /* if a comment is after some non-whitespace, 
                     * proceed with line we've got (minus the comment), 
                     * otherwise get another 
                     */
        
                    /* check if line is pure whitespace */ 
                    if (postWhitespace==FALSE) isCommentLine=TRUE;  
                } while (isCommentLine);
             
                sscanf(s, "%d %lf\n", &j, &x);
	            // some error checking...
                if ((j<0)||(j>255)) 
                {
                    fprintf(stderr, 
                        "Index (%d) out of range [0..255]"
                        " on line %3d of %s\n", j, lineno, lut_filename);
	                exit(EXIT_FAILURE);
	             }
	             powLookupTable[j] = x;
                 lutset[j] = TRUE;
                 if (verbose) 
                     printf("lut[%3d]=%10.20g\n", j, powLookupTable[j]);
            }//i<lutsize
             
            // check if all lut values were set
            lutsetall=TRUE;
            for (i=0; i<lutsize; i++) if (lutset[i]==FALSE) lutsetall=FALSE;
            if (lutsetall==FALSE) 
            {
                fprintf(stderr, 
                    "Error: Not all LUT index values have a lightspace value.\n");
                fprintf(stderr, "Missing indices: ");
                for (i=0; i<lutsize; i++)  if (lutset[i]==FALSE) fprintf(stderr, " [%3d]", i);
                fprintf(stderr, "\n");
                exit(EXIT_FAILURE);
            }

            // the exponent model is not being used
            if (p!=NULL) *p = 0.0;
            if (powLookupExponent!=NULL) *powLookupExponent = 0.0;
            
            // deallocation
            free(s);
            free(lutset);
        } // if lutfile!=NULL 
    } 
    else //lut_filename==NULL
    {
        fprintf(stderr, "Readlut called with no lut file specified.\n"
            "Continuing run with default lut.\n");
    }
}
#endif
int cementinit(char *input_filename,
               char *dest_filename,
               double R,
               double G,
               double B,
               char* command,
               void (*status)(char *action, char *filename, double R,double G, double B, double complete)
              )
{
  return cementinit_lut(input_filename, dest_filename, 
           (char*)NULL, R, G, B, command, status, NULL);
}

/* set one of the status functions to NULL when calling */
int cementinit_lut(char *input_filename,
               char *dest_filename,
               char *lut_filename,
               double R,
               double G,
               double B,
               char* command,
               void (*status)(char *action, char *filename, double R,double G, double B, double complete),
               void (*lutstatus)(char *action, char *filename, char*lut, double R,double G, double B, double complete)
              )
{
    struct image_params a_params={NULL,0,0,0,0};
    File * a, * dest;
    double p=EXPONENT;  /* exponent for pow */
    unsigned char a_pixel[ARRAY_SIZE];
    double out_pixel[ARRAY_SIZE];
    int i,j;
    int channels_per_pixel;

    /* Timing measurments */
    struct timeval timeValStart;
    struct timeval timeValEnd;
    struct timezone timeZone;
    int minutes;
    double seconds=0.0;
#ifdef GET_TIME_MEASUREMENTS
    struct timeval runTimeStart;
    struct timeval runTimeStop;
    double fileReadTime=0.0;
    double fileWriteTime=0.0;
    double computeTime=0.0;
#endif
    
    unsigned int numberOfPixels;
    char string[MAX_STRING_LENGTH];
    unsigned int image_ptr=0;
   
    a_params.filename=input_filename;

    if ((a=fileopen(a_params.filename, "r"))==NULL)
    {
        fprintf(stderr, "Unable to open %s.\n", a_params.filename);
        exit(EXIT_FAILURE);
    }

    /* maali may 9 2000 */
    if(lut_filename !=NULL) 
    {
        readlut(lut_filename, &p, &powLookupExponent);
    }

    if (dest_filename==NULL)
    {
        fprintf(stderr, "ERROR: There is no destination file.\n");
        exit(EXIT_FAILURE);
    }

    if ((dest=fileopen(dest_filename, "w"))==NULL)
    {
        fprintf(stderr, "Unable to open %s.\n", dest_filename);
        exit(EXIT_FAILURE);
    }

    if(p!=powLookupExponent)
    {
        printf("Exponents must match\n");
        exit(EXIT_FAILURE);
    }

    if(isJpegFile(a)==0)
    {
        get_image_params(a, &a_params);

        if (a_params.type=='6')
            channels_per_pixel=3;
        else
        {
            fprintf(stderr, "Input image must be type P6 and it is of type P%c\n",a_params.type);
            exit(EXIT_FAILURE);
        }


    }
    else
    {
        a_params.type='6';
        a_params.max_val=255;
        channels_per_pixel=3;
        
        if(read_JPEG_file (a_params.filename)==0)
        {
            printf("ERROR: File %s does not exist\n",a_params.filename);
            exit(0);
        }
        
        image_ptr=0;
        a_params.width=image_width;
        a_params.height=image_height;
    }


    sprintf(string, "P%c\n", 'A');
    filewrite(string,sizeof(unsigned char),strlen(string),dest);
//    fileclose(dest);
//    exit(0);

    sprintf(string, "# %s %s %f %f %f -o %s\n",command,input_filename,R,G,
            B,dest_filename);
    filewrite(string,sizeof(unsigned char),strlen(string),dest);

    sprintf(string, "%d %d\n%d\n%d\n%f\n",a_params.width,
            a_params.height, a_params.max_val,1,(float)EXPONENT);
    filewrite(string,sizeof(unsigned char),strlen(string),dest);


#ifdef SILENT_RUN
//    printf("Init %s (%s) %d %d %d\r",a_params.filename, lut_filename, (int)R,(int)G,(int)B);
#else

    printf("Initilizing Lightspace from file: \"%s\",",a_params.filename);
    if (lut_filename!=NULL) printf("    Using LookUp Table from file: \"%s\",",lut_filename);
    printf(" P%c, %dx%d, Channels_per_pixel: %d, ",a_params.type,a_params.width,a_params.height,channels_per_pixel);

    printf("R=%7.3f ",R);
    printf("G=%7.3f ",G);
    printf("B=%7.3f\n",B);
#endif
    
    /* Start Timer */
    if(gettimeofday(&timeValStart,&timeZone)==-1)
    {
        fprintf(stderr,"Error getting the time\n");
        exit(0);
    }

    numberOfPixels=a_params.width*a_params.height;

    if(((float)numberOfPixels/NUMBER_PIXELS_PER_READ)!=(int)((float)numberOfPixels/NUMBER_PIXELS_PER_READ))
    {
        if(verbose)
            printf("\nERROR: The number of pixels %d is not evenly divisible by %d. ",numberOfPixels,NUMBER_PIXELS_PER_READ);

        numberOfPixels=(int)((float)numberOfPixels/NUMBER_PIXELS_PER_READ)*NUMBER_PIXELS_PER_READ;
        if(verbose)
            printf("We will go up to %d pixels.\n",numberOfPixels);
    }

    for(i=0;i<numberOfPixels;i+=NUMBER_PIXELS_PER_READ)
    {
        if(i%(3*NUMBER_PIXELS_PER_READ)==0)
	{
            if(status!=NULL)
                status("Init",a_params.filename,R,G,B,(double)100*i/numberOfPixels);
            if(lutstatus!=NULL)
                lutstatus("Init",a_params.filename,lut_filename,R,G,B,(double)100*i/numberOfPixels);
	}

        
#ifdef GET_TIME_MEASUREMENTS
        gettimeofday(&runTimeStart,&timeZone);
#endif

        if(isJpegFile(a)==0)
            fileread(a_pixel, sizeof(unsigned char), ARRAY_SIZE, a);
        else
        {
            memcpy(a_pixel,&image_buffer[image_ptr],ARRAY_SIZE);
            image_ptr+=ARRAY_SIZE;
        }

#ifdef GET_TIME_MEASUREMENTS
        gettimeofday(&runTimeStop,&timeZone);

        seconds=(double)runTimeStop.tv_sec+(double)runTimeStop.tv_usec/1000000;
        seconds-=(double)runTimeStart.tv_sec+(double)runTimeStart.tv_usec/1000000;
        fileReadTime+=seconds;

        gettimeofday(&runTimeStart,&timeZone);
#endif
        
        for(j=0;j<ARRAY_SIZE;j+=3)
        {
            out_pixel[j]=createValue(a_pixel[j],R);
            out_pixel[j+1]=createValue(a_pixel[j+1],G);
            out_pixel[j+2]=createValue(a_pixel[j+2],B);
        }

#ifdef GET_TIME_MEASUREMENTS
        gettimeofday(&runTimeStop,&timeZone);

        seconds=(double)runTimeStop.tv_sec+(double)runTimeStop.tv_usec/1000000;
        seconds-=(double)runTimeStart.tv_sec+(double)runTimeStart.tv_usec/1000000;

        computeTime+=seconds;

        gettimeofday(&runTimeStart,&timeZone);
#endif
        
        filewrite(out_pixel, sizeof(double), ARRAY_SIZE, dest);

#ifdef GET_TIME_MEASUREMENTS
        gettimeofday(&runTimeStop,&timeZone);

        seconds=(double)runTimeStop.tv_sec+(double)runTimeStop.tv_usec/1000000;
        seconds-=(double)runTimeStart.tv_sec+(double)runTimeStart.tv_usec/1000000;
        fileWriteTime+=seconds;
#endif
    }

    if(numberOfPixels!=(a_params.width*a_params.height))
    {
        if(verbose)
            printf("Cleanup on pixels %d to %d\n",numberOfPixels,a_params.width*a_params.height);

        for(i=numberOfPixels;i<a_params.width*a_params.height;i++)
        {
            if(isJpegFile(a)==0)
                fileread(a_pixel, sizeof(unsigned char),CHANNELS_PER_PIXEL, a);
            else
            {
                memcpy(a_pixel,&image_buffer[image_ptr],CHANNELS_PER_PIXEL);
                image_ptr+=CHANNELS_PER_PIXEL;
            }

            out_pixel[0]=createValue(a_pixel[0],R);
            out_pixel[1]=createValue(a_pixel[1],G);
            out_pixel[2]=createValue(a_pixel[2],B);
            filewrite(out_pixel, sizeof(double), CHANNELS_PER_PIXEL, dest);
        }
    }

    /* End timer */
    if(gettimeofday(&timeValEnd,&timeZone)==-1)
    {
        printf("Error getting the time\n");
        exit(0);
    }

    while (!fileeof(a))
    {
        if(isJpegFile(a)==0)
            fileread(a_pixel, sizeof(char),CHANNELS_PER_PIXEL, a);
        else
        {
            memcpy(a_pixel,&image_buffer[image_ptr],ARRAY_SIZE);
            image_ptr+=ARRAY_SIZE;
        }

        if(fileeof(a))
            break;
        
        out_pixel[0]=createValue(a_pixel[0],R);
        out_pixel[1]=createValue(a_pixel[1],G);
        out_pixel[2]=createValue(a_pixel[2],B);
        printf("EP A: %d %d %d\t",a_pixel[0],a_pixel[1],a_pixel[2]);
        printf("OUT: %f %f %f\n",out_pixel[0],out_pixel[1],out_pixel[2]);
        filewrite(out_pixel, sizeof(double), CHANNELS_PER_PIXEL, dest);
    }

    fileclose(a);
    fileclose(dest);

    seconds=(double)timeValEnd.tv_sec+(double)timeValEnd.tv_usec/1000000;
    seconds-=(double)timeValStart.tv_sec+(double)timeValStart.tv_usec/1000000;

#ifdef GET_TIME_MEASUREMENTS
    printf("%f s doing File Read %f%%\n",fileReadTime,100*fileReadTime/seconds);
    printf("%f s doing File Writes %f%%\n",fileWriteTime,100*fileWriteTime/seconds);
    printf("%f s doing Computation %f%%\n",computeTime,100*computeTime/seconds);
    printf("%f s doing Timing and looping\n",seconds-fileReadTime-fileWriteTime-computeTime);
#endif
    
    if(seconds>60)
    {
        minutes=seconds/60;
        seconds=seconds-minutes*60;
    }
    else
        minutes=0;

    if(verbose || GET_RUN_TIME)
    {
#ifndef SILENT_RUN
        if(minutes==1)
            printf("Run Time is about %d minute %f seconds.\n",minutes,seconds);
        else
            printf("Run Time is about %d minutes %f seconds.\n",minutes,seconds);
#else
            if(status!=NULL)
                status("Init",a_params.filename,R,G,B,(double)100);
            if(lutstatus!=NULL)
                lutstatus("Init",a_params.filename,lut_filename,R,G,B,(double)100);
//        printf("Init %s (%s) %d %d %d %4.2f(s)\n",a_params.filename,lut_filename,(int)R,(int)G,(int)B,minutes*60+seconds);
#endif
    }

    if(isJpegFile(a)==1)
        free(image_buffer);

    return(EXIT_SUCCESS);
}


static inline double createValue(unsigned char a,double weight)
{
    return(weight*powLookupTable[a]);
}

#ifndef OBJECT_COMPILE
int main(int argc, char ** argv)
{
    char * dest_filename=NULL;
    char * input_filename=NULL;
    char * lut_filename=NULL;
    double R,G,B;

    parse_commandline(argc, argv, &input_filename, &R,&G,&B,&dest_filename,&lut_filename);
    return(cementinit_lut(input_filename,dest_filename,lut_filename,R,G,B,argv[0],NULL,mystatus_lut));
}

void mystatus_lut(char *action, char *filename, char*lut_filename, double R,double G, double B, double complete)
{
    if (lut_filename!=NULL) printf("%s %s (%s) %d %d %d %d%%\r",action,filename,lut_filename,(int)R,(int)G,(int)B,(int)complete);
    else printf("%s %s %d %d %d %d%%\r",action,filename,(int)R,(int)G,(int)B,(int)complete);
    fflush(stdout);
    if((int)complete==100)
	printf("\n");
}

void usage(char *string)
{
    fprintf(stderr, "Use: %s [Imagespace file] <R> <G> <B> -o [Lightspace file] \n"
		    "\t [-lut [Imaging Device Response file]]\n\n",string);
    fprintf(stderr, " [Imagespace file] is a ppm file that will start a lightspace.\n");
    fprintf(stderr, " <R>=Float for Red weight.\n");
    fprintf(stderr, " <G>=Float for Green weight.\n");
    fprintf(stderr, " <B>=Float for Blue weight.\n");
    fprintf(stderr, " [LightSpaceFile] is a Portable Lightspace Map (plm) that will be created.\n");
    fprintf(stderr, " [LookUp Table file] (optional, lut) specifies a map from \n");
    fprintf(stderr, " imagespace to lightspace; if none specified, a default map is used.\n");
    exit(EXIT_SUCCESS);
}

void parse_commandline(int argc, char ** argv,
                       char ** input_filename,
                       double *R,
                       double *G,
                       double *B,
                       char ** output_filename,
                       char ** lut_filename) 
{
    if (argc<7)
    {
        fprintf(stderr,"error: number of input arguments was only %d\n",argc-1);
        usage(argv[0]);
    }

    *input_filename=(char*)strdup(argv[1]);
    sscanf(argv[2],"%lf",R); /* sscanf does not recognize %g, must be %lf */
    sscanf(argv[3],"%lf",G); /* sscanf does not recognize %g, must be %lf */
    sscanf(argv[4],"%lf",B); /* sscanf does not recognize %g, must be %lf */

    if(argv[5][0]!='-' || argv[5][1] !='o')
        usage(argv[0]);

    *output_filename=(char *)strdup(argv[6]);

    /* maali may 9 2000 */
    if(argc>7)
    {
        if((argv[7][0]=='-')&&(argv[7][1]=='l')&&(argv[7][2]=='u')&&(argv[7][3]=='t'))
        {
            *lut_filename=(char *)strdup(argv[8]);
        } else {
            usage(argv[0]);
        }
    }
}
#endif