#ifndef _PY_TRIPLE_OBJ_H
#define _PY_TRIPLE_OBJ_H

#define PY_SSIZE_T_CLEAN

#include <Python.h>
#include <structmember.h>

#include "triple.h"
#include "term_obj.h"


typedef struct {
    PyObject_HEAD
    LSUP_Triple * ob_struct;
    TermObject *s;
    TermObject *p;
    TermObject *o;
} TripleObject;


static int
Triple_init (TripleObject *self, PyObject *args)
{
    TermObject *s = NULL, *p = NULL, *o = NULL, *tmp;

    if (! PyArg_ParseTuple (
    /*
                args, "O!O!O!", &s, &TermType,
                &p, &TermType, &o, &TermType))
    */
                args, "OOO", &s, &p, &o))
        return -1;

    // TODO check for null s, p, o
    if (
        PyObject_TypeCheck (s, &TermType) ||
        PyObject_TypeCheck (p, &TermType) ||
        PyObject_TypeCheck (o, &TermType)
    ) return -1;

    tmp = self->s;
    Py_INCREF(s);
    self->s = s;
    Py_XDECREF(tmp);

    tmp = self->p;
    Py_INCREF(p);
    self->p = p;
    Py_XDECREF(tmp);

    tmp = self->o;
    Py_INCREF(o);
    self->o = o;
    Py_XDECREF(tmp);

    self->ob_struct = LSUP_triple_new (
            s->ob_struct, p->ob_struct, o->ob_struct);
    if (!self->ob_struct) {
        PyErr_SetString (PyExc_ValueError, "Could not create triple.");
        return -1;
    }

    return 0;
}


static void
Triple_dealloc (TripleObject *self)
{
    Py_XDECREF(self->s);
    Py_XDECREF(self->p);
    Py_XDECREF(self->o);
    free (self->ob_struct); // Term pointers were allocated independently.
    Py_TYPE (self)->tp_free ((PyObject *) self);
}


static PyMemberDef Triple_members[] = {
    {"s", T_OBJECT_EX, offsetof(TripleObject, s), 0, "Triple subject,"},
    {"p", T_OBJECT_EX, offsetof(TripleObject, p), 0, "Triple predicate."},
    {"o", T_OBJECT_EX, offsetof(TripleObject, o), 0, "Triple object."},
    {NULL}
};


static PyObject *
Triple_richcmp (PyObject *obj1, PyObject *obj2, int op);


PyTypeObject TripleType = {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name = "triple.Triple",
    .tp_doc = "RDF triple",
    .tp_basicsize = sizeof(TripleObject),
    .tp_itemsize = 0,
    .tp_flags = Py_TPFLAGS_DEFAULT,
    .tp_new = PyType_GenericNew,
    .tp_init = (initproc) Triple_init,
    .tp_dealloc = (destructor) Triple_dealloc,
    .tp_members = Triple_members,
    .tp_richcompare = Triple_richcmp,
};


static PyObject *
Triple_richcmp (PyObject *obj1, PyObject *obj2, int op)
{
    PyObject *result = NULL;

    if (
        ! PyObject_TypeCheck (obj1, &TripleType) ||
        ! PyObject_TypeCheck (obj2, &TripleType)
    ) return NULL;

    int c = 0;
    LSUP_Triple *t1 = ((TripleObject *) obj1)->ob_struct;
    LSUP_Triple *t2 = ((TripleObject *) obj2)->ob_struct;

    switch (op) {
        case Py_LT: result = Py_NotImplemented; break;
        case Py_LE: result = Py_NotImplemented; break;
        case Py_EQ: c = (
                            LSUP_term_equals (t1->s, t2->s) &&
                            LSUP_term_equals (t1->p, t2->p) &&
                            LSUP_term_equals (t1->o, t2->o)); break;
        case Py_NE: c = (!
                            LSUP_term_equals (t1->s, t2->s) &&
                            LSUP_term_equals (t1->p, t2->p) &&
                            LSUP_term_equals (t1->o, t2->o)); break;
        case Py_GT: result = Py_NotImplemented; break;
        case Py_GE: result = Py_NotImplemented; break;
    }

    if (!result) result = c ? Py_True : Py_False;

    Py_INCREF(result);
    return result;
 }

#endif