/*
 *	Copyright (c) 2024 Scott Duensing, scott@kangaroopunch.com
 *
 *	Permission is hereby granted, free of charge, to any person obtaining a copy
 *	of this software and associated documentation files (the "Software"), to deal
 *	in the Software without restriction, including without limitation the rights
 *	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 *	copies of the Software, and to permit persons to whom the Software is
 *	furnished to do so, subject to the following conditions:
 *
 *	The above copyright notice and this permission notice shall be included in
 *	all copies or substantial portions of the Software.
 *
 *	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 *	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 *	SOFTWARE.
 */


#include <stdio.h>
#include <stdbool.h>

#define STB_IMAGE_IMPLEMENTATION
#include "../shared/stb_image.h"

#include "../shared/util.h"


int writeImage(byte *data, int imageWidth, colorT *palette, int colors, char *filename, int xs, int ys, int width, int height) {
	int     x;
	int     y;
	int     n;
	int     a;
	colorT  c;
	FILE   *out;

	printf("Writing %dx%d indexed image %s...\n", width, height, filename);
	out = fopen(filename, "wb");
	if (out == NULL) {
		printf("Unable to write %s.  Aborting.\n", filename);
		return 5;
	}
	for (y=ys; y<ys+height; y++) {
		for (x=xs; x<xs+width; x++) {
			a = (y * imageWidth * 3) + (x * 3);
			c.r = data[a++];
			c.g = data[a++];
			c.b = data[a++];
			for (n=0; n<colors; n++) {
				if ((palette[n].r == c.r) && (palette[n].g == c.g) && (palette[n].b == c.b)) {
					fputc(n, out);
					break;
				}
			}
			// This should never happen.
			if (n == colors) {
				printf("Color (%d, %d, %d) not found at %dx%d!  Aborting.\n", c.r, c.g, c.b, x, y);
				printf("Palette:\n");
				for (n=0; n<colors; n++) {
					printf("Color %d = (%d, %d, %d)\n", n, palette[n].r, palette[n].g, palette[n].b);
				}
				return 9;
			}
		}
	}
	fclose(out);

	return 0;
}


int main(int argc, char *argv[]) {
	int     x;
	int     y;
	int     w;
	int     h;
	int     i;
	int     j;
	int     n;
	int     colors     = 0;
	byte    found;
	byte   *data;
	byte   *p;
	byte    spriteSize = 0;
	colorT  c;
	colorT  palette[256];
	char   *filename;
	char   *temp;
	FILE   *out;
	char   *inputImage;
	char   *outputType;
	bool    okay;

	if (argc < 3 || argc > 4) {
		printf("Usage:  %s [type] [imagefile]\n", argv[0]);
		printf("Where: [type] is the output type:\n");
		printf("       - image   (creates CLUT and indexed image)\n");
		printf("       - sprite  (creates CLUT and indexed sprites)\n");
		return 1;
	}

	outputType = argv[1];
	inputImage = argv[2];

	// Are we making sprites?
	if (utilStricmp(outputType, "sprite") == 0) {
		okay = false;
		if (argc == 4) {
			inputImage = argv[3];
			spriteSize = atoi(argv[2]);
			if (spriteSize == 8 || spriteSize == 16 || spriteSize == 24 || spriteSize == 32) {
				okay = true;
			}
		}
		if (!okay) {
			printf("Usage:  %s sprite [size] [imagefile]\n", argv[0]);
			printf("Where: [size] is 8, 16, 24, or 32\n");
			return 6;
		}
	}

	// Load image, check for valid size.
	data = stbi_load(inputImage, &w, &h, &n, 3);
	if (data == NULL) {
		printf("Unable to load %s!\n", inputImage);
		return 2;
	}
	if (spriteSize > 0) {
		// Sprites must be multiples of 8, 16, 24, or 32.
		okay = false;
		if (((int)(w /  8) == (w /  8.0)) && ((int)(h /  8) == (h /  8.0))) okay = true;
		if (((int)(w / 16) == (w / 16.0)) && ((int)(h / 16) == (h / 16.0))) okay = true;
		if (((int)(w / 24) == (w / 24.0)) && ((int)(h / 24) == (h / 24.0))) okay = true;
		if (((int)(w / 32) == (w / 32.0)) && ((int)(h / 32) == (h / 32.0))) okay = true;
		if (!okay) {
			printf("Height and width must be divisible 8, 16, 24, or 32!\n");
			return 8;
		}
	} else {
		// Images are more lax - we'll let anything of the right width through.
		if (w != 320) {
			free(data);
			printf("Images must be 320 pixels in width!\n");
			return 7;
		}
	}

	// Build palette.
	printf("Building palette...\n");
	p = data;
	for (y=0; y<h; y++) {
		for (x=0; x<w; x++) {
			c.r = *p++;
			c.g = *p++;
			c.b = *p++;
			found = 0;
			for (n=0; n<colors; n++) {
				if ((palette[n].r == c.r) && (palette[n].g == c.g) && (palette[n].b == c.b)) {
					found = 1;
					break;
				}
			}
			if (found == 0) {
				palette[colors].r = c.r;
				palette[colors].g = c.g;
				palette[colors].b = c.b;
				colors++;
				if (colors > 256) {
					free(data);
					printf("More than 256 colors in the image.  Aborting.\n");
					return 3;
				}
			}
		}
	}

	// Write out F256 CLUT.
	filename = utilReplaceExtension(inputImage, ".clut");
	printf("Writing %d color palette %s...\n", colors, filename);
	out = fopen(filename, "wb");
	if (out == NULL) {
		printf("Unable to write %s.  Aborting.\n", filename);
		free(data);
		free(filename);
		return 4;
	}
	for (n=0; n<colors; n++) {
		fputc(palette[n].b, out);
		fputc(palette[n].g, out);
		fputc(palette[n].r, out);
		fputc(0xff, out);
	}
	fclose(out);
	free(filename);

	if (spriteSize == 0) {
		// Write out raw indexed image.
		filename = utilReplaceExtension(inputImage, ".indexed");
		n = writeImage(data, w, palette, colors, filename, 0, 0, w, h);
		free(filename);
		if (n != 0) {
			free(data);
			return n;
		}
	} else {
		// Split image into multiple sprite images.
		temp = utilReplaceExtension(inputImage, "");
		i = 1;
		j = 1;
		for (y=0; y<h; y+=spriteSize) {
			for (x=0; x<w; x+=spriteSize) {
				filename = utilCreateString("%s-%dx%d.indexed", temp, i++, j);
				printf("Writing from %dx%d to %dx%d for %d bytes\n", x, y, x+spriteSize, y+spriteSize, spriteSize*spriteSize);
				n = writeImage(data, w, palette, colors, filename, x, y, spriteSize, spriteSize);
				free(filename);
				if (n != 0) {
					free(temp);
					free(data);
					return n;
				}
			}
			i = 1;
			j++;
		}
		free(temp);
	}

	free(data);

	printf("Finished!\n");

	return 0;
}