/* -*- Mode: C; c-basic-offset: 4 -*- */
%%
headers
#include <Python.h>
#include <stdio.h>

#define NO_IMPORT_PYGOBJECT
#include "pygobject.h"

#include <beagle/beagle.h>

#define BEAGLE_TYPE_HIT       (beagle_hit_get_gtype ())
#define BEAGLE_TYPE_PROPERTY  (beagle_property_get_gtype ())
#define BEAGLE_TYPE_TIMESTAMP (beagle_timestamp_get_gtype ())
#define BEAGLE_TYPE_QUERYABLE_STATUS	(beagle_queryable_status_get_gtype ())
#define BEAGLE_TYPE_SCHEDULER_INFORMATION   (beagle_scheduler_information_get_gtype ())

GType
beagle_hit_get_gtype (void)
{
	static GType our_type = 0;
	if (!our_type)
		our_type = g_pointer_type_register_static ("BeagleHit");
	return our_type;
} 

GType
beagle_timestamp_get_gtype (void)
{
	static GType our_type = 0;
	if (!our_type)
		our_type = g_pointer_type_register_static ("BeagleTimestamp");
	return our_type;
} 

GType
beagle_property_get_gtype (void)
{
	static GType our_type = 0;
	if (!our_type)
		our_type = g_pointer_type_register_static ("BeagleProperty");
	return our_type;
}

GType
beagle_queryable_status_get_gtype (void)
{
	static GType our_type = 0;
	if (!our_type)
		our_type = g_pointer_type_register_static ("BeagleQueryableStatus");
	return our_type;
}

GType
beagle_scheduler_information_get_gtype (void)
{
	static GType our_type = 0;
	if (!our_type)
		our_type = g_pointer_type_register_static ("BeagleSchedulerInformation");
	return our_type;
}

static PyObject *
_helper_wrap_pointer_gslist (GType type, GSList *list)
{
    GSList *tmp;
    PyObject *py_list;

    if ((py_list = PyList_New(0)) == NULL) {
        return NULL;
    }
    for (tmp = list; tmp != NULL; tmp = tmp->next) {
        PyObject *obj = pyg_pointer_new (type, tmp->data);
        PyList_Append(py_list, obj);
        Py_DECREF(obj);
    }
    return py_list;
}

static PyObject *
_helper_wrap_string_gslist (GSList *list)
{
    GSList *tmp;
    PyObject *py_list;

    if ((py_list = PyList_New(0)) == NULL) {
        return NULL;
    }
    for (tmp = list; tmp != NULL; tmp = tmp->next) {
        PyObject *str_obj =  PyString_FromString ((char*)tmp->data);

        if (str_obj == NULL) {
            Py_DECREF(py_list);
            return NULL;
        }
        PyList_Append(py_list, str_obj);
        Py_DECREF(str_obj);
    }
    return py_list;
}
%%
modulename beagle
%%
import gobject.GObject as PyGObject_Type
%%
ignore-glob
	beagle_snippet_request_set_query_terms_from_query
