#include "hvif-light.h"

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

enum
{
	STYLE_TYPE_SOLID_COLOR = 1,
	STYLE_TYPE_GRADIENT = 2,
	STYLE_TYPE_SOLID_COLOR_NO_ALPHA = 3,
	STYLE_TYPE_SOLID_GRAY = 4,
	STYLE_TYPE_SOLID_GRAY_NO_ALPHA = 5,

	SHAPE_TYPE_PATH_SOURCE = 10,

	TRANSFORMER_TYPE_AFFINE = 20,
	TRANSFORMER_TYPE_CONTOUR = 21,
	TRANSFORMER_TYPE_PERSPECTIVE = 22,
	TRANSFORMER_TYPE_STROKE = 23,
};

enum
{
	GRADIENT_FLAG_TRANSFORM = 1 << 1,
	GRADIENT_FLAG_NO_ALPHA = 1 << 2,
	GRADIENT_FLAG_16_BIT_COLORS = 1 << 3, /* not yet used */
	GRADIENT_FLAG_GRAYS = 1 << 4,
};

enum
{
	PATH_FLAG_CLOSED = 1 << 1,
	PATH_FLAG_USES_COMMANDS = 1 << 2,
	PATH_FLAG_NO_CURVES = 1 << 3,
};

enum
{
	PATH_COMMAND_H_LINE = 0,
	PATH_COMMAND_V_LINE = 1,
	PATH_COMMAND_LINE = 2,
	PATH_COMMAND_CURVE = 3,
};

enum
{
	SHAPE_FLAG_TRANSFORM = 1 << 1,
	SHAPE_FLAG_HINTING = 1 << 2,
	SHAPE_FLAG_LOD_SCALE = 1 << 3,
	SHAPE_FLAG_HAS_TRANSFORMERS = 1 << 4,
	SHAPE_FLAG_TRANSLATION = 1 << 5,
};

#define ERROR_RESULT(E) \
	(hvif_result) { .status = E }
#define SUCCESS_RESULT(I) \
	(hvif_result) { .status = SUCCESS, .image = I }

#define le_read(V, BUFFER) V = _Generic((V), uint32_t : le_read_uint32)(BUFFER)
static inline uint32_t
le_read_uint32(char buffer[static 1])
{
	return (buffer[0] << 0) | (buffer[1] << 8) | (buffer[2] << 16) |
		(buffer[3] << 24);
}

typedef uint32_t hvif_color; /* 8bit each: alpha, blue, green, red */
#define COLOR_GET_RED(C) (C & 0xff)
#define COLOR_GET_GREEN(C) ((C >> 8) & 0xff)
#define COLOR_GET_BLUE(C) ((C >> 16) & 0xff)
#define COLOR_GET_ALPHA(C) ((C >> 24) & 0xff)
#define _BM8(N) (0xff << N)
#define COLOR_SET_RED(C, V) (C = ((C & (~_BM8(0))) | (V & 0xff)))
#define COLOR_SET_GREEN(C, V) (C = ((C & (~_BM8(8))) | ((V & 0xff) << 8)))
#define COLOR_SET_BLUE(C, V) (C = ((C & (~_BM8(16))) | ((V & 0xff) << 16)))
#define COLOR_SET_ALPHA(C, V) (C = ((C & (~_BM8(24))) | ((V & 0xff) << 24)))
#define COLOR_SET_RGB(C, R, G, B) \
	(C = (C & (~0xffffff)) | (R & 0xff) | ((G & 0xff) << 8) | ((B & 0xff) << 16))

typedef struct hvif_style hvif_style;
struct hvif_style
{
	signed gradient_type;
	uint8_t stops;
	hvif_color* colors;
	float* offsets;
};

struct hvif_image
{
	uint8_t num_styles;
	hvif_style* styles;
};

