#include <glib.h>
#include <gtk/gtk.h>
#include <gnome.h>
#include <gtkhtml/gtkhtml.h>

#include <gnome-xml/tree.h>
#include <gnome-xml/parser.h>

#include "filter-arg-types.h"
#include "filter-xml.h"
#include "e-sexp.h"
#include "filter-format.h"

#include "camel.h"
#include "camel-mbox-folder.h"
#include "camel-mbox-parser.h"
#include "camel-mbox-utils.h"
#include "camel-mbox-summary.h"
#include "camel-exception.h"
#include "camel-folder-summary.h"

extern int filter_find_arg(FilterArg *a, char *name);

struct exec_context {
	GHashTable *globals;	/* global variables */

	GList *matches;		/* all messages which match current rule */

	GList *deleted;		/* messages to be deleted */
	GHashTable *terminated;	/* messages for which processing is terminated */
	GHashTable *processed;	/* all messages that were processed in some way */

	CamelSession *session;
	CamelStore *store;
	CamelFolder *folder;	/* temporary input folder */
	CamelException *ex;
};

/*

  foreach rule
    find matches

  foreach action
    get all matches

 */

/*
  splices ${cc} lines into a single string
*/
int
expand_variables(GString *out, char *source, GList *args, GHashTable *globals)
{
	GList *argl;
	FilterArg *arg;
	char *name= alloca(32);
	char *start, *end, *newstart, *tmp, *val;
	int namelen=32;
	int len=0;
	int ok = 0;

	printf("expanding %s\n", source);

	start = source;
	while ( (newstart = strstr(start, "${"))
		&& (end = strstr(newstart+2, "}")) ) {
		len = end-newstart-2;
		if (len+1>namelen) {
			namelen = (len+1)*2;
			name = alloca(namelen);
		}
		memcpy(name, newstart+2, len);
		name[len] = 0;
		printf("looking for name '%s'\n", name);
		argl = g_list_find_custom(args, name, (GCompareFunc) filter_find_arg);
		if (argl) {
			int i, count;

			tmp = g_strdup_printf("%.*s", newstart-start, start);
			printf("appending: %s\n", tmp);
			g_string_append(out, tmp);
			g_free(tmp);

			arg = argl->data;
			count = filter_arg_get_count(arg);
			for (i=0;i<count;i++) {
				printf("appending '%s'\n", filter_arg_get_value_as_string(arg, i));
				g_string_append(out, " \"");
				g_string_append(out, filter_arg_get_value_as_string(arg, i));
				g_string_append(out, "\"");
			}
		} else if ( (val = g_hash_table_lookup(globals, name)) ) {
			tmp = g_strdup_printf("%.*s", newstart-start, start);
			printf("appending: %s\n", tmp);
			g_string_append(out, tmp);
			g_free(tmp);
			g_string_append(out, " \"");
			g_string_append(out, val);
			g_string_append(out, "\"");
		} else {
			ok = 1;
			tmp = g_strdup_printf("%.*s", end-start+1, start);
			printf("appending: '%s'\n", tmp);
			g_string_append(out, tmp);
			g_free(tmp);
		}
		start = end+1;
	}
	g_string_append(out, start);

	return ok;
}

/*
  build an expression for the filter
*/
static void
expand_filter_option(GString *s, GString *action, struct filter_option *op)
{
	GList *optionl;
	FilterArg *arg;
	GHashTable *globals;

	globals = g_hash_table_new(g_str_hash, g_str_equal);

	g_hash_table_insert(globals, "self-email", "mzucchi@dehaa.sa.gov.au");

	g_string_append(s, "(and ");
	optionl = op->options;
	while (optionl) {
		struct filter_optionrule *or = optionl->data;
		if (or->rule->type == FILTER_XML_MATCH
		    || or->rule->type == FILTER_XML_EXCEPT) {
			if (or->args) {
				arg = or->args->data;
				if (arg) {
					printf("arg = %s\n", arg->name);
				}
			}
			expand_variables(s, or->rule->code, or->args, globals);
		}
		optionl = g_list_next(optionl);
	}

	g_string_append(s, ")");

	g_string_append(action, "(begin ");
	optionl = op->options;
	while (optionl) {
		struct filter_optionrule *or = optionl->data;
		if (or->rule->type == FILTER_XML_ACTION) {
			expand_variables(action, or->rule->code, or->args, globals);
			g_string_append(action, " ");
		}
		optionl = g_list_next(optionl);
	}
	g_string_append(action, ")");

	printf("combined rule '%s'\n", s->str);
	printf("combined action '%s'\n", action->str);
}

