/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* gmime-rfc2047.c: implemention of RFC2047 */

/*
 * Copyright (C) 1999 Bertrand Guiheneuf <Bertrand.Guiheneuf@inria.fr> .
 * 
 * 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
 *
 */

/* 
 * Authors:  Robert Brady <rwb197@ecs.soton.ac.uk>
 */

#include <stdio.h>
#include <ctype.h>
#include <unicode.h>
#include <string.h>

#include "gmime-rfc2047.h"

#define NOT_RANKED -1

/* This should be changed ASAP to use the base64 code Miguel comitted */

const char *base64_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

static unsigned char base64_rank[256];
static int base64_rank_table_built;
static void build_base64_rank_table (void);

static int 
hexval (gchar c) {
	if (isdigit (c)) return c-'0';
	c = tolower (c);
	return c - 'a' + 10;
}

static gchar *
decode_quoted(const gchar *text, const gchar *end) {
	gchar *to = malloc(end - text + 1), *to_2 = to;
        if (!to) return NULL;
	while (*text && text < end) {
		if (*text == '=') {
			gchar a = hexval (text[1]);
			gchar b = hexval (text[2]);
			int c = (a << 4) + b;
			*to = c;
			to++;
			text+=3;
		} else if (*text == '_') {
			*to = ' ';
			to++;
			text++;
		} else {
			*to = *text;
			to++;
			text++;
		}
	}
	return to_2;
}

static gchar *
decode_base64(const gchar *data, const gchar *end) {
	unsigned short pattern = 0;
	int bits = 0;
	int delimiter = '=';
	gchar x;
	gchar *buffer = g_malloc((end - data) * 3);
	gchar *t = buffer;
	int Q = 0;

	if (!buffer) return NULL;

	while (*data != delimiter) {
		x = base64_rank[(unsigned char)(*data++)];
		if (x == NOT_RANKED)
			continue;
		pattern <<= 6;
		pattern |= x;
		bits += 6;
		if (bits >= 8) {
			x = (pattern >> (bits - 8)) & 0xff;
			*t++ = x;
			Q++;
			bits -= 8;
		}
	}
	*t = 0;
	return buffer;
}

static void
build_base64_rank_table (void)
{
	int i;
	
	if (!base64_rank_table_built) {
		for (i = 0; i < 256; i++)
			base64_rank[i] = NOT_RANKED;
		for (i = 0; i < 64; i++)
			base64_rank[(int) base64_alphabet[i]] = i;
		base64_rank_table_built = 1;
	}
}


gchar*
rfc2047_decode_word (const gchar *data, const gchar *into_what) 
{
	const char *charset = strstr(data, "=?"), *encoding, *text, *end;

	char *buffer, *b, *cooked_data;
	
	buffer = g_malloc(strlen(data) * 2);
	b = buffer;

	if (!charset) return strdup(data);
	charset+=2;

	encoding = strchr(charset, '?');
	if (!encoding) return strdup(data);
	encoding++;

	text = strchr(encoding, '?');
	if (!text) return strdup(data);
	text++;

	end = strstr(text, "?=");
	if (!end) return strdup(data);

	b[0] = 0;

	if (toupper(*encoding)=='Q')
		cooked_data = decode_quoted(text, end);
	else if (toupper(*encoding)=='B')
		cooked_data = decode_base64(text, end);
	else
		return g_strdup(data);

	{
		char *c = strchr(charset, '?');
		char *q = g_malloc(c - charset + 1);
		char *cook_2 = cooked_data;
		int cook_len = strlen(cook_2);
		int b_len = 4096;
		iconv_t i;
		strncpy(q, charset, c - charset);
		q[c - charset] = 0;
		i = unicode_iconv_open(into_what, q);
		if (!i) {
			g_free(q);
			return g_strdup(buffer);
		}
		unicode_iconv(i, &cook_2, &cook_len, &b, &b_len);
		unicode_iconv_close(i);
		*b = 0;
	}

	return g_strdup(buffer);
}

static gchar *
find_end_of_encoded_word(const gchar *data) {
	/* We can't just search for ?=,
           because of the case :
           "=?charset?q?=ff?=" :( */
	if (!data) return NULL;
	data = strstr(data, "=?");
	if (!data) return NULL;
	data = strchr(data+2, '?');
	if (!data) return NULL;
	data = strchr(data+1, '?');
	if (!data) return NULL;
	data = strstr(data+1, "?=");
	if (!data) return NULL;
	return data + 2;
}

gchar *
gmime_rfc2047_decode (const gchar *data, const gchar *into_what) 
{
	char *buffer = malloc(strlen(data) * 4), *b = buffer;

	int was_encoded_word = 0;

	build_base64_rank_table ();

	while (data && *data) {
		char *word_start = strstr(data, "=?"), *decoded;
		if (!word_start) {
			strcpy(b, data);
			b[strlen(data)] = 0;
			return buffer;
		}
		if (word_start != data) {

			if (strspn(data, " \t\n\r") != (word_start - data)) {
				strncpy(b, data, word_start - data);
				b += word_start - data;
				*b = 0;
			}
		}
		decoded = rfc2047_decode_word(word_start, into_what);
		strcpy(b, decoded);
		b += strlen(decoded);
		*b = 0;
		g_free(decoded);

		data = find_end_of_encoded_word(data);
	}

	*b = 0;
	return buffer;
}

gchar 
*gmime_rfc2047_encode (const gchar *string, const gchar *charset) 
{
	gchar buffer[4096] /* FIXME : constant sized buffer */;
	gchar *b = buffer;
	const gchar *s = string;
	int not_ascii = 0, not_latin1 = 0;
	while (*s) {
		if (*s <= 20 || *s >= 0x7f || *s == '=') { not_ascii = 1; }
		s++;
	}
	
	if (!not_ascii) {
		b += sprintf (b, "%s", string);
	}
	
	else {
		b += sprintf (b, "=?%s?Q?", charset);
		s = string;
		while (*s) {
			if (*s == ' ') b += sprintf (b, "_");
			else if (*s < 0x20 || *s >= 0x7f || *s == '=' || *s == '?' || *s == '_') {
				b += sprintf (b, "=%2x", (unsigned char)*s);
			} else {
				b += sprintf (b, "%c", *s);
			}
			s++;
		}
		b += sprintf (b, "?=");
	}
	
	*b = 0;
	
	return g_strdup (buffer);
}