#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "array_utility.h"

//  Sample program to read a PPM (color) or PGM (grey) image 
//  and write it out as a BMP image

char *strstr();

typedef struct {
  unsigned short int type;                 // Magic identifier           
  unsigned int size;                       // File size in bytes         
  unsigned short int reserved1, reserved2;
  unsigned int offset;                     // Offset to image data, bytes
} FILEHEADER;

typedef struct {
  unsigned int size;               // Header size in bytes      
  int width,height;                // Width and height of image 
  unsigned short int planes;       // Number of color planes   
  unsigned short int bits;         // Bits per pixel           
  unsigned int compression;        // Compression type         
  unsigned int imagesize;          // Image size in bytes      
  int xresolution,yresolution;     // Pixels per meter         
  unsigned int ncolors;            // Number of colors         
  unsigned int importantcolors;    // Important colors         
} INFOHEADER;

float **read_bw_image(), ***read_color_image();

int main(int argc,char **argv)
{
  int i,j, M,N, color, gotindex = 0;
  unsigned char grey,r,g,b;
  FILEHEADER fileheader;
  INFOHEADER infoheader;
  char fname_in[50], *fname_out, *sp, magic[4];
  FILE *fp;
  float ***img_color, **img_grey;
  
  /* Check arguments */
  if (argc < 2) {
    printf("Usage: %s filename\n",argv[0]);
    printf("Enter filename: ");
    scanf("%s",&fname_in);
  }
  else {
    strcpy(fname_in,argv[1]);
  }
  
  if ((fp = fopen(fname_in,"r")) == NULL) {
    fprintf(stderr,"Unable to open BMP file \"%s\"\n",fname_in);
    exit(-1);
  }

  get_header(fp,&N,&M,magic);
  
  printf("Input image size width and height: %d %d\n",N,M);

  if (strcmp(magic, "P5")==0) {
    color=0; 
    printf("Grey image...\n");
    img_grey=read_bw_image(fp,M,N); 
  }
  else if (strcmp(magic, "P6")==0) {
    color=1; 
    printf("Color image...\n");
    img_color=read_color_image(fp,M,N); 
  }
  else 
    { printf("invalid magic=%s\n",magic);  pause(); }

  fname_out=fname_in;
  sp=strstr(fname_in,".p");
  if (sp) strcpy(sp,".bmp");
  else strncat(fname_out,".bmp",4);

  if ((fp = fopen(fname_out,"w")) == NULL) {
    fprintf(stderr,"Unable to open BMP file \"%s\"\n",fname_out);
    exit(-1);
  }

  fileheader.type='M'*256+'B';
  fprintf(stderr,"File ID is %d \n",fileheader.type);

  fileheader.offset=14+40;      // fileheader+infoheader 
  if (color) 
    fileheader.size=fileheader.offset+3*M*N;
  else {
    fileheader.offset+=1024;
    fileheader.size=fileheader.offset+1024+M*N;  // with color table
  }

  infoheader.ncolors=infoheader.importantcolors=256;
  if (color) infoheader.bits=24; 
  else infoheader.bits=8;

  fprintf(stderr,"File offset is %d bytes\n",fileheader.offset);
  fprintf(stderr,"File size (headers + data) is %d bytes\n",fileheader.size);
  
  // FILEHEADER struct has 14 bytes, not a multiple of 4 bytes, but some 
  // machines/compilers assume so and pad this struct by 2 bytes to make it 16,
  // which will unalign the future fwrite() calls. That is why here the components 
  // are written individually.

  // write the fileheader

  if (fwrite(&fileheader.type,sizeof(unsigned short int),1,fp) != 1) {
    fprintf(stderr,"Failed to write BMP fileheader.type\n");
  }
  if (fwrite(&fileheader.size,sizeof(unsigned int),1,fp) != 1) {
    fprintf(stderr,"Failed to write BMP fileheader.size\n");
  }
  if (   fwrite(&fileheader.reserved1,sizeof(unsigned short int),1,fp) != 1
      || fwrite(&fileheader.reserved2,sizeof(unsigned short int),1,fp) != 1) {
    fprintf(stderr,"Failed to write BMP fileheader.size\n");
  }
  if (fwrite(&fileheader.offset,sizeof(unsigned int),1,fp) !=1) {
    fprintf(stderr,"Failed to write BMP fileheader.offset\n");
  }

  infoheader.size=40;
  infoheader.width=N;
  infoheader.height=M;
  infoheader.planes=1;
  infoheader.compression=0;
  infoheader.imagesize=M*N;

  //  infoheader.xresolution, infoheader.yresolution

  printf("bits: %d\n",infoheader.bits);

  // write the information header 
  if (fwrite(&infoheader,sizeof(INFOHEADER),1,fp) != 1) {
    fprintf(stderr,"Failed to write BMP infoheader\n");
    exit(-1);
  }

  if (!color) {  // colortable is still used for grey level images 

    for (i=0; i<infoheader.ncolors; i++) {
      for (j=0; j<4; j++) {
	grey=i;
	if (fwrite(&grey,sizeof(unsigned char),1,fp) != 1) {
	  fprintf(stderr,"Image write failed\n");
	  exit(-1);
	}
      }
    }
  }

  // Seek to the start of the image data 
  printf("Seek, offset=%d\n",fileheader.offset);
  fseek(fp,fileheader.offset,SEEK_SET);

  // write the image 
  for (i=infoheader.height-1; i>=0; i--) {
    for (j=0; j<infoheader.width; j++) {

      switch (infoheader.bits) {
      case 1:
	break;
      case 4:                   // 2^4=16 colors
	break;
      case 8:                   // 2^8=256 colors
	grey=img_grey[i][j];
	if (fwrite(&grey,sizeof(unsigned char),1,fp) != 1) {
	  fprintf(stderr,"Image write failed\n");
	  exit(-1);
	}
	break;
      case 24:                 // 2^24=(2^8)^3=256^3 colors
	r=img_color[0][i][j];
	g=img_color[1][i][j];
	b=img_color[2][i][j];
	if (fwrite(&b,sizeof(unsigned char),1,fp) != 1) {
	  fprintf(stderr,"Image write failed\n");
	  exit(-1);
	}
	if (fwrite(&g,sizeof(unsigned char),1,fp) != 1) {
	  fprintf(stderr,"Image write failed\n");
	  exit(-1);
	}
	if (fwrite(&r,sizeof(unsigned char),1,fp) != 1) {
	  fprintf(stderr,"Image write failed\n");
	  exit(-1);
	}
	//	    printf("(%d %d %d %d %d) ",i,j,r,g,b);
	break;
      }
    } // close j
  }  // close i

  fclose(fp);
  printf("Output file %s written on disk.\n",fname_out);
   
}