struct filter_optionrule *
find_optionrule(struct filter_option *option, char *name)
{
	GList *optionrulel;
	struct filter_optionrule *or;
	
	optionrulel = option->options;
	while (optionrulel) {
		or = optionrulel->data;
		if (!strcmp(or->rule->name, name)) {
			return or;
		}
		optionrulel = g_list_next(optionrulel);
	}
	return NULL;
}

static ESExpResult *
do_delete(struct _ESExp *f, int argc, struct _ESExpResult **argv, struct exec_context *x)
{
	GList *m;

	printf("doing delete\n");
	m = x->matches;
	while (m) {
		printf(" %s\n", m->data);
		x->deleted = g_list_append(x->deleted, g_strdup(m->data));
		m = m->next;
	}
	return NULL;
}

static ESExpResult *
do_forward(struct _ESExp *f, int argc, struct _ESExpResult **argv, struct exec_context *x)
{
	GList *m;

	printf("doing forward on the following messages:\n");
	m = x->matches;
	while (m) {
		printf(" %s\n", m->data);
		m = m->next;
	}
	return NULL;
}

static ESExpResult *
do_copy(struct _ESExp *f, int argc, struct _ESExpResult **argv, struct exec_context *x)
{
	GList *m;
	int i;

	printf("doing copy on the following messages to:");
	for (i=0;i<argc;i++) {
		if (argv[i]->type == ESEXP_RES_STRING) {
			char *folder = argv[i]->value.string;
			CamelFolder *outbox;

			/* FIXME: this might have to find another store, based on
			   the folder as a url??? */
			printf("opening outpbox %s\n", folder);
			outbox = camel_store_get_folder (x->store, folder, x->ex);
			if (!camel_folder_exists(outbox, x->ex)) {
				camel_folder_create(outbox, x->ex);
			}
			
			camel_folder_open (outbox, FOLDER_OPEN_WRITE, x->ex);

			m = x->matches;
			while (m) {
				CamelMimeMessage *mm;

				printf("appending message %s\n", m->data);

				mm = camel_folder_get_message_by_uid(x->folder, m->data, x->ex);
				camel_folder_append_message(outbox, mm, x->ex);
				gtk_object_unref((GtkObject *)mm);

				printf(" %s\n", m->data);
				m = m->next;
			}
			camel_folder_close (outbox, FALSE, x->ex);
		}
	}

	return NULL;
}

static ESExpResult *
do_stop(struct _ESExp *f, int argc, struct _ESExpResult **argv, struct exec_context *x)
{
	GList *m;

	printf("doing stop on the following messages:\n");
	m = x->matches;
	while (m) {
		printf(" %s\n", m->data);
		g_hash_table_insert(x->terminated, g_strdup(m->data), (void *)1);
		m = m->next;
	}
	return NULL;
}

static struct {
	char *name;
	ESExpFunc *func;
	int type;		/* set to 1 if a function can perform shortcut evaluation, or
				   doesn't execute everything, 0 otherwise */
} symbols[] = {
	{ "delete", (ESExpFunc *)do_delete, 0 },
	{ "forward-to", (ESExpFunc *)do_forward, 0 },
	{ "copy-to", (ESExpFunc *)do_copy, 0 },
	{ "stop", (ESExpFunc *)do_stop, 0 },
};

static char *
auth_callback(char *prompt, gboolean secret,
	      CamelService *service, char *item,
	      CamelException *ex)
{
	printf ("auth_callback called: %s\n", prompt);
	return NULL;
}

