#import <ObjXMPP/ObjXMPP.h>
#include <gtk/gtk.h>

#import "JubGtkUI.h"
#import "JubGObjectMap.h"

void on_roster_window_destroy(GObject *object, gpointer user_data)
{
	gtk_main_quit();
}

static gboolean filter_roster_by_presence(GtkTreeModel *model,
    GtkTreeIter *iter, gpointer data)
{
	char *jid_s;
	OFString *jid;
	OFCountedSet *presences = data;

	gtk_tree_model_get(model, iter, 1, &jid_s, -1);

	// Groups have no JID
	if (!jid_s)
		return TRUE;

	jid = [[OFString alloc] initWithUTF8String: jid_s];

	g_free(jid_s);

	if ([presences countForObject: jid]) {
		[jid release];
		return TRUE;
	} else {
		[jid release];
		return FALSE;
	}
}

@implementation JubGtkUI
- init
{
	self = [super init];

	@try {
		groupMap = [[OFMapTable alloc]
		    initWithKeyFunctions: keyFunctions
			  valueFunctions: rowRefFunctions];
		contactMap = [[OFMutableDictionary alloc] init];
		presences = [[OFCountedSet alloc] init];
	} @catch (id e) {
		[self release];
		@throw e;
	}

	return self;
}

- (void)dealloc
{

	[groupMap release];
	[contactMap release];
	[presences release];

	if (roster_model)
		g_object_unref(roster_model);

	[super dealloc];
}

- (void)startUIThread
{
	int *argc;
	char ***argv;

	GtkBuilder *builder;
	GtkWidget *roster_window;

	[[OFApplication sharedApplication] getArgumentCount: &argc
					  andArgumentValues: &argv];

	gtk_init(argc, argv);

	builder = gtk_builder_new();
	gtk_builder_add_from_file(builder, "data/gtk/roster.ui", NULL);

	roster_window =
	    GTK_WIDGET(gtk_builder_get_object(builder, "RosterWindow"));

	roster_model =
	    GTK_TREE_STORE(gtk_builder_get_object(builder, "RosterTreeStore"));

	roster_filter = GTK_TREE_MODEL_FILTER(
	    gtk_builder_get_object(builder,"RosterTreeModelFilter"));

	gtk_tree_model_filter_set_visible_func(roster_filter,
	    filter_roster_by_presence, presences, NULL);

	gtk_builder_connect_signals(builder, NULL);
	g_object_unref(G_OBJECT(builder));

	gtk_widget_show(roster_window);

	[[OFThread threadWithBlock: ^(void){
		gtk_main();
		[OFApplication terminate];

		return nil;
	}] start];
}


- (id<XMPPRosterDelegate>)rosterDelegate
{
	return self;
}

/* Presence handling */
static gboolean refilter_roster(gpointer data)
{
	gtk_tree_model_filter_refilter(data);

	return FALSE;
}

-   (void)connection: (XMPPConnection*)connection
  didReceivePresence: (XMPPPresence*)presence
{
	if ([presence.type isEqual: @"available"])
		[presences addObject: [presence.from bareJID]];
	else
		[presences removeObject: [presence.from bareJID]];

	g_idle_add(refilter_roster, roster_filter);
}

/* Roster Delegate methods */
struct add_roster_item_param {
	OFString *group;
	OFString *name;
	OFString *jid;
	OFMapTable *groupMap;
	OFMapTable *contactRows;
	GtkTreeStore *roster_model;
};

static gboolean add_roster_item(gpointer user_data)
{
	struct add_roster_item_param *params = user_data;
	GtkTreeIter group_iter, contact_iter;
	GtkTreeRowReference *group_ref, *contact_ref;
	GtkTreePath *group_path, *contact_path;

	group_ref = [params->groupMap valueForKey: params->group];

	if (!group_ref) {
		// Create new group row
		gtk_tree_store_append(params->roster_model, &group_iter, NULL);
		gtk_tree_store_set(params->roster_model, &group_iter,
		    0, [params->group UTF8String], -1);

		group_path = gtk_tree_model_get_path(GTK_TREE_MODEL(
			params->roster_model), &group_iter);

		group_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(
			params->roster_model), group_path);

		[params->groupMap setValue: group_ref
				    forKey: params->group];
	} else {
		// Get iter for existing group row
		group_path = gtk_tree_row_reference_get_path(group_ref);

		gtk_tree_model_get_iter(GTK_TREE_MODEL(params->roster_model),
		    &group_iter, group_path);
	}
	gtk_tree_path_free(group_path);

	// Create new contact row
	gtk_tree_store_append(params->roster_model, &contact_iter, &group_iter);
	gtk_tree_store_set(params->roster_model, &contact_iter,
	    0, [params->name UTF8String], 1, [params->jid UTF8String], -1);

	contact_path = gtk_tree_model_get_path(GTK_TREE_MODEL(
		params->roster_model), &contact_iter);

	contact_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(
		params->roster_model), contact_path);

	gtk_tree_path_free(contact_path);

	[params->contactRows setValue: contact_ref
			       forKey: params->group];

	[params->group release];
	[params->name release];
	[params->jid release];
	[params->groupMap release];
	[params->contactRows release];
	g_object_unref(params->roster_model);
	free(params);

	return FALSE;
}

struct remove_roster_item_param {
	OFString *group;
	OFMapTable *groupMap;
	OFMapTable *contactRows;
	GtkTreeStore *roster_model;
};

static gboolean remove_roster_item(gpointer user_data)
{
	struct remove_roster_item_param *params = user_data;
	GtkTreeIter contact_iter, group_iter;
	GtkTreePath *contact_path, *group_path;
	GtkTreeRowReference *contact_ref, *group_ref;

	contact_ref = [params->contactRows valueForKey: params->group];
	contact_path = gtk_tree_row_reference_get_path(contact_ref);
	gtk_tree_model_get_iter(GTK_TREE_MODEL(params->roster_model),
	    &contact_iter, contact_path);

	gtk_tree_store_remove(params->roster_model, &contact_iter);

	group_ref = [params->groupMap valueForKey: params->group];
	group_path = gtk_tree_row_reference_get_path(group_ref);
	gtk_tree_model_get_iter(GTK_TREE_MODEL(params->roster_model),
	    &group_iter, group_path);

	if (!gtk_tree_model_iter_has_child(GTK_TREE_MODEL(params->roster_model),
	    &group_iter)) {
		gtk_tree_store_remove(params->roster_model, &group_iter);
		[params->groupMap removeValueForKey: params->group];
	}

	gtk_tree_path_free(group_path);

	[params->group release];
	[params->groupMap release];
	[params->contactRows release];
	g_object_unref(params->roster_model);
	free(params);

	return FALSE;
}

- (void)rosterWasReceived: (XMPPRoster*)roster_
{
	[[roster_ rosterItems] enumerateKeysAndObjectsUsingBlock:
	    ^(OFString *bareJID, XMPPRosterItem *item, BOOL *stop) {
		OFArray *groups;
		OFMapTable *contactRows = [OFMapTable
		    mapTableWithKeyFunctions: keyFunctions
			      valueFunctions: rowRefFunctions];

		[contactMap setObject: contactRows
			       forKey: bareJID];

		if (item.groups != nil)
			groups = item.groups;
		else
			groups = @[@"General"];

		for (OFString *group in groups) {
			struct add_roster_item_param *params =
			    malloc(sizeof(*params));
			params->group = [group retain];
			params->name = [item.name retain];
			params->jid = [bareJID retain];
			params->groupMap = [groupMap retain];
			params->contactRows = [contactRows retain];
			params->roster_model = g_object_ref(roster_model);
			g_idle_add(add_roster_item, params);
		}
	}];
}

-         (void)roster: (XMPPRoster*)roster_
  didReceiveRosterItem: (XMPPRosterItem*)item
{
	OFArray *groups;
	XMPPRosterItem *oldItem =
	    [roster_.rosterItems objectForKey: [item.JID bareJID]];

	if (oldItem) {
		if (oldItem.groups != nil)
			groups = oldItem.groups;
		else
			groups = @[@"General"];

		for (OFString *group in groups) {
			struct remove_roster_item_param *params =
			    malloc(sizeof(*params));
			params->group = [group retain];
			params->contactRows = [[contactMap objectForKey:
			    [oldItem.JID bareJID]] retain];
			params->groupMap = [groupMap retain];
			params->roster_model = g_object_ref(roster_model);
			g_idle_add(remove_roster_item, params);
		}

		[contactMap removeObjectForKey: [item.JID bareJID]];
	}

	if (![item.subscription isEqual: @"remove"]) {
		OFMapTable *contactRows = [OFMapTable
		    mapTableWithKeyFunctions: keyFunctions
			      valueFunctions: rowRefFunctions];

		[contactMap setObject: contactRows
			       forKey: [item.JID bareJID]];

		if (item.groups != nil)
			groups = item.groups;
		else
			groups = @[@"General"];

		for (OFString *group in groups) {
			struct add_roster_item_param *params =
			    malloc(sizeof(*params));
			params->group = [group retain];
			params->name = [item.name retain];
			params->jid = [[item.JID bareJID] retain];
			params->groupMap = [groupMap retain];
			params->contactRows = [contactRows retain];
			params->roster_model = g_object_ref(roster_model);
			g_idle_add(add_roster_item, params);
		}
	}
}
@end