%%
override beagle_hits_added_response_get_hits noargs
static PyObject *
_wrap_beagle_hits_added_response_get_hits(PyGObject *self)
{
    GSList *list;

    list = beagle_hits_added_response_get_hits(BEAGLE_HITS_ADDED_RESPONSE (self->obj));

    return _helper_wrap_pointer_gslist (BEAGLE_TYPE_HIT, list);
}
%%
override beagle_hits_subtracted_response_get_uris noargs
static PyObject *
_wrap_beagle_hits_subtracted_response_get_uris(PyGObject *self)
{
    GSList *list;

    list = beagle_hits_subtracted_response_get_uris(BEAGLE_HITS_SUBTRACTED_RESPONSE (self->obj));

    return _helper_wrap_string_gslist (list);
}
%%
override beagle_hit_get_one_property kwargs
static PyObject *
_wrap_beagle_hit_get_one_property (PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "key", NULL };
    char *key;
    const char *value = NULL;
    gboolean ret;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:BeagleHit.get_one_property", kwlist, &key))
        return NULL;
    ret = beagle_hit_get_one_property (pyg_pointer_get (self, BeagleHit), key, &value);
    
    if (!ret) {
        /* Dont return exception in the method case */
	Py_INCREF(Py_None);
	return Py_None;
    }
    
    return PyString_FromString (value);
}
%%
override beagle_hit_get_properties kwargs
static PyObject *
_wrap_beagle_hit_get_properties (PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "key", NULL };
    char *key;
    GSList *list;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:BeagleHit.get_properties", kwlist, &key))
        return NULL;
    list = beagle_hit_get_properties (pyg_pointer_get(self, BeagleHit), key);
    
    if (list)
        return _helper_wrap_string_gslist (list);
    
    Py_INCREF(Py_None);
    return Py_None;
}
%%
override beagle_hit_get_all_properties noargs
static PyObject *
_wrap_beagle_hit_get_all_properties (PyGObject *self)
{
    GSList *list;

    list = beagle_hit_get_all_properties ((BeagleHit *) self->obj);

    return _helper_wrap_pointer_gslist (BEAGLE_TYPE_PROPERTY, list);
}
%%
override-slot BeagleHit.tp_as_mapping
static PyObject *
_wrap_beagle_hit_get_one_property_mapping (PyGObject *self, PyObject *item)
{
    char *key = NULL;
    const char *value = NULL;
    gboolean ret;

    if (! PyString_Check (item)) {
	    PyErr_SetString(PyExc_TypeError, "key must be a string");
	    return NULL;
    }

    key = PyString_AsString (item);
    ret = beagle_hit_get_one_property ((BeagleHit *) self->obj, key, &value);
    
    if (!ret) {
        PyErr_SetString(PyExc_KeyError, "key doesnt exist or is not single valued");
        return NULL;
    }
    
    return PyString_FromString (value);
    
}

static PyMappingMethods _wrap_beagle_hit_tp_as_mapping = {
    (inquiry) 0,					    /* number of properties as len (hit) */
    (binaryfunc) _wrap_beagle_hit_get_one_property_mapping, /* getting value of property as hit [...] */
    (objobjargproc) 0					    /* for setting value of property as hit[...] = X*/
};
%%
override beagle_client_new kwargs
static int
_wrap_beagle_client_new(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "client_name", NULL };
    char *client_name = NULL;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s:BeagleClient.__init__", kwlist, &client_name))
        return -1;
    self->obj = (GObject *)beagle_client_new(client_name);

    if (!self->obj) {
        PyErr_SetString(PyExc_RuntimeError, "could not create BeagleClient object");
        return -1;
    }
    pygobject_register_wrapper((PyObject *)self);
    return 0;
}
%%
override beagle_timestamp_to_unix_time
static PyObject *
_wrap_beagle_timestamp_to_unix_time (PyGObject *self)
{
    time_t t;
    gboolean ret;

    ret = beagle_timestamp_to_unix_time ((BeagleTimestamp *) self->obj, &t);

    if (!ret) {
	PyErr_SetString(PyExc_ValueError, "timestamp is invalid");
	return NULL;
    }

    return PyInt_FromLong (t);
}
%%
override beagle_scheduler_information_get_pending_tasks noargs
static PyObject *
_wrap_beagle_scheduler_information_get_pending_tasks (PyGObject *self)
{
    GSList *list;

    list = beagle_scheduler_information_get_pending_tasks ((BeagleSchedulerInformation *) self->obj);

    return _helper_wrap_string_gslist (list);
}
%%
override beagle_scheduler_information_get_future_tasks noargs
static PyObject *
_wrap_beagle_scheduler_information_get_future_tasks (PyGObject *self)
{
    GSList *list;

    list = beagle_scheduler_information_get_future_tasks ((BeagleSchedulerInformation *) self->obj);

    return _helper_wrap_string_gslist (list);
}
%%
override beagle_scheduler_information_get_blocked_tasks noargs
static PyObject *
_wrap_beagle_scheduler_information_get_blocked_tasks (PyGObject *self)
{
    GSList *list;

    list = beagle_scheduler_information_get_blocked_tasks ((BeagleSchedulerInformation *) self->obj);

    return _helper_wrap_string_gslist (list);
}
%%
override beagle_daemon_information_response_get_index_status
static PyObject *
_wrap_beagle_daemon_information_response_get_index_status (PyGObject *self)
{
    GSList *list;

    list = beagle_daemon_information_response_get_index_status ((BeagleDaemonInformationResponse *) self->obj);

    return _helper_wrap_pointer_gslist (BEAGLE_TYPE_QUERYABLE_STATUS, list);
}