%%
headers
#include <Python.h>
#include "pygobject.h"
#include "gtask/gtask.h"
#include "gtask/gtaskpriv.h"
#include "pygtaskmarshal.h"

#define PY_TYPE_OBJECT (py_object_get_type())

static GClosure* _pyg_task_make_func_closure     (GClosure *closure);
static GClosure* _pyg_task_make_callback_closure (GClosure *closure);
//static GClosure* _pyg_task_make_errback_closure  (GClosure *closure);

static GType
py_object_get_type (void)
{
	static GType py_type_object = 0;
	if (G_UNLIKELY (py_type_object == 0))
		py_type_object = g_type_from_name ("PyObject");
	g_assert (py_type_object != 0);
	return py_type_object;
}
%%
modulename gtask
%%
import gobject.GObject as PyGObject_Type
%%
ignore-glob
  *_get_type
  g_task_add_callback_closure
  g_task_add_errback_closure
  g_task_new_from_closure
  g_task_take_error
%%
override g_task_get_result noargs
static PyObject*
_wrap_g_task_get_result (PyGObject *self)
{
	const GValue *gvalue = g_task_get_result (G_TASK (self->obj));

	if (!gvalue)
	{
		Py_INCREF (Py_None);
		return Py_None;
	}

	return pyg_value_as_pyobject (gvalue, TRUE);
}
%%
override g_task_set_result
static PyObject*
_wrap_g_task_set_result (PyGObject *self, PyObject *args, PyObject *kwargs)
{
	static char *kwlist[] = { "result", NULL };
	PyObject    *result   = NULL;
	GValue       value    = {0};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GTask.set_result", kwlist, &result))
		return NULL;

	g_value_init (&value, PY_TYPE_OBJECT);
	if (pyg_value_from_pyobject (&value, result)) {
		PyErr_SetString (PyExc_TypeError, "Could not convert value");
		return NULL;
	}

	g_task_set_result (G_TASK (self->obj), &value);

	Py_INCREF (Py_None);
	return Py_None;
}
%%
override g_task_get_error noargs
static PyObject*
_wrap_g_task_get_error (PyGObject *self)
{
	const GError *error = g_task_get_error (G_TASK (self->obj));

	if (error != NULL)
		return PyString_FromString (error->message);

	Py_INCREF (Py_None);
	return Py_None;
}
%%
override g_task_set_error
static PyObject*
_wrap_g_task_set_error (PyGObject *self, PyObject *args)
{
	PyObject *error  = NULL;
	PyObject *str    = NULL;
	GError   *gerror = NULL;

	if (!PyArg_ParseTuple (args, "O:GTask.set_error", &error))
		return NULL;

	if (!(str = PyObject_Str (error)))
		return NULL;

	gerror = g_error_new (G_TASK_ERROR, G_TASK_ERROR_EXEC, "%s", PyString_AsString (str));
	g_task_take_error (G_TASK (self->obj), gerror);

	Py_INCREF (Py_None);

	return Py_None;
}
%%
override g_task_add_callback
static GTask* current_task = NULL;
static void
_pyg_task_closure_exception_handler (GValue *ret, guint n_param_values, const GValue *params)
{
	/* XXX: Can we find a really good way to get the exception or part
	 *   of the traceback as a string for the GError? That would be super
	 *   fantastic awesome.
	 */
	g_task_take_error (current_task, g_error_new_literal (
		G_TASK_ERROR, G_TASK_ERROR_EXEC,
		"An error occurred in the python closure"));
}
static void
_pyg_task_handle_closure_result (GTask *task, GValue *src, GValue *dst)
{
	PyObject *pyobject = pyg_value_as_pyobject (src, TRUE);

	if (pygobject_check (pyobject, &PyGTask_Type))
	{
		g_value_init (dst, G_TYPE_TASK);
		g_value_set_object (dst, pygobject_get (pyobject));
		return;
	}

	g_value_init (dst, PY_TYPE_OBJECT);

	if (pyg_value_from_pyobject (dst, pyobject) == 0)
		return;

	g_warning ("Could not store result from python closure");
}
static GValue*
_pyg_task_func (GTask *task, gpointer user_data)
{
	g_return_val_if_fail (user_data != NULL, NULL);

	PyGILState_STATE state = pyg_gil_state_ensure ();

	GClosure *closure        = user_data;
	GValue    closure_result = {0};
	GValue   *result         = g_new0 (GValue, 1);

	g_value_init (&closure_result, PY_TYPE_OBJECT);

	current_task = task;

	pyg_closure_set_exception_handler (closure, _pyg_task_closure_exception_handler);
	g_closure_invoke (closure, &closure_result, 0, NULL, NULL);

	current_task = NULL;

	_pyg_task_handle_closure_result (task, &closure_result, result);

	pyg_gil_state_release (state);

	return result;

}
static GValue*
_pyg_task_callback (GTask *task, const GValue *param, gpointer user_data)
{
	g_return_val_if_fail (user_data != NULL, NULL);

	PyGILState_STATE state = pyg_gil_state_ensure ();

	GClosure *closure           = user_data;
	GValue    closure_result    = {0};
	GValue   *result            = g_new0 (GValue, 1);
	GValue    closure_params[1] = {{0}};

	g_value_init (&closure_result, PY_TYPE_OBJECT);
	g_value_init (&closure_params[0], PY_TYPE_OBJECT);

	if (param && G_VALUE_HOLDS (param, G_TYPE_BOXED))
		pyg_value_from_pyobject (&closure_params[0], g_value_get_boxed (param));
	else
		g_value_set_boxed (&closure_params[0], NULL);

	current_task = task;

	pyg_closure_set_exception_handler (closure, _pyg_task_closure_exception_handler);
	g_closure_invoke (closure, &closure_result, 1, &closure_params[0], NULL);

	current_task = NULL;

	_pyg_task_handle_closure_result (task, &closure_result, result);

	pyg_gil_state_release (state);

	return result;
}
static GValue*
_pyg_task_errback (GTask *task, const GError *error, gpointer user_data)
{
	g_return_val_if_fail (user_data != NULL, NULL);

	PyGILState_STATE state = pyg_gil_state_ensure ();

	GClosure *closure = user_data;
	GValue    closure_result = {0};
	GValue   *result = g_new0 (GValue, 1);
	GValue    closure_params[1] = {{0}};

	g_value_init (&closure_result, PY_TYPE_OBJECT);
	g_value_init (&closure_params[0], PY_TYPE_OBJECT);

	if (!error)
	{
		g_value_set_boxed (&closure_params[0], Py_None);
	}
	else
	{
		PyObject *failure = PyString_FromString (error->message);
		pyg_value_from_pyobject (&closure_params[0], failure);
		Py_XDECREF (failure);
	}

	/* this invalidates our const GError *error parameter! */
	g_task_set_error (task, NULL);

	current_task = task;

	pyg_closure_set_exception_handler (closure, (PyClosureExceptionHandler)_pyg_task_handle_closure_result);
	g_closure_invoke (closure, &closure_result, 1, &closure_params[0], NULL);

	current_task = NULL;

	_pyg_task_handle_closure_result (task, &closure_result, result);

	pyg_gil_state_release (state);

	return result;
}
static GClosure*
_pyg_task_make_func_closure (GClosure *closure)
{
	g_closure_ref (closure);
	g_closure_sink (closure);

	GClosure *wrapper_closure = g_cclosure_new (G_CALLBACK (_pyg_task_func), closure, (GClosureNotify)g_closure_unref);
	g_closure_set_marshal (wrapper_closure, _pyg_task_marshal_POINTER__VOID);
	return wrapper_closure;
}
static GClosure*
_pyg_task_make_callback_closure (GClosure *closure)
{
	g_closure_ref (closure);
	g_closure_sink (closure);

	GClosure *wrapper_closure = g_cclosure_new (G_CALLBACK (_pyg_task_callback), closure, (GClosureNotify)g_closure_unref);
	g_closure_set_marshal (wrapper_closure, _pyg_task_marshal_POINTER__POINTER);
	return wrapper_closure;
}
static GClosure*
_pyg_task_make_errback_closure (GClosure *closure)
{
	g_closure_ref (closure);
	g_closure_sink (closure);

	GClosure *wrapper_closure = g_cclosure_new (G_CALLBACK (_pyg_task_errback), closure, (GClosureNotify)g_closure_unref);
	g_closure_set_marshal (wrapper_closure, _pyg_task_marshal_POINTER__POINTER);
	return wrapper_closure;
}
static PyObject*
_pyg_task_add_handler (PyGObject *self, PyObject *args, gboolean is_errback)
{
	PyGILState_STATE state;

	PyObject *callback   = NULL;
	PyObject *extra_args = NULL;
	GClosure *closure    = NULL;
	gint      len;

	state = pyg_gil_state_ensure ();

	len = PyTuple_Size (args);
	if (len < 1)
	{
		PyErr_SetString (PyExc_TypeError, "GTask.add_callback requires least one argument");
		goto error;
	}

	if (!(callback = PySequence_GetItem (args, 0)))
		goto error;

	if (len > 1)
	{
		if (!(extra_args = PySequence_GetSlice (args, 1, len)))
		{
			Py_DECREF (callback);
			goto error;
		}
	}

	closure = pyg_closure_new (callback, extra_args, NULL);

	if (is_errback)
		g_task_add_errback_closure (G_TASK (self->obj), _pyg_task_make_errback_closure (closure));
	else
		g_task_add_callback_closure (G_TASK (self->obj), _pyg_task_make_callback_closure (closure));

	Py_XDECREF (callback);
	Py_XDECREF (extra_args);
	Py_INCREF (Py_None);

	pyg_gil_state_release (state);

	return Py_None;

error:
	pyg_gil_state_release (state);
	return NULL;
}
static PyObject*
_wrap_g_task_add_callback (PyGObject *self, PyObject *args)
{
	return _pyg_task_add_handler (self, args, FALSE);
}
%%
override g_task_add_errback
static PyObject*
_wrap_g_task_add_errback (PyGObject *self, PyObject *args)
{
	return _pyg_task_add_handler (self, args, TRUE);
}
%%
override g_task_new
static int
_wrap_g_task_new (PyGObject *self, PyObject *args, PyObject *kwargs)
{
	PyGILState_STATE state;

	PyObject *callback   = NULL;
	PyObject *extra_args = NULL;
	GClosure *closure    = NULL;
	gint      len;

	state = pyg_gil_state_ensure ();

	len = PyTuple_Size (args);
	if (len < 1)
	{
		PyErr_SetString (PyExc_TypeError, "GTask.add_callback requires least one argument");
		goto error;
	}

	pygobject_constructv (self, 0, NULL);

	if (!self->obj) {
		PyErr_SetString (PyExc_RuntimeError, "Could not create gtask.Task object");
		goto error;
	}

	if (!(callback = PySequence_GetItem (args, 0)))
		goto error;

	if (len > 1)
	{
		if (!(extra_args = PySequence_GetSlice (args, 1, len)))
		{
			Py_DECREF (callback);
			goto error;
		}
	}

	GTask *task = g_object_ref (G_TASK (self->obj));

	closure = _pyg_task_make_func_closure (pyg_closure_new (callback, extra_args, NULL));
	task->priv->closure = g_closure_ref (closure);
	g_closure_sink (closure);

	Py_DECREF (callback);
	Py_XDECREF (extra_args);

	pyg_gil_state_release (state);

	return 0;

error:
	pyg_gil_state_release (state);
	return -1;

}
%%
define schedule
static PyObject*
_wrap_schedule (PyObject *self, PyObject *args)
{
	GTaskScheduler *sched = g_task_scheduler_get_default ();
	PyObject *pytask;

	if (!PyArg_ParseTuple (args, "O", &pytask))
		return NULL;

	if (!pygobject_check (pytask, &PyGTask_Type))
	{
		PyErr_SetString (PyExc_TypeError, "Argument must be a gtask.Task");
		return NULL;
	}

	g_task_scheduler_schedule (sched, G_TASK (pygobject_get (pytask)));

	Py_INCREF (Py_None);
	return Py_None;
}
%%