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

static int verbose=0;

/*
 * 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... since this code exists
             * only to subvert the error-checking for compatible exponent 
             * values, we really should provide a warning.  what is really 
             * required is a LightSpaceSignature, ideally a word or two which
             * can be used for exactly this type of checking, to ensure we are
             * coming and going from lightspace in a useful way--of course 
             * identical (or very close?) lut's would map to the same LSS
             */
            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");
    }
}