static struct exec_context *
start(void)
{
	struct exec_context *x;
	char *store_url = "mbox:///tmp/evmail";

	x = g_malloc0(sizeof(*x));

	/* just hack up this for now */
	x->ex = camel_exception_new ();
	camel_provider_register_as_module ("../camel/providers/mbox/.libs/libcamelmbox.so.0");
	x->session = camel_session_new (auth_callback);
	printf("session = %p\n", x->session);
	x->store = camel_session_get_store (x->session, store_url, x->ex);
	printf("store = %p\n", x->store);
	if (camel_exception_get_id (x->ex)) {
		printf ("Exception caught in camel_store_get_folder\n"
			"Full description : %s\n", camel_exception_get_description (x->ex));
		return NULL;
	}
	x->folder = camel_store_get_folder (x->store, "Inbox", x->ex);
	if (camel_exception_get_id (x->ex)) {
		printf ("Exception caught in camel_store_get_folder\n"
			"Full description : %s\n", camel_exception_get_description (x->ex));
		return NULL;
	}
	camel_folder_open (x->folder, FOLDER_OPEN_READ, x->ex);
	x->terminated = g_hash_table_new(g_str_hash, g_str_equal);
	x->processed = g_hash_table_new(g_str_hash, g_str_equal);
	return x;
}

static void
search_cb(CamelFolder *f, int id, gboolean complete, GList *matches, struct exec_context *x)
{
	printf("appending matches ...\n");
	x->matches =  g_list_concat(x->matches, g_list_copy(matches));
}

int main(int argc, char **argv)
{
	ESExp *f;
	ESExpResult *r;
	GList *rules, *options, *options2;
	xmlDocPtr doc, out;
	GString *s, *a;
	GList *all, *m;
	struct exec_context *x;
	int i;
	ESExp *eval;

	gnome_init("Test", "0.0", argc, argv);
	camel_init();

	doc = xmlParseFile("filterdescription.xml");
	rules = filter_load_ruleset(doc);
	options2 = filter_load_optionset(doc, rules);

	out = xmlParseFile("saveoptions.xml");
	options = filter_load_optionset(out, rules);

	x = start();

	eval = e_sexp_new();
	/* Load in builtin symbols? */
	for(i=0;i<sizeof(symbols)/sizeof(symbols[0]);i++) {
		if (symbols[i].type == 1) {
			e_sexp_add_ifunction(eval, 0, symbols[i].name, (ESExpIFunc *)symbols[i].func, x);
		} else {
			e_sexp_add_function(eval, 0, symbols[i].name, symbols[i].func, x);
		}
	}

	while (options) {
		struct filter_option *fo = options->data;
		int id;

		s = g_string_new("");
		a = g_string_new("");
		expand_filter_option(s, a, fo);

		printf("searching expression %s\n", s->str);
		x->matches= NULL;
		id = camel_folder_search_by_expression  (x->folder, s->str, search_cb, x, x->ex);

		/* wait for it to finish */
		camel_folder_search_complete(x->folder, id, TRUE, x->ex);
		
		/* remove uid's for which processing is complete ... */
		m = x->matches;
		while (m) {
			GList *n = m->next;

			/* for all matching id's, so we can work out what to default */
			if (g_hash_table_lookup(x->processed, m->data) == NULL) {
				g_hash_table_insert(x->processed, g_strdup(m->data), (void *)1);
			}

			if (g_hash_table_lookup(x->terminated, m->data)) {
				printf("removing terminated message %s\n", m->data);
				x->matches = g_list_remove_link(x->matches, m);
			}
			m = n;
		}

		printf("applying actions ... '%s'\n", a->str);
		e_sexp_input_text(eval, a->str, strlen(a->str));
		e_sexp_parse(eval);
		r = e_sexp_eval(eval);
		e_sexp_result_free(r);

		g_string_free(s, TRUE);
		g_string_free(a, TRUE);

		g_list_free(x->matches);
		
		options = g_list_next(options);
	}

	/* now apply 'default' rule */
	all = camel_folder_get_uid_list(x->folder, x->ex);
	m = all;
	while (m) {
		char *uid = m->data;
		if (g_hash_table_lookup(x->processed, uid) == NULL) {
			printf("Applying default rule to message %s\n", uid);
		}
		m = m->next;
	}
	g_list_free(all);

	return 0;
}