/**
 * Navit, a modular navigation system.
 * Copyright (C) 2005-2008 Navit Team
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * 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., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

#include <glib.h>
#include "event.h"
#include "event_glib.h"
#include "debug.h"
#include "callback.h"
#include "plugin.h"

static GMainLoop *loop;

static void event_glib_main_loop_run(void)
{
	loop = g_main_loop_new (NULL, TRUE);
	if (g_main_loop_is_running (loop))
	{
		g_main_loop_run (loop);
	}
}

static void event_glib_main_loop_quit(void)
{
	if (loop) {
		g_main_loop_quit(loop);
		g_main_loop_unref(loop);
	}

}

struct event_watch {
	GIOChannel *iochan;
	guint source;
};

static gboolean
event_glib_call_watch(GIOChannel * iochan, GIOCondition condition, gpointer t)
{
	struct callback *cb=t;
	callback_call_0(cb);
	return TRUE;
}

static struct event_watch *
event_glib_add_watch(void *fd, enum event_watch_cond cond, struct callback *cb)
{
	struct event_watch *ret=g_new0(struct event_watch, 1);
	int flags=0;
	ret->iochan = g_io_channel_unix_new(GPOINTER_TO_INT(fd));
	switch (cond) {
	case event_watch_cond_read:
		flags=G_IO_IN;
		break;
	case event_watch_cond_write:
		flags=G_IO_OUT;
		break;
	case event_watch_cond_except:
		flags=G_IO_ERR|G_IO_HUP;
		break;
	}	
	ret->source = g_io_add_watch(ret->iochan, flags, event_glib_call_watch, (gpointer)cb);
	return ret;
}

static void
event_glib_remove_watch(struct event_watch *ev)
{
	if (! ev)
		return;
	g_source_remove(ev->source);
	g_io_channel_unref(ev->iochan);
	g_free(ev);
}

struct event_timeout {
	guint source;
	struct callback *cb;
};

static gboolean
event_glib_call_timeout_single(struct event_timeout *ev)
{
	callback_call_0(ev->cb);
	g_free(ev);
	return FALSE;
}

static gboolean
event_glib_call_timeout_multi(struct event_timeout *ev)
{
	callback_call_0(ev->cb);
	return TRUE;
}


static struct event_timeout *
event_glib_add_timeout(int timeout, int multi, struct callback *cb)
{
	struct event_timeout *ret=g_new0(struct event_timeout, 1);
	ret->cb=cb;
	ret->source = g_timeout_add(timeout, multi ? (GSourceFunc)event_glib_call_timeout_multi : (GSourceFunc)event_glib_call_timeout_single, (gpointer)ret);

	return ret;
}

static void
event_glib_remove_timeout(struct event_timeout *ev)
{
	if (! ev)
		return;
	g_source_remove(ev->source);
	g_free(ev);
}

struct event_idle {
	guint source;
	struct callback *cb;
};

static gboolean
event_glib_call_idle(struct event_idle *ev)
{
	callback_call_0(ev->cb);
	return TRUE;
}

static struct event_idle *
event_glib_add_idle(int priority, struct callback *cb)
{
	struct event_idle *ret=g_new0(struct event_idle, 1);
	ret->cb=cb;
	ret->source = g_idle_add_full(priority+100, (GSourceFunc)event_glib_call_idle, (gpointer)ret, NULL);
	return ret;
}

static void
event_glib_remove_idle(struct event_idle *ev)
{
	if (! ev)
		return;
	g_source_remove(ev->source);
	g_free(ev);
}

static void
event_glib_call_callback(struct callback_list *cb)
{
/* 
 Idea for implementation:
 Create a pipe then use add_watch
 add callback to a queue
 from here write to the pipe to wakeup the pool
 then from the gui thread process the callback queue
*/
}

static struct event_methods event_glib_methods = {
	event_glib_main_loop_run,
	event_glib_main_loop_quit,
	event_glib_add_watch,
	event_glib_remove_watch,
	event_glib_add_timeout,
	event_glib_remove_timeout,
	event_glib_add_idle,
	event_glib_remove_idle,
	event_glib_call_callback,
};

struct event_priv {
};

static struct event_priv*
event_glib_new(struct event_methods *meth)
{
	*meth=event_glib_methods;
	return (struct event_priv *)event_glib_new;
}

void
event_glib_init(void)
{
	plugin_register_event_type("glib", event_glib_new);
}