// NOTE: This code doesn't quite work right.  I once wrote a version that wrote jpegs
// using library functions which worked well, but I can no longer find the code.  If
// anyone ever actually shows interest in display of results from mc, hey, let me know -
// I'll write up a neat graphics generator that handles time-progression output and
// various display options (such as assigning different content display to each of R, G, 
// and B).  Just email me at meme@daughtersoftiresias.org.


#include <stdio.h>
#include <stdlib.h>
#include <zlib.h>

#define X_RES_OUT	1000
#define Y_RES_OUT	1000

const unsigned char ON_BIT[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
const unsigned char OFF_BIT[] = { 0xFE, 0xFD, 0xFB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F };

typedef struct BitmapFileHeader {
    char type1;
    char type2;
    unsigned long size;
    unsigned short reserved1;
    unsigned short reserved2;
    unsigned long offBits;
} BitmapFileHeader;

typedef struct BitmapInfoHeader {
    unsigned long size;
    long width;
    long height;
    short planes;
    short bitCount;
    unsigned long compression;
    unsigned long sizeImage;
    long xPelsPerMeter;
    long yPelsPerMeter;
    unsigned long clrUsed;
    unsigned long clrImportant;
} BitmapInfoHeader;

typedef struct BitmapPaletteEntry {
    unsigned char r;
    unsigned char g;
    unsigned char b;
    unsigned char unused;
} BitmapPaletteEntry;

typedef struct BitmapPaletteHeader {
    BitmapPaletteEntry pal[256];
} BitmapPaletteHeader;

int main(int argc, char** argv)
{
    gzFile* gfp;
    FILE* fp;
    unsigned long i,x,y,x2,y2;
    unsigned char* world;
    unsigned long long* world2;
    unsigned long long* counts;
    float version;
    unsigned long x_res, y_res, x_resB;
    unsigned long long steps;
    BitmapFileHeader bf;
    BitmapInfoHeader bi;
    BitmapPaletteHeader bp;
    
    if (argc!=3)
    {
        printf("Error: Requires the filenames of the .sav file and the .bmp file\n");
        return 1;
    }
    
    if (!(gfp=gzopen(argv[1],"r")))
    {
        printf("Error: cannot read input file.\n");
        return 2;
    }
    
    gzread(gfp,&version,4);
    gzread(gfp,&x_res,4);
    gzread(gfp,&y_res,4);
    gzread(gfp,&steps,8);
    x_resB=x_res/8;
    
    printf("Reading %s: Ver=%2.1f, X=%d, Y=%d, Steps=%d\n",argv[1],version,x_res,y_res,steps);
    
    world=malloc(x_res*y_res*sizeof(unsigned char));
    world2=malloc(X_RES_OUT * Y_RES_OUT * sizeof(unsigned long long));
    counts=malloc(X_RES_OUT * Y_RES_OUT * sizeof(unsigned long long));
    
    for (y=0; y<y_res; y++)
    {
       for (x=0; x<x_resB; x++)
       {
           world[x+y*x_resB]=gzgetc(gfp);
       }
    }
    
    for (y=0; y<Y_RES_OUT; y++)
    {
        for (x=0; x<X_RES_OUT; x++)
        {
            world2[x+y*X_RES_OUT]=0;
            counts[x+y*X_RES_OUT]=0;
        }
    }
    
    gzclose(gfp);
    
    if (!(fp=fopen(argv[2],"w")))
    {
        printf("Error: cannot open output file.\n");
        return 3;
    }
    
    printf("Writing %s: %d x %d\n",argv[2],X_RES_OUT,Y_RES_OUT);
    
    bf.type1='B';
    bf.type2='M';
    bf.reserved1=0;
    bf.reserved2=0;
    bf.offBits=sizeof(BitmapFileHeader)+sizeof(BitmapInfoHeader)+sizeof(BitmapPaletteHeader);
    bf.size=X_RES_OUT*Y_RES_OUT+bf.offBits;
    
    bi.size=sizeof(BitmapInfoHeader);
    bi.width=X_RES_OUT;
    bi.height=Y_RES_OUT;
    bi.planes=1;
    bi.bitCount=1;
    bi.compression=0;
    bi.sizeImage=X_RES_OUT*Y_RES_OUT;
    bi.xPelsPerMeter=1000;
    bi.yPelsPerMeter=1000;
    bi.clrUsed=256;
    bi.clrImportant=0;
   
    for (i=0; i<256; i++)
    {
        bp.pal[i].r=i;
        bp.pal[i].g=i;
        bp.pal[i].b=i;
        bp.pal[i].unused=0;
    }
    
    fwrite(&bf,sizeof(BitmapFileHeader),1,fp);
    fwrite(&bi,sizeof(BitmapInfoHeader),1,fp);
    fwrite(&bp,sizeof(BitmapPaletteHeader),1,fp);
    
    printf("%d\n",sizeof(BitmapFileHeader));
    
    for (y=0; y<y_res; y++)
    {
        y2=y*Y_RES_OUT/y_res;
        for (x=0; x<x_res; x++)
        {
            x2=x*X_RES_OUT/x_res;
            world2[x2+y2*X_RES_OUT]+=((world[x/8+y*x_resB]&ON_BIT[x%8])>0);
            counts[x2+y2*X_RES_OUT]++;
        }
    }

    for (y=0; y<Y_RES_OUT; y++)
    {
        for (x=0; x<X_RES_OUT; x++)
        {
            fputc((unsigned char)((world2[x+y*X_RES_OUT] * 256) / counts[x+y*X_RES_OUT]),fp);
        }
    }
    
    fclose(fp);
    
    printf("Done.\n");
}