/*
 * Copyright 2015 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Andrew Lindesay
 */


// This command line program was created in order to be able to render
// HVIF files and then save the resultant bitmap into a PNG image file.
// The tool can be compiled for linux and was initially created for
// use with the Haiku Depot Server application server so that it was
// able to render HVIFs in the web page.

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

#include <png.h>

#include <Bitmap.h>
#include <IconUtils.h>
#include <InterfaceDefs.h>
#include <SupportDefs.h>

#include <AutoDeleter.h>


#define SIZE_HVIF_BUFFER_STEP 1024


static const uint8 kHvifMagic[] = { 'n', 'c', 'i', 'f' };


typedef struct h2p_hvif_buffer {
	uint8*	buffer;
	size_t	used;
	size_t	allocated;
} h2p_hvif_buffer;


typedef struct h2p_parameters {
	int		size;
	char*	in_filename;
	char*	out_filename;
} h2p_parameters;


typedef struct h2p_state {
	FILE*			in;
	FILE*			out;
	BBitmap*		bitmap;
	h2p_hvif_buffer	hvif_buffer;
	h2p_parameters	params;
} h2p_state;


static int
h2p_fprintsyntax(FILE* stream)
{
	return fprintf(stream, "syntax: hvif2png -s <size> [-i <input-file>]"
		" [-o <output-file>]\n");
}


static void
h2p_close_state(h2p_state* state)
{
	if (state->hvif_buffer.buffer != NULL)
		free(state->hvif_buffer.buffer);

	if (state->in != NULL) {
		if (state->in != stdin)
			fclose(state->in);
		state->in = NULL;
	}

	if (state->out != NULL) {
		if (state->out != stdout)
			fclose(state->out);
		state->out = NULL;
	}
}


/*! Opens the input and output streams for the conversion.
    \return false if there was some problem in opening the streams; otherwise
    	true.
*/
static bool
h2p_open_streams(h2p_state* state)
{
	CObjectDeleter<h2p_state, void, &h2p_close_state> stateCloser(state);

	if (state->params.in_filename != NULL)
		state->in = fopen(state->params.in_filename, "rb");
	else
		state->in = stdin;

	if (state->in == NULL) {
		fprintf(stderr, "unable to open the input file; '%s'\n",
			state->params.in_filename);
		return false;
	}

	if (state->params.out_filename != NULL)
		state->out = fopen(state->params.out_filename, "wb");
	else
		state->out = stdout;

	if (state->out == NULL) {
		fprintf(stderr, "unable to open the output file; '%s'\n",
			state->params.out_filename);
		return false;
	}

	stateCloser.Detach();

	return true;
}


static bool
h2p_write_png(BBitmap* bitmap, FILE* out)
{
	png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL,
		NULL);

	if (png == NULL) {
		fprintf(stderr, "unable to setup png write data structures\n");
		return false;
	}

	png_init_io(png, out);
	png_infop info = png_create_info_struct(png);

	bool result = false;

	if (info != NULL) {
		BRect rect = bitmap->Bounds();
		png_uint_32 width = (png_uint_32)rect.Width() + 1;
		png_uint_32 height = (png_uint_32)rect.Height() + 1;

		png_set_IHDR(png, info, width, height, 8, PNG_COLOR_TYPE_RGBA,
			PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE,
			PNG_FILTER_TYPE_BASE);

		png_set_bgr(png);

		png_write_info(png, info);

		uint8 *bitmapData = (uint8*)bitmap->Bits();
		int32 bitmapBytesPerRow = bitmap->BytesPerRow();

		for (png_uint_32 i = 0; i < height; i++) {
			png_write_row(png,
				(png_bytep)&bitmapData[i * bitmapBytesPerRow]);
		}

		png_write_end(png, NULL);

		png_free_data(png, info, PNG_FREE_ALL, -1);

		result = true;
	} else
		fprintf(stderr, "unable to setup png info data structures\n");

	png_destroy_write_struct(&png, (png_infopp)NULL);

	return result;
}