float ***read_color_image(fp,M,N)
     FILE *fp;
     int M,N;
{
  int i,j,k;
  float ***temp;
/*
  printf("Color input image.\n");  
*/
  temp=alloc3df(3,M,N);

  for (i=0; i<M; i++)
    for (j=0; j<N; j++)
      for (k=0; k<3; k++)
	temp[k][i][j] = read_byte(fp);
  fclose(fp); 
  return temp;
}

float **read_bw_image(fp,M,N)
     FILE *fp;
     int M,N;
{
  int i,j,k;
  float **temp;
/* 
   printf("Black/white input image.\n");  
*/
  temp=alloc2df(M,N);

  for (i=0; i<M; i++)
    for (j=0; j<N; j++)
      temp[i][j] = read_byte(fp);
  fclose(fp);
  return temp;
}


get_header(fp,width,height,magic)
     int *width, *height;
     char *magic;
     FILE *fp;
{
  char word[10];
  int Max;
  //  printf("get header...\n");

  if (getword(fp,word)!=0) eof_err();
  strcpy(magic,word);

  if ( (strcmp(magic,"P5")!=0) && (strcmp(magic,"P6")!=0) ) 
    {
      fprintf(stderr,"\nBad file type, use raw grayscale (pgm) or raw color (ppm) file.\n");
      exit(0);
    }
  if (getword(fp,word)!=0) eof_err();  *width=atoi(word);
  if (getword(fp,word)!=0) eof_err();  *height=atoi(word);
  if (getword(fp,word)!=0) eof_err();  Max=atoi(word);
}


/**********
 *
 * read_byte() - read a byte of data from a file and check for EOF
 *
 *  arguments - FILE * of file to read from
 *
 *  returns - int value of the byte read
 *
 **********/

int read_byte(fp)
FILE *fp;
{
int cha;

cha=fgetc(fp);
if (cha==EOF) eof_err();

return cha;
}


/********************************************************************************
 *
 * getword() - eliminates whitspace and comments and gets a single word.
 *  arguments: file pointer to read from, initialized char * to place word into
 *  returns:  0 if no end of file
 *           -1 if no word and eof
 *            1 if word then eof
 ********************************************************************************/

int getword(fp, word)  
     FILE *fp;
     char *word;
{              
  int cha=' ';
  int x=0;
  short end=0;

  /* Eliminate White Space and comments (from # to end of line) */
  do {
    cha=fgetc(fp);   
    if (cha=='#') 
      {	do cha=fgetc(fp); while (!(cha=='\n')); }
  }
  while (isspace(cha) && (cha!=EOF));

  if (cha==EOF) return -1;
  /* get chars until a whitespace or End of File*/
  else
    do
      { word[x++]=cha; cha=fgetc(fp); }			/* Get Single Word */
    while ( !(isspace(cha)) && (cha!=EOF) );
  
  /* if end of the file then we are done reading chars */
  if (cha==EOF) end=1;
  
  word[x]='\0';
  return end;  
}

eof_err()
{
  fprintf(stderr, "Unexpected end of file, exiting. \n");
  exit(0);
}