#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#include "array_utility.h"

// Sample program to convert a limited number of BMP file types
// to a PPM (color) or PGM (grey) image file

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;


int main(int argc,char **argv)
{
  int i,j,k, M,N, color, gotindex = 0;
  unsigned char grey,r,g,b;
  FILEHEADER fileheader;
  INFOHEADER infoheader;
  int **colortable;
  char fname_in[50], *fname_out, *sp;
  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);
  }

  // Read and check the fileheader 
  // 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 fread() calls. That is why here the components 
  // are read individually.

  fread(&fileheader.type,sizeof(unsigned short int),1,fp);   
  fprintf(stderr,"ID is: %d, should be %d\n",fileheader.type,'M'*256+'B');
  if (fileheader.type != 'M'*256+'B') {
    printf("Input file is not in BMP format.\n");
    exit(-1);
  }

  fread(&fileheader.size,sizeof(unsigned int),1,fp);
  fprintf(stderr,"File size is %d bytes\n",fileheader.size);

  fread(&fileheader.reserved1,sizeof(unsigned short int),1,fp);
  fread(&fileheader.reserved2,sizeof(unsigned short int),1,fp);

  fread(&fileheader.offset,sizeof(unsigned int),1,fp);
  
  fprintf(stderr,"Offset to image data is %d bytes\n",fileheader.offset);

  // Read and check the information header 
  if (fread(&infoheader,sizeof(INFOHEADER),1,fp) != 1) {
    fprintf(stderr,"Failed to read BMP info header\n");
    exit(-1);
  }

  N=infoheader.width;
  M=infoheader.height;

  fprintf(stderr,"Infoheader size = %d \n",infoheader.size);
  fprintf(stderr,"Image size = %d x %d\n",infoheader.width,infoheader.height);
  fprintf(stderr,"Number of color planes is %d\n",infoheader.planes);
  fprintf(stderr,"Bits per pixel is %d\n",infoheader.bits);
  fprintf(stderr,"Compression type is %d\n",infoheader.compression);
  fprintf(stderr,"Image size is %d\n",infoheader.imagesize);
  fprintf(stderr,"Resolution, x=%d, y=%d\n",
	  infoheader.xresolution,infoheader.yresolution);
  fprintf(stderr,"Number of colors is %d\n",infoheader.ncolors);
  fprintf(stderr,"Number of required colors is %d\n",
	  infoheader.importantcolors);

  printf("size of fileheader: %d\n",sizeof(FILEHEADER));
  printf("size of infoheader: %d\n",sizeof(INFOHEADER));
    
  color=0;
  // Read color lookup table if there is one 
  //   if (infoheader.ncolors > 0) {
  if (infoheader.bits == 24) {
    printf("bits/pixel=24, color image.\n");
    color=1;
  }
  else if (infoheader.bits < 24) {
    gotindex = 1;
    colortable=alloc2di(infoheader.ncolors,4);
    printf("Color table:\n");
    for (i=0; i<infoheader.ncolors; i++) {
      printf("%3d\t",i);
      for (j=0; j<4; j++) {
	if (fread(&grey,sizeof(unsigned char),1,fp) != 1) 
	  { printf("Image read failed\n"); exit(-1); }
	colortable[i][j]=grey;
	printf("%3d\t",grey);
      }
      printf("\n");
      if (colortable[i][0]!=colortable[i][1] ||
	  colortable[i][0]!=colortable[i][2]   )
	color=1;
    }
  }
  else {
    printf("bits per pixel: %d\n",infoheader.bits);
    pause();
  }
  
  fname_out=fname_in;
  sp=strstr(fname_in,".bmp");

  printf("gotindex=%d\n",gotindex);

  if (color) {
    printf("Color image...\n");
    img_color=alloc3df(3,M,N); 
    if (sp) strcpy(sp,".ppm");
    else strncat(fname_out,".ppm",4);
  }
  else {
    printf("Grey image...\n");
    img_grey=alloc2df(M,N); 
    if (sp) strcpy(sp,".pgm");
    else strncat(fname_out,".pgm",4);
  }

  fseek(fp,fileheader.offset,SEEK_SET);  // Seek to the start of the image data 

  // Read 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:
	break;
      case 8:
	if (fread(&grey,sizeof(unsigned char),1,fp) != 1) {
	  fprintf(stderr,"Image read failed\n");
	  exit(-1);
	}
	//	    printf("(%d %d %d) ",i,j,grey);
	
	if (color) {
	  for (k=0; k<3; k++)
	    img_color[k][i][j]=colortable[grey][k];
	} else {
	  img_grey[i][j]=colortable[grey][0];
	}

	break;
      case 24:
	if (fread(&b,sizeof(unsigned char),1,fp) != 1) {
	  fprintf(stderr,"Image read failed\n");
	  exit(-1);
	}
	if (fread(&g,sizeof(unsigned char),1,fp) != 1) {
	  fprintf(stderr,"Image read failed\n");
	  exit(-1);
	}
	if (fread(&r,sizeof(unsigned char),1,fp) != 1) {
	  fprintf(stderr,"Image read failed\n");
	  exit(-1);
	}
	//	printf("(%d %d %d %d %d) ",i,j,r,g,b);

	img_color[0][i][j]=r;
	img_color[1][i][j]=g;
	img_color[2][i][j]=b;

	break;
      }
    } // close j
  }  // close i

  fclose(fp);
  
  if (color) write_color_image(fname_out,img_color,M,N,1);
  else write_bw_image(fname_out,img_grey,M,N,1);

}


/*
write_grey_image(fname,img,M,N)  // write a grey image in pgm format
     int M,N;
     char *fname;
     float **img;
{
  int i,j,k,l, max=255;
  FILE *fp;

  printf("\nWriting grey image %s (%d x %d) on the disk...\n",fname, N,M);

  if ( (fp = fopen(fname, "w")) == NULL) 
    { fprintf(stderr, "Unable to open file %s for writing, exiting.\n", fname);
      exit(0);
    }
  fprintf(fp,"%s\n%d %d\n%d\n","P5",N,M,max);
  for (i=0; i<M; i++)
    for (j=0; j<N; j++)
      putc( (short)img[i][j], fp);
  fclose(fp);
}

write_color_image(fname,img,M,N)  // write a color image in ppm format
     int M,N;
     char *fname;
     float ***img;
{
  int i,j,k,l, max=255;
  FILE *fp;

  printf("\nWriting color image %s (%d x %d) on the disk...\n",fname, N,M);

  if ( (fp = fopen(fname, "w")) == NULL) 
    { fprintf(stderr, "Unable to open file %s for writing, exiting.\n", fname);
      exit(0);
    }
  fprintf(fp,"%s\n%d %d\n%d\n","P6",N,M,max);
  for (i=0; i<M; i++)
    for (j=0; j<N; j++)
      for (k=0; k<3; k++)
	putc( (short)img[k][i][j], fp);
  fclose(fp);
}
*/