/*

 * avatar.c             -- Pep avatar events

 *

 * Copyrigth (C) 2009      Myhailo Danylenko <isbear@ukrpost.net>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or (at

 * your option) any later version.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

 * USA

 */

#define PNG_USER_MEM_SUPPORTED

#include <glib.h>

#include <gmodule.h>

#include <loudmouth/loudmouth.h>

#include <aalib.h>

#include <png.h>

#include <string.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdlib.h>

#include <errno.h>

#include "compl.h"

#include "commands.h"

#include "utils.h"

#include "xmpp.h"

#include "screen.h"

#include "hbuf.h"

#include "hooks.h"

#include "settings.h"

#include "pep.h"

#define NS_AVATAR_DATA            ( "urn:xmpp:avatar:data"            )

#define NS_AVATAR_METADATA        ( "urn:xmpp:avatar:metadata"        )

#define NS_AVATAR_METADATA_NOTIFY ( "urn:xmpp:avatar:metadata+notify" )

static guint avatar_cid = 0;

GSList *reply_handlers = NULL;

// png stuff

static png_voidp png_glib_malloc (png_structp ignore, png_size_t size)

{

	return g_malloc (size);

}

static void png_glib_free (png_structp ignore, png_voidp chunk)

{

	g_free (chunk);

}

// reads file and returns array of pointers to image rows in

// after use just do g_free of this pointer - all data are in one memory chunk

{

	FILE        *fd       = fopen (file, "rb");

	png_infop    info_ptr;

	png_structp  png_ptr;

	int          rowbytes;

	png_bytep   *row_pointers;

	int          width;

	int          height;

	if (!fd)

		return NULL;

	{ // check signature

		char header[8];

		fread (header, 1, 8, fd);

		if (png_sig_cmp (header, 0, 8)) {

			fclose (fd);

			return NULL;

		}

	}

	// initialize reader

	png_ptr = png_create_read_struct_2 (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL, NULL, png_glib_malloc, png_glib_free);

	if (!png_ptr) {

		fclose (fd);

		return NULL;

	}

	info_ptr = png_create_info_struct (png_ptr);

	if (!info_ptr) {

		png_destroy_read_struct (&png_ptr, NULL, NULL);

		fclose (fd);

		return NULL;

	}

	if (setjmp (png_jmpbuf (png_ptr))) {

		png_destroy_read_struct (&png_ptr, &info_ptr, NULL);

		fclose (fd);

		return NULL;

	}

	png_init_io (png_ptr, fd);

	png_set_sig_bytes (png_ptr, 8);

	// get information

	png_read_info (png_ptr, info_ptr);

	{ // set up transformations

		png_byte color_type = info_ptr->color_type;

		png_byte bit_depth  = info_ptr->bit_depth;

			png_set_palette_to_rgb (png_ptr);

		if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)

			png_set_expand_gray_1_2_4_to_8 (png_ptr);

		if (bit_depth == 16)

			png_set_strip_16 (png_ptr);

		if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))

			png_set_tRNS_to_alpha (png_ptr);

			png_set_rgb_to_gray_fixed (png_ptr, 1, -1, -1);

		// renew information in info structure

		png_read_update_info (png_ptr, info_ptr);

	}

	width    = info_ptr->width;

	height   = info_ptr->height;

	rowbytes = info_ptr->rowbytes;

	{ // allocate buffer for image data

		png_bytep chunk = g_malloc ((sizeof(png_bytep) + rowbytes) * height);

		png_bytep start = chunk + sizeof(png_bytep) * height;

		int       y;

		row_pointers = (png_bytep *) chunk;

		for (y = 0; y < height; ++y)

			row_pointers[y] = start + y * rowbytes;

	}

	// read image

	if (setjmp (png_jmpbuf (png_ptr))) {

		g_free (row_pointers);

		png_destroy_read_struct (&png_ptr, &info_ptr, NULL);

		fclose (fd);

		return NULL;

	}

	png_read_image (png_ptr, row_pointers);

	png_read_end (png_ptr, NULL);

	// free resources

	png_destroy_read_struct (&png_ptr, &info_ptr, NULL); 

	fclose (fd);

	*rheight = height;

	*rwidth  = width;

	return row_pointers;

}

// aa stuff

// converts image in format, returned by png_read_file into ascii,

// scaling it to fit specified max values. If font parameters are

// set properly, should result in image on screen with original png

// aspect ratio.

static gchar *aa_convert_image (png_bytep *row_pointers, int height, int width, int maxcharh, int maxcharw, int fonth, int fontw)

{

	gchar                     *result;

	struct aa_hardware_params  hwparams = {

		.font      = NULL,

		.supported = AA_NORMAL_MASK,

		.width     = 0,

		.height    = 0,

	};

	// params for zooming

	int finalcharh;

	int finalcharw;

	int finalh;

	int finalw;

	int starty;

	int startx;

	int finalratioh;

	int finalratiow;

	// process aa parameters from environment variables

	aa_parseoptions (&hwparams, NULL, NULL, NULL);

	{ // calculate parameters for image zooming into aa surface

	  // this always makes me a hard time, thus such a mess :/

	  // I hope, compiler will optimize out all these variables...

		// font size in font pixels (real?)

		//int fonth = 16;

		//int fontw = 8;

		float fontaspect = (float) fontw / fonth;

		// aa pixels per character

		const int aappch = 2;

		const int aappcw = 2;

		const float aaaspect = (float) aappcw / aappch;

		// font pixels per aa pixel

		int aappph = (float) fonth / aappch;

		int aapppw = (float) fontw / aappcw;

		float aapixelaspect = (float) aapppw / aappph;

		// original image size in real pixels

		int originh = height;

		int originw = width;

		float originaspect = (float) originw / originh;

		// maximal resulting image size in chars

		//int maxcharh = res_height;

		//int maxcharw = res_width;

		// maximal resulting image size in aa pixels

		int maxh = maxcharh * aappch;

		int maxw = maxcharw * aappcw;

		// maximal resulting image size in real pixels

		int maxh_rp;

		int maxw_rp;

		if (aapixelaspect > 1) {

			maxh_rp = maxh;

			maxw_rp = (float) maxw * aapixelaspect;

		} else {

			maxh_rp = (float) maxh / aapixelaspect;

			maxw_rp = maxw;

		}

		float maxaspect_rp = (float) maxw_rp / maxh_rp;

		// resulting image size in real pixels

		float ratio_rp;

		int resh_rp;

		int resw_rp;

		if (originh > maxh_rp || originw > maxw_rp) {

			// boundaries crossed, will zoom

			if (originaspect > maxaspect_rp) {

				// width is bigger

				ratio_rp = (float) maxw_rp / originw;

				resh_rp = (float) originh * ratio_rp;

				resw_rp = maxw_rp;

			} else {

				// height is bigger

				ratio_rp = (float) maxh_rp / originh;

				resh_rp = maxh_rp;

				resw_rp = (float) originw * ratio_rp;

			}

		} else {

			// image fits, no zooming

			ratio_rp = 1;

			resh_rp = originh;

			resw_rp = originw;

		}

		// resulting image size in aa pixels

		int resh;

		int resw;

		if (aapixelaspect > 1) {

			resh = resh_rp;

			resw = (float) resw_rp / aapixelaspect;

		} else {

			resh = (float) resh_rp * aapixelaspect;

			resw = resw_rp;

		}

		// number of original image pixels per one resulting image pixel

		int ratioh = (float) originh / resh;

		int ratiow = (float) originw / resw;

		// resulting image size in chars

		int rescharh = (float) resh / aappch;

		int rescharw = (float) resw / aappcw;

		// re-calculate parameters, as they may change due to rounding (?)

		finalcharh = rescharh;

		finalcharw = rescharw;

		finalh = rescharh * aappch;

		finalw = rescharw * aappcw;

		int finalh_rp;

		int finalw_rp;

		if (aapixelaspect > 1) {

			finalh_rp = finalh;

			finalw_rp = (float) finalw * aapixelaspect;

		} else {

			finalh_rp = (float) finalh / aapixelaspect;

			finalw_rp = finalw;

		}

		finalratioh = (float) originh / finalh;

		finalratiow = (float) originw / finalw;

		// center image part actually used

		int areah = (float) finalh * finalratioh;

		int areaw = (float) finalw * finalratiow;

		int losth = originh - areah;

		int lostw = originw - areaw;

		starty = losth / 2;

		startx = lostw / 2;

	}

	// create aa image

	hwparams.height = finalcharh;

	hwparams.width  = finalcharw;

	aa_context *context = aa_init (&mem_d, &hwparams, NULL);

	if (context == NULL)

		return NULL;

	{ // fill aa image from png buffer with scaling

		height = aa_imgheight (context);

		width  = aa_imgwidth (context);

		if (height > finalh)

			height = finalh;

		if (width > finalw)

			width = finalw;

		for (y = 0;  y < height; ++y) {

			int x;

			for (x = 0; x < width; ++x) {

				png_bytep    *row_pointer = row_pointers + starty + y * finalratioh;

				unsigned int  color = 0;

				unsigned int  cy;

				// just arithmetic average

				for (cy = 0; cy < finalratioh; ++cy) {

					int       cx;

					for (cx = 0; cx < finalratiow; ++cx)

				}

				color /= finalratioh * finalratiow;

				aa_putpixel (context, x, y, color);

			}

		}

	}

	// render ascii image

	aa_render (context, &aa_defrenderparams, 0, 0, aa_scrwidth (context), aa_scrheight (context));

	aa_flush (context);

	{ // format the result

		char    *text   = aa_text (context);

		int      width  = aa_scrwidth (context);

		int      height = aa_scrheight (context);

		GString *avatar = g_string_new (NULL);

		char    *end    = text + width * height;

		while (text < end) {

			g_string_append_len (avatar, text, width);

			g_string_append_c (avatar, '\n');

			text += width;

		}

		// strip last '\n'

		g_string_truncate (avatar, avatar->len - 1);

		result = g_string_free (avatar, FALSE);

	}

	// free resources

	aa_close (context);

	return result;

}

// avatar stuff

// returns filename to save this avatar. NULL on error. g_free result.

static gchar *avatar_id_filename (const gchar *id)

{

	gchar *escid = g_strdup (id);

	gchar *dir   = (gchar *) settings_opt_get ("avatar_directory");

	gchar *file;

	if (!dir)

		return NULL;

	{ // neutralize id

		const gchar *valid = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

		g_strcanon (escid, valid, '_');

	}

	dir = expand_filename (dir);

	file = g_strdup_printf ("%s/%s.png", dir, escid);

	g_free (dir);

	g_free (escid);

	return file;