/*

 * 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 <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 <mcabber/compl.h>

#include <mcabber/commands.h>

#include <mcabber/utils.h>

#include <mcabber/xmpp.h>

#include <mcabber/screen.h>

#include <mcabber/hbuf.h>

#include <mcabber/hooks.h>

#include <mcabber/settings.h>

#include <mcabber/modules.h>

#include <mcabber/xmpp_helper.h>

#include <mcabber/pep.h>

#include "config.h"

// module description

static void avatar_init   (void);

static void avatar_uninit (void);

#define DESCRIPTION ( \

	"PEP avatars handling\n" \

	"Recognizes options avatar_directory, avatar_font_height, avatar_font_width, avatar_max_height, avatar_max_width and avatar_background\n" \

	"Provides command /avatar" )

static const gchar *deps[] = { "pep", NULL };

static module_info_t info_avatar_experimental = {

	.branch      = "experimental",

	.api         = 28,

	.version     = PROJECT_VERSION,

	.description = DESCRIPTION,

	.requires    = deps,

	.init        = avatar_init,

	.uninit      = avatar_uninit,

	.next        = NULL,

};

static module_info_t info_avatar_dev = {

	.branch      = "dev",

	.api         = 13,

	.version     = PROJECT_VERSION,

	.description = DESCRIPTION,

	.requires    = deps,

	.init        = avatar_init,

	.uninit      = avatar_uninit,

	.next        = &info_avatar_experimental,

};

module_info_t info_avatar = {

	.branch      = "0.10.0",

	.api         = 1,

	.version     = PROJECT_VERSION,

	.description = DESCRIPTION,

	.requires    = deps,

	.init        = avatar_init,

	.uninit      = avatar_uninit,

	.next        = &info_avatar_dev,

};

// globals

#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" )

#ifdef HAVE_CMD_ID

static gpointer avatar_cmid = NULL;

#ifdef HAVE_CMD_SAFE

static gboolean avatar_set_safe = FALSE;

#endif

#endif

static guint avatar_hid_connect    = 0;

static guint avatar_hid_disconnect = 0;

static GSList *reply_handlers = NULL;

static LmMessageHandler *avatar_metadata_reply_handler = NULL;

static gboolean  publish_delayed = FALSE;

static gsize     publish_len     = 0;

static guchar   *publish_data    = NULL;

// predeclarations

static LmHandlerResult avatar_retrieve_data_reply_handler (LmMessageHandler *handler, LmConnection *connection, LmMessage *message, gpointer userdata);

// 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

// grayscale 8-bit without alpha-channel format (i.e. one byte per pixel)

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

static png_bytep *png_read_file (const char *file, int *rheight, int *rwidth, png_uint_16 background)

{

	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

		png_byte 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;

		// trying to convert anything to grayscale 8-bit without alpha channel

		if (color_type == PNG_COLOR_TYPE_PALETTE)

			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);

		if (color_type & PNG_COLOR_MASK_COLOR)

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

		if (color_type & PNG_COLOR_MASK_ALPHA) {

			png_color_16 my_background = {

				.red   = background,

				.green = background,

				.blue  = background,

				.gray  = background,

			};

			png_set_background (png_ptr, &my_background, PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);

		}

		// 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

		int height, width;

		int y;

		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