/*! Reads the HVIF input data from the supplied input file.
    \return the quantity of bytes that were read from the
    	HVIF file or 0 if there was a problem reading the HVIF data.
*/
static size_t
h2p_read_hvif_input(h2p_hvif_buffer* result, FILE* in)
{
	result->buffer = (uint8*)malloc(SIZE_HVIF_BUFFER_STEP);
	result->allocated = SIZE_HVIF_BUFFER_STEP;
	result->used = 0;

	if (result->buffer == NULL) {
		fprintf(stderr,"out of memory\n");
		return 0;
	}

	while (!feof(in)) {
		if (result->used == result->allocated) {
			result->buffer = (uint8 *)realloc(result->buffer,
				result->allocated + SIZE_HVIF_BUFFER_STEP);

			if (result->buffer == NULL) {
				fprintf(stderr,"out of memory\n");
				return 0;
			}

			result->allocated += SIZE_HVIF_BUFFER_STEP;
		}

		result->used += fread(&result->buffer[result->used], sizeof(uint8),
			result->allocated - result->used, in);

		int err = ferror(in);

		if (err != 0) {
			fprintf(stderr, "error reading input; %s\n", strerror(err));
			return 0;
		}
	}

	if (result->used < 4) {
		fprintf(stderr, "the hvif data is too small to visably be valid\n");
		return 0;
	}

	// hvif files have a magic string of "ncif" so we should check for that as
	// well.

	if (memcmp(result->buffer, kHvifMagic, 4) != 0) {
		fprintf(stderr, "the input data does not look like hvif because the"
			" magic string is not 'ncif'; %d, %d, %d, %d\n",
			result->buffer[0], result->buffer[1], result->buffer[2],
			result->buffer[3]);
		return 0;
	}

	return result->used;
}


/*! Parse the arguments to the conversion program from the command line.
		\return false if there was a problem reading the parameters and true
    	otherwise.
*/
static bool
h2p_parse_args(h2p_parameters* result, int argc, char* argv[])
{
	for (int i = 1;i < argc;) {
		if (argv[i][0] != '-') {
			fprintf(stderr, "was expecting a switch; found '%s'\n",argv[i]);
			h2p_fprintsyntax(stderr);
			return false;
		}

		if (strlen(argv[i]) != 2) {
			fprintf(stderr, "illegal switch; '%s'\n", argv[i]);
			h2p_fprintsyntax(stderr);
			return false;
		}

		switch (argv[i][1]) {
			case 's':
				if (i == argc - 1) {
					fprintf(stderr,"the size has not been specified\n");
					h2p_fprintsyntax(stderr);
					return false;
				}

				result->size = atoi(argv[i + 1]);

				if (result->size <= 0 || result->size > 8192) {
					fprintf(stderr,"bad size specified; '%s'\n", argv[i + 1]);
					h2p_fprintsyntax(stderr);
					return false;
				}

				i+=2;
				break;

			case 'i':
				if (i == argc - 1) {
					fprintf(stderr,
						"the input filename has not been specified\n");
					h2p_fprintsyntax(stderr);
					return false;
				}

				result->in_filename = argv[i + 1];
				i+=2;
				break;

			case 'o':
				if (i == argc - 1) {
					fprintf(stderr,
						"the output filename has not been specified\n");
					h2p_fprintsyntax(stderr);
					return false;
				}

				result->out_filename = argv[i + 1];
				i += 2;
				break;

			default:
				fprintf(stderr, "unrecognized switch; '%s'\n", argv[i]);
				h2p_fprintsyntax(stderr);
				return false;
		}
	}

	if (result->size == 0) {
		fprintf(stderr, "size has not been specified\n");
		h2p_fprintsyntax(stderr);
		return false;
	}

	return true;
}


int
main(int argc, char* argv[])
{
	if (argc == 1) {
		h2p_fprintsyntax(stderr);
		return 1;
	}

	h2p_state state;
	bzero(&state, sizeof(state));

	if (!h2p_parse_args(&state.params, argc, argv))
		return 1;

	if (!h2p_open_streams(&state))
		return 1;

	int exitResult = 1;

	if (h2p_read_hvif_input(&state.hvif_buffer, state.in) > 0) {
		// create the bitmap and then parse and render the HVIF icon
		// data into the bitmap.

		state.bitmap = new BBitmap(
			BRect(0.0, 0.0, state.params.size - 1,
				state.params.size - 1),
			B_RGBA32); // actual storage is BGRA

		status_t gviStatus = BIconUtils::GetVectorIcon(
			state.hvif_buffer.buffer,
			state.hvif_buffer.used,
			state.bitmap);

		if (gviStatus != B_OK) {
			fprintf(stderr, "the hvif data (%zdB) was not able to "
				"be parsed / rendered\n", state.hvif_buffer.used);
		} else {
			// write the bitmap data out again as a PNG.
			if (h2p_write_png(state.bitmap, state.out))
				exitResult = 0;
		}
	}

	// clean up
	h2p_close_state(&state);

	return exitResult;
}