hvif_color
read_color(char* buffer, bool gray, bool alpha)
{
	/* On disk a color is:
	 	   red, green, blue, alpha
	 	 Hence reading this as a (little-endian) uint32 result in the desired
	 	 format. If `alpha` is `false` then only three bytes are used and alpha
	 	 is `0xff`. If gray is `true` only one one byte is used for the three
	 	 colors.
	 */
	hvif_color c = 0;
	if (alpha) {
		if (gray) {
			COLOR_SET_RGB(c, buffer[0], buffer[0], buffer[0]);
			COLOR_SET_ALPHA(c, buffer[1]);
		} else {
			le_read(c, buffer);
		}
	} else {
		COLOR_SET_ALPHA(c, 0xff);
		if (gray) {
			COLOR_SET_RGB(c, buffer[0], buffer[0], buffer[0]);
		} else {
			COLOR_SET_RGB(c, buffer[0], buffer[1], buffer[2]);
		}
	}
	return c;
}

hvif_status
read_color_style(hvif_style* style, char* buffer, bool gray, bool alpha)
{
	hvif_color color = read_color(buffer, gray, alpha);
	style->colors = calloc(1, sizeof(hvif_color));
	style->offsets = calloc(1, sizeof(float));
	if (!style->colors || !style->colors) return ERROR_NOMEM;

	style->colors[0] = color;
	style->offsets[0] = 1.0; /* TODO: Is this ok for solid colors */
	return SUCCESS;
}

hvif_status
read_style(FILE* file, hvif_style* style)
{
	uint8_t type;
	if (fread(&type, 1, 1, file) != 1) { return ERROR_STYLE; }
	char buffer[4];
	switch (type) {
		case STYLE_TYPE_SOLID_COLOR:
			if (fread(buffer, 1, 4, file) != 4) { return ERROR_EOF; }
			read_color_style(style, buffer, false, true);
			break;
		case STYLE_TYPE_GRADIENT: break;
		case STYLE_TYPE_SOLID_COLOR_NO_ALPHA:
			if (fread(buffer, 1, 3, file) != 3) { return ERROR_EOF; }
			read_color_style(style, buffer, false, false);
			break;
		case STYLE_TYPE_SOLID_GRAY:
			if (fread(buffer, 1, 2, file) != 2) { return ERROR_EOF; }
			read_color_style(style, buffer, true, true);
			break;
		case STYLE_TYPE_SOLID_GRAY_NO_ALPHA:
			if (fread(buffer, 1, 1, file) != 1) { return ERROR_EOF; }
			read_color_style(style, buffer, true, false);
			break;
		default: return ERROR_STYLE;
	}
	return SUCCESS;
}

hvif_result
hvif_from_file(FILE* file)
{
	uint32_t const magic = 0x6669636e; /* 'finc' (on disk little endian 'cnif') */

	char magic_buffer[4];
	if (fread(magic_buffer, 1, 4, file) != 4) { return ERROR_RESULT(ERROR_EOF); }
	uint32_t read_magic;
	le_read(read_magic, magic_buffer);
	if (read_magic != magic) { return ERROR_RESULT(ERROR_MAGIC); }

	hvif_image* image = calloc(1, sizeof(hvif_image));
	if (!image) return ERROR_RESULT(ERROR_NOMEM);

	uint8_t num_styles;
	if (fread(&num_styles, 1, 1, file) != 1) {
		hvif_free(image);
		return ERROR_RESULT(ERROR_EOF);
	}
	image->styles = calloc(num_styles, sizeof(hvif_style));
	if (!image->styles) {
		hvif_free(image);
		return ERROR_RESULT(ERROR_NOMEM);
	}
	for (unsigned i = 0; i < image->num_styles; ++i) {
		hvif_status s = read_style(file, &image->styles[i]);
		if (s != SUCCESS) {
			hvif_free(image);
			return ERROR_RESULT(s);
		}
	}

	return SUCCESS_RESULT(image);
}

void
hvif_free(hvif_image* image)
{
	for (unsigned i = 0; i < image->num_styles; ++i) {
		free(image->styles[i].colors);
		free(image->styles[i].offsets);
	}
	free(image->styles);
	free(image);
}