#include <lua.h>

#include <lauxlib.h>

#include <glib.h>

#include "glib_types.h"

/// g.main_context

/// Glib main context object. Mainly useful when lua needs to

/// manage glib-based libs.

/// g.main_context.new

/// Creates new main context object.

/// R: g main context object

static int lglib_main_context_new (lua_State *L)

{

	GMainContext *context = g_main_context_new ();

	lglib_main_context_bless (L, context);

	g_main_context_unref (context);

	return 1;

}

/// g.main_context.bless

/// Blesses given pointer to g main context object.

/// A: lightuserdata (C g main context object)

/// R: g main context object

static int lglib_main_context_bless_lua (lua_State *L)

{

	luaL_argcheck (L, lua_islightuserdata (L, 1), 1, "g main context lightuserdata expected");

	lglib_main_context_bless (L, lua_touserdata (L, 1));

	return 1;

}

/// g.main_context.default

/// Returns default main context object.

/// R: g main context object

static int lglib_main_context_default (lua_State *L)

{

	GMainContext *context = g_main_context_default ();

	lglib_main_context_bless (L, context);

	// XXX g_main_context_unref (context);

	return 1;

}

/// main_context:iteration

/// Performs single full iteration in blocking or non-blocking manner,

/// depending on value of argument.

/// Returns true, if some events have been handled.

/// A: boolean (optional)

/// R: boolean

static int lglib_main_context_iteration (lua_State *L)

{

	lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);

	int may_block = 0;

	if ( lua_gettop (L) > 1 ) {

		luaL_checktype (L, 2, LUA_TBOOLEAN);

		may_block = lua_toboolean (L, 2);

	}

	lua_pushboolean (L, g_main_context_iteration (object->main_context, may_block));

	return 1;

}

/// main_context:pending

/// Indicates, if there are present events in sources.

/// R: boolean

static int lglib_main_context_pending (lua_State *L)

{

	lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);

	lua_pushboolean (L, g_main_context_pending (object->main_context));

	return 1;

}

/// main_context:find_source

/// Returns source with given id.

/// A: integer (source id)

/// R: g main context object or nil

static int lglib_main_context_find_source (lua_State *L)

{

	lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);

	int id = luaL_checkint (L, 2);

	GSource *source = g_main_context_find_source_by_id (object->main_context, id);

	if (source) {

		lglib_source_bless (L, source);

		// XXX g_source_unref (source)

	} else

		lua_pushnil (L);

	return 1;

}

/// main_context:wakeup

/// Awakes main context if it currently poll() ing.

/// XXX Seems to be threading-related routine, how lua will work in this case?

static int lglib_main_context_wakeup (lua_State *L)

{

	lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);

	g_main_context_wakeup (object->main_context);

	return 0;

}

/// main_context:acquire

/// Tries to own main context.

/// R: boolean (success)

static int lglib_main_context_acquire (lua_State *L)

{

	lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);

	lua_pushboolean (L, g_main_context_acquire (object->main_context));

	return 1;

}

/// main_context:release

/// Disowns acquired context.

/// Note: release context as many times, as you acquired it.

static int lglib_main_context_release (lua_State *L)

{

	lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);

	g_main_context_release (object->main_context);

	return 0;

}

/// main_context:owner

/// Indicates if current thread is owner of context.

/// R: boolean

static int lglib_main_context_owner (lua_State *L)

{

	lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);

	lua_pushboolean (L, g_main_context_is_owner (object->main_context));

	return 1;

}

/// main_context:wait

/// For now this will not be implemented, as it requires threading part of glib

/// WARNING: conventions for next four methods are likely to change

/// as I become more familiar with all that stuff.

/// main_context:prepare

/// Polling preparation step.

/// R: boolean (indicates readiness for dispatching before polling), integer (priority of most important ready source, if first value is true)

static int lglib_main_context_prepare (lua_State *L)

{

	lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);

	gint priority;

	gboolean ready = g_main_context_prepare (object->main_context, &priority);

	lua_pushboolean (L, ready);

	if (!ready)

		return 1;

	lua_pushnumber (L, priority);

	return 0;

}

/// main_context:query

/// Get necessary for polling information.

/// A: integer (maximum priority), integer (number of fds to allocate)

/// R: userdata (GPollFDs), integer (number of fds required), integer (timeout)

static int lglib_main_context_query (lua_State *L)

{

	lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);

	int priority = luaL_checkint (L, 2);

	int nfds = luaL_checkint (L, 3);

	gint timeout;

	GPollFD *fds = lua_newuserdata (L, sizeof (GPollFD) * nfds);

	lua_pushnumber (L, g_main_context_query (object->main_context, priority, &timeout, fds, nfds));

	lua_pushnumber (L, timeout);

	return 3;

}

/// main_context:check

/// Passes results of polling back to main loop.

/// A: integer (priority), userdata (GPollFDs), integer (number of fds)

/// R: boolean (readiness for dispatching)

static int lglib_main_context_check (lua_State *L)

{

	lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);

	int priority = luaL_checkint (L, 2);

	GPollFD *fds = lua_touserdata (L, 3); // FIXME

	int nfds = luaL_checkint (L, 4);

	lua_pushboolean (L, g_main_context_check (object->main_context, priority, fds, nfds));

	return 1;

}

/// main_context:dispatch

/// Actually dispatches pending event sources

static int lglib_main_context_dispatch (lua_State *L)

{

	lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);

	g_main_context_dispatch (object->main_context);

	return 0;

}

/// main_context:poll_function

/// main_context:add_poll

/// main_context:remove_poll

/// Let's delay implementing this until fd objects will be ready...

/// main_context:pointer

/// Returns pointe to underlying C structure.

/// A: g main context object

/// R: lightuserdata

static int lglib_main_context_pointer (lua_State *L)

{

	lglib_main_context_t *object = luaL_checklglib_main_context (L, 1);

	lua_pushlightuserdata (L, object->main_context);

	return 1;

}

static int lglib_main_context_gc (lua_State *L)

{

	lglib_main_context_t *object = lua_touserdata (L, 1);

	g_main_context_unref (object->main_context);

	return 0;

}

static const luaL_Reg lglib_main_context_reg_f[] = {

	{ "new",     lglib_main_context_new       },

	{ "bless",   lglib_main_context_bless_lua },

	{ "default", lglib_main_context_default   },

	{ NULL,      NULL                         },

};

static const luaL_Reg lglib_main_context_reg_m[] = {

	{ "iteration",   lglib_main_context_iteration   },

	{ "pending",     lglib_main_context_pending     },

	{ "find_source", lglib_main_context_find_source },

	{ "wakeup",      lglib_main_context_wakeup      },

	{ "acquire",     lglib_main_context_acquire     },

	{ "release",     lglib_main_context_release     },

	{ "owner",       lglib_main_context_owner       },

	{ "prepare",     lglib_main_context_prepare     },

	{ "query",       lglib_main_context_query       },

	{ "check",       lglib_main_context_check       },

	{ "dispatch",    lglib_main_context_dispatch    },

	{ "pointer",     lglib_main_context_pointer     },

	{ "__gc",        lglib_main_context_gc          },

	{ NULL,          NULL                           },

};

int luaopen_glib_main_context (lua_State *L)

{

	luaL_newmetatable (L, "glib.main_context" );

	lua_pushstring (L, "__index");

	lua_pushvalue (L, -2);

	lua_settable (L, -3);

	luaL_register (L, NULL, lglib_main_context_reg_m);

	lua_pop (L, 1);

	luaL_register (L, "g.main_context", lglib_main_context_reg_f);

	return 1;

}