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

int  main (int argc,  char* argv[])
{
	const unsigned char*  pp       = NULL;
	uint32_t              pix      = 0;
	int                   bit      = 0;

	uint8_t               b        = 0;
	uint8_t               bcnt     = 0;

	unsigned int          lcnt     = 0;
	static const int      lmax     = 16;  // max hex values per line

	uint8_t*              buf      = NULL;
	uint8_t*              bp       = NULL;
	unsigned int          blen     = 0;

	uint8_t*              cmp      = NULL;
	uint8_t*              cp       = NULL;
	unsigned int          clen     = 0;
	uint8_t               ctag     = 0xFF;
	uint32_t              tag[256] = {0};
	uint32_t              tmax     = UINT32_MAX;

	unsigned int          x, y, z;

	const char*           name     = argv[1];
	FILE*                 fh       = fopen(argv[2], "wb");

	uint32_t              white    = 0xFF;

	int                   rv       = 0;  // assume success

	// allocate buffers
	blen = ((img.w * img.h) +0x7) >>3;
	bp = (buf = calloc(blen +1, 1));
	cp = (cmp = calloc(blen +4, 1));

	// sanity check
	if (!fh || !buf || !cmp) {
		printf("! fopen() or malloc() fail.\n");
		rv = 255;
		goto bail;
	}

	// Find white value
	for (x = 1;  x < img.bpp;  x++)
		white = (white << 8) | 0xFF ;

	// build bit pattern
	// create the comment as we go
	for (pp = img.b,  y = 0;  y < img.h;  y++) {
		fprintf(fh, "// ");
		for (x = 0;  x < img.w;  x++) {
			// read pixel
			for (pix = 0,  z = 0;  z < img.bpp;  pix = (pix << 8) | *pp++, z++) ;
			// get bit and draw
			if (pix < white) {
				b = (b << 1) | 1;
				fprintf(fh, "##");
			} else {
				b <<= 1;
				fprintf(fh, "..");
			}
			// got byte
			if ((++bcnt) == 8) {
				*bp++ = b;
				tag[b]++;
				bcnt = (b = 0);
			}
		}
		fprintf(fh, "\n");
	}
	fprintf(fh, "\n");
	// padding
	if (bcnt) {
		b <<= (bcnt = 8 - bcnt);
		*bp++ = b;
		tag[b]++;
	}
	// Kill the compression
	*bp = ~bp[-1];  // https://youtube.com/clip/Ugkx-JZIr16hETy7hz_H6yIdKPtxVe8C5w_V

	// Byte run length compression
	// Find a good tag
	for (x = 0;  tmax && (x < 256);  x++) {
		if (tag[x] < tmax) {
			tmax = tag[x];
			ctag = x;
		}
	}

	// compress the data
	for (bp = buf,  x = 0;  (clen < blen) && (x < blen);  x++) {
		// need at least 4 the same to be worth it
		// must compress tag (if it occurs)
		if ((bp[x] == bp[x+1]) && (bp[x] == bp[x+2]) && (bp[x] == bp[x+3]) || (bp[x] == ctag)) {
			for (y = 1;  (y < 255) && (bp[x] == bp[x+y]); y++) ;
			*cp++  = ctag;   // tag
			*cp++  = y;      // length
			*cp++  = bp[x];  // byte
			x     += y -1;
			clen  += 3;
		} else {
			*cp++ = bp[x];
			clen++;
		}
	}

	// create struct
	fprintf(fh, "#include \"images.h\"\n\n");
	fprintf(fh, "const image_t  img_%s = { %d, %d, ", name, img.w, img.h);

	if (clen < blen) {  // dump compressed?
		fprintf(fh, "true, %d, 0x%02X, {  // orig:%d, comp:%.2f%%\n\t", 
		            clen, ctag, blen, 100.0-((clen*100.0)/blen));
		for (x = 0;  x < clen;  x++)
			if (x == clen -1)  fprintf(fh, "0x%02X\n}};\n", cmp[x]) ;
			else               fprintf(fh, "0x%02X%s", cmp[x], (!((x+1)%16)) ? ",\n\t" : ", ") ;

	} else {  // dump UNcompressed
		fprintf(fh, "false, %d, 0, {\n\t", blen);
		for (x = 0;  x < blen;  x++)
			if (x == blen -1)  fprintf(fh, "0x%02X\n}};\n", buf[x]) ;
			else               fprintf(fh, "0x%02X%s", buf[x], (!((x+1)%16)) ? ",\n\t" : ", ") ;
	}

bail:
	if (fh)   fclose(fh) ;
	if (buf)  free(buf) ;
	if (cmp)  free(cmp) ;

	return rv;
}