#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <stdbool.h>

#include "./expr.h"

// static ExprObject*
// Expr_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
// {
//     ExprObject* self = (ExprObject *)type->tp_alloc(type, 0);
//     if (self != NULL) {
//         self->master = NULL;
//         self->pool   = NULL;
//         self->expr   = gu_null_variant;
//     }
//
//     return self;
// }
//
// static void
// Expr_dealloc(ExprObject* self)
// {
//     if (self->master != NULL) {
//         Py_DECREF(self->master);
//     }
//     if (self->pool != NULL) {
//         gu_pool_free(self->pool);
//     }
//
//     Py_TYPE(self)->tp_free((PyObject*)self);
// }
//
// static PyObject*
// Expr_getattro(ExprObject *self, PyObject *attr_name);
//
// static int
// Expr_initMeta(ExprObject *self);
//
// static int
// Expr_initLiteral(ExprObject *self, PyObject *lit);
//
// static int
// Expr_initApp(ExprObject *self, const char* fname, PyObject *args);
//
// static ExprObject*
// Expr_call(ExprObject* e, PyObject* args, PyObject* kw);
//
// static PyObject*
// Expr_unpack(ExprObject* self, PyObject *args);
//
// static PyObject*
// Expr_visit(ExprObject* self, PyObject *args);
//
// static PyObject*
// Expr_reduce_ex(ExprObject* self, PyObject *args);
//
// static int
// Expr_init(ExprObject *self, PyObject *args, PyObject *kwds)
// {
//     Py_ssize_t tuple_size = PyTuple_Size(args);
//
//     if (tuple_size == 0) {
//         return Expr_initMeta(self);
//     } else if (tuple_size == 1) {
//         PyObject* lit = NULL;
//         if (!PyArg_ParseTuple(args, "O", &lit))
//             return -1;
//         return Expr_initLiteral(self, lit);
//     } else if (tuple_size == 2) {
//         const char* fname;
//         PyObject* list = NULL;
//         if (!PyArg_ParseTuple(args, "sO!", &fname, &PyList_Type, &list))
//             return -1;
//         return Expr_initApp(self, fname, list);
//     } else {
//         PyErr_Format(PyExc_TypeError, "function takes 0, 1 or 2 arguments (%d given)", (int) tuple_size);
//         return -1;
//     }
//
//     return 0;
// }
//
// static PyObject *
// Expr_repr(ExprObject *self)
// {
//     GuPool* tmp_pool = gu_local_pool();
//
//     GuExn* err = gu_exn(tmp_pool);
//     GuStringBuf* sbuf = gu_new_string_buf(tmp_pool);
//     GuOut* out = gu_string_buf_out(sbuf);
//
//     pgf_print_expr(self->expr, NULL, 0, out, err);
//
//     PyObject* pystr = PyString_FromStringAndSize(gu_string_buf_data(sbuf),
//                                                  gu_string_buf_length(sbuf));
//
//     gu_pool_free(tmp_pool);
//     return pystr;
// }
//
// static PyObject *
// Expr_richcompare(ExprObject *e1, ExprObject *e2, int op)
// {
//     bool cmp = pgf_expr_eq(e1->expr,e2->expr);
//
//     if (op == Py_EQ) {
//         if (cmp) Py_RETURN_TRUE;  else Py_RETURN_FALSE;
//     } else if (op == Py_NE) {
//         if (cmp) Py_RETURN_FALSE; else Py_RETURN_TRUE;
//     } else {
//         PyErr_SetString(PyExc_TypeError, "the operation is not supported");
//         return NULL;
//     }
// }
//
// static long
// Expr_hash(ExprObject *e)
// {
//     return (long) pgf_expr_hash(0, e->expr);
// }
//
// static PyMethodDef Expr_methods[] = {
//     {"unpack", (PyCFunction)Expr_unpack, METH_VARARGS,
//      "Decomposes an expression into its components"
//     },
//     {"visit", (PyCFunction)Expr_visit, METH_VARARGS,
//      "Implementation of the visitor pattern for abstract syntax trees. "
//      "If e is an expression equal to f a1 .. an then "
//      "e.visit(self) calls method self.on_f(a1,..an). "
//      "If the method doesn't exist then the method self.default(e) "
//      "is called."
//     },
//     {"__reduce_ex__", (PyCFunction)Expr_reduce_ex, METH_VARARGS,
//      "This method allows for transparent pickling/unpickling of expressions."
//     },
//     {NULL}  /* Sentinel */
// };
//
// static PyGetSetDef Expr_getseters[] = {
//     {"fun",
//      NULL, NULL,
//      "this is the function in a function application",
//      NULL},
//     {"arg",
//      NULL, NULL,
//      "this is the argument in a function application",
//      NULL},
//     {"val",
//      NULL, NULL,
//      "this is the value of a literal",
//      NULL},
//     {"id",
//      NULL, NULL,
//      "this is the id of a meta variable",
//      NULL},
//     {"name",
//      NULL, NULL,
//      "this is the name of a function",
//      NULL},
//     {"index",
//      NULL, NULL,
//      "this is the de Bruijn index of a variable",
//      NULL},
//     {NULL}  /* Sentinel */
// };
//
// static PyTypeObject pgf_ExprType = {
//     PyVarObject_HEAD_INIT(NULL, 0)
//     //0,                         /*ob_size*/
//     "pgf.Expr",                /*tp_name*/
//     sizeof(ExprObject),        /*tp_basicsize*/
//     0,                         /*tp_itemsize*/
//     (destructor)Expr_dealloc,  /*tp_dealloc*/
//     0,                         /*tp_print*/
//     0,                         /*tp_getattr*/
//     0,                         /*tp_setattr*/
//     0,                         /*tp_compare*/
//     0,                         /*tp_repr*/
//     0,                         /*tp_as_number*/
//     0,                         /*tp_as_sequence*/
//     0,                         /*tp_as_mapping*/
//     (hashfunc) Expr_hash,      /*tp_hash */
//     (ternaryfunc) Expr_call,   /*tp_call*/
//     (reprfunc) Expr_repr,      /*tp_str*/
//     (getattrofunc) Expr_getattro,/*tp_getattro*/
//     0,                         /*tp_setattro*/
//     0,                         /*tp_as_buffer*/
//     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
//     "abstract syntax tree",    /*tp_doc*/
//     0,                           /*tp_traverse */
//     0,                           /*tp_clear */
//     (richcmpfunc) Expr_richcompare, /*tp_richcompare */
//     0,                           /*tp_weaklistoffset */
//     0,                           /*tp_iter */
//     0,                           /*tp_iternext */
//     Expr_methods,              /*tp_methods */
//     0,                         /*tp_members */
//     Expr_getseters,            /*tp_getset */
//     0,                         /*tp_base */
//     0,                         /*tp_dict */
//     0,                         /*tp_descr_get */
//     0,                         /*tp_descr_set */
//     0,                         /*tp_dictoffset */
//     (initproc)Expr_init,       /*tp_init */
//     0,                         /*tp_alloc */
//     (newfunc) Expr_new,        /*tp_new */
// };
//
// static int
// Expr_initMeta(ExprObject *self)
// {
//     self->master = NULL;
//     self->pool = gu_new_pool();
//     PgfExprMeta* e =
//         gu_new_variant(PGF_EXPR_META,
//                        PgfExprMeta,
//                        &self->expr, self->pool);
//     e->id = 0;
//     return 0;
// }
//
// static int
// Expr_initLiteral(ExprObject *self, PyObject *lit)
// {
//     self->master = NULL;
//     self->pool   = gu_new_pool();
//     PgfExprLit* e =
//         gu_new_variant(PGF_EXPR_LIT,
//                        PgfExprLit,
//                        &self->expr, self->pool);
//     e->lit = gu_null_variant;
//
//     if (PyString_Check(lit)) {
//         char* s;
//         Py_ssize_t len;
//
// #if PY_MAJOR_VERSION >= 3
//         PyObject* bytes = PyUnicode_AsUTF8String(lit);
//         if (bytes == NULL)
//             return -1;
//         if (PyBytes_AsStringAndSize(bytes,&s,&len) < 0)
//             return -1;
// #else
//         if (PyString_AsStringAndSize(lit,&s,&len) < 0)
//             return -1;
// #endif
//
//         PgfLiteralStr* slit =
//             gu_new_flex_variant(PGF_LITERAL_STR,
//                                 PgfLiteralStr,
//                                 val, len+1,
//                                 &e->lit, self->pool);
//         memcpy(slit->val, s, len+1);
//
// #if PY_MAJOR_VERSION >= 3
//         Py_DECREF(bytes);
// #endif
//     } else if (PyInt_Check(lit)) {
//         PgfLiteralInt* ilit =
//             gu_new_variant(PGF_LITERAL_INT,
//                            PgfLiteralInt,
//                            &e->lit, self->pool);
//         ilit->val = PyInt_AsLong(lit);
//     } else if (PyFloat_Check(lit)) {
//         PgfLiteralFlt* flit =
//             gu_new_variant(PGF_LITERAL_FLT,
//                            PgfLiteralFlt,
//                            &e->lit, self->pool);
//         flit->val = PyFloat_AsDouble(lit);
//     } else {
//         PyErr_SetString(PyExc_TypeError, "the literal must be a string, an integer, or a float");
//         return -1;
//     }
//     return 0;
// }
//
// static int
// Expr_initApp(ExprObject *self, const char* fname, PyObject *args)
// {
//     Py_ssize_t n_args = PyList_Size(args);
//
//     self->master = PyTuple_New(n_args);
//     if (self->master == NULL)
//         return -1;
//
//     self->pool = gu_new_pool();
//     PgfExprFun* e =
//         gu_new_flex_variant(PGF_EXPR_FUN,
//                             PgfExprFun,
//                             fun, strlen(fname)+1,
//                             &self->expr, self->pool);
//     strcpy(e->fun, fname);
//
//     for (Py_ssize_t i = 0; i < n_args; i++) {
//         PyObject* obj = PyList_GetItem(args, i);
//         if (obj->ob_type != &pgf_ExprType) {
//             PyErr_SetString(PyExc_TypeError, "the arguments in the list must be expressions");
//             return -1;
//         }
//
//         PyTuple_SetItem(self->master, i, obj);
//         Py_INCREF(obj);
//
//         PgfExpr fun = self->expr;
//         PgfExpr arg = ((ExprObject*) obj)->expr;
//
//         PgfExprApp* e =
//             gu_new_variant(PGF_EXPR_APP,
//                            PgfExprApp,
//                            &self->expr, self->pool);
//         e->fun = fun;
//         e->arg = arg;
//     }
//
//     return 0;
// }
//
// static ExprObject*
// Expr_call(ExprObject* self, PyObject* args, PyObject* kw)
// {
//     ExprObject* pyexpr = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0);
//     if (pyexpr == NULL)
//         return NULL;
//
//     size_t n_args = PyTuple_Size(args);
//
//     pyexpr->master = PyTuple_New(n_args+1);
//     if (pyexpr->master == NULL) {
//         Py_DECREF(pyexpr);
//         return NULL;
//     }
//
//     PyTuple_SetItem(pyexpr->master, 0, (PyObject*) self);
//     Py_INCREF(self);
//
//     pyexpr->pool = gu_new_pool();
//     pyexpr->expr = self->expr;
//
//     for (Py_ssize_t i = 0; i < n_args; i++) {
//         PyObject* obj = PyTuple_GetItem(args, i);
//         if (obj->ob_type != &pgf_ExprType) {
//             PyErr_SetString(PyExc_TypeError, "the arguments must be expressions");
//             return NULL;
//         }
//
//         PyTuple_SetItem(pyexpr->master, i+1, obj);
//         Py_INCREF(obj);
//
//         PgfExpr fun = pyexpr->expr;
//         PgfExpr arg = ((ExprObject*) obj)->expr;
//
//         PgfExprApp* e =
//             gu_new_variant(PGF_EXPR_APP,
//                            PgfExprApp,
//                            &pyexpr->expr, pyexpr->pool);
//         e->fun = fun;
//         e->arg = arg;
//     }
//
//     return pyexpr;
// }
//
// static PyObject*
// Expr_unpack(ExprObject* self, PyObject *fargs)
// {
//     PgfExpr expr = self->expr;
//     PyObject* args = PyList_New(0);
//
//     for (;;) {
//         GuVariantInfo i = gu_variant_open(expr);
//         switch (i.tag) {
//         case PGF_EXPR_ABS: {
//             PgfExprAbs* eabs = i.data;
//
//             ExprObject* py_body = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0);
//             if (py_body == NULL) {
//                 Py_DECREF(args);
//                 return NULL;
//             }
//             py_body->pool   = NULL;
//             py_body->master = (self->master) ? self->master : (PyObject*) self;
//             py_body->expr   = eabs->body;
//             Py_INCREF(py_body->master);
//
//             PyObject* py_bindtype =
//                 (eabs->bind_type == PGF_BIND_TYPE_EXPLICIT) ? Py_True
//                                                             : Py_False;
//             PyObject* py_var = PyString_FromString(eabs->id);
//             PyObject* res =
//                 Py_BuildValue("OOOO", py_bindtype, py_var, py_body, args);
//             Py_DECREF(py_var);
//             Py_DECREF(py_body);
//             Py_DECREF(args);
//             return res;
//         }
//         case PGF_EXPR_APP: {
//             PgfExprApp* eapp = i.data;
//
//             ExprObject* pyexpr = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0);
//             if (pyexpr == NULL) {
//                 Py_DECREF(args);
//                 return NULL;
//             }
//             pyexpr->pool   = NULL;
//             pyexpr->master = (self->master) ? self->master : (PyObject*) self;
//             pyexpr->expr   = eapp->arg;
//             Py_INCREF(pyexpr->master);
//
//             if (PyList_Insert(args, 0, (PyObject*) pyexpr) == -1) {
//                 Py_DECREF(args);
//                 return NULL;
//             }
//
//             Py_DECREF((PyObject*) pyexpr);
//
//             expr = eapp->fun;
//             break;
//         }
//         case PGF_EXPR_LIT: {
//             PgfExprLit* elit = i.data;
//
//             Py_DECREF(args);
//
//             GuVariantInfo i = gu_variant_open(elit->lit);
//             switch (i.tag) {
//             case PGF_LITERAL_STR: {
//                 PgfLiteralStr* lstr = i.data;
//                 return PyString_FromString(lstr->val);
//             }
//             case PGF_LITERAL_INT: {
//                 PgfLiteralInt* lint = i.data;
//                 return PyInt_FromLong(lint->val);
//             }
//             case PGF_LITERAL_FLT: {
//                 PgfLiteralFlt* lflt = i.data;
//                 return PyFloat_FromDouble(lflt->val);
//             }
//             default:
//                 gu_impossible();
//                 return NULL;
//             }
//         }
//         case PGF_EXPR_META: {
//             PyObject* res = Py_BuildValue("OO", Py_None, args);
//             Py_DECREF(args);
//             return res;
//         }
//         case PGF_EXPR_FUN: {
//             PgfExprFun* efun = i.data;
//             PyObject* fun = PyString_FromString(efun->fun);
//             PyObject* res = Py_BuildValue("OO", fun, args);
//             Py_DECREF(fun);
//             Py_DECREF(args);
//             return res;
//         }
//         case PGF_EXPR_VAR: {
//             PgfExprVar* evar = i.data;
//             PyObject* res = Py_BuildValue("iO", evar->var, args);
//             Py_DECREF(args);
//             return res;
//         }
//         case PGF_EXPR_TYPED: {
//             PgfExprTyped* etyped = i.data;
//             expr = etyped->expr;
//             break;
//         }
//         case PGF_EXPR_IMPL_ARG: {
//             PgfExprImplArg* eimpl = i.data;
//             expr = eimpl->expr;
//             break;
//         }
//         default:
//             gu_impossible();
//             return NULL;
//         }
//     }
//     return NULL;
// }
//
// static PyObject*
// Expr_visit(ExprObject* self, PyObject *args)
// {
//     PyObject* py_visitor = NULL;
//     PgfExpr expr = self->expr;
//     if (!PyArg_ParseTuple(args, "O", &py_visitor))
//         return NULL;
//
//     GuPool* tmp_pool = gu_local_pool();
//
//     PgfApplication* app = pgf_expr_unapply(expr, tmp_pool);
//     if (app != NULL) {
//         char* method_name = gu_malloc(tmp_pool, strlen(app->fun)+4);
//         strcpy(method_name, "on_");
//         strcat(method_name, app->fun);
//
//         if (PyObject_HasAttrString(py_visitor, method_name)) {
//             PyObject* method_args = PyTuple_New(app->n_args);
//             if (method_args == NULL) {
//                 gu_pool_free(tmp_pool);
//                 return NULL;
//             }
//
//             for (size_t i = 0; i < app->n_args; i++) {
//                 ExprObject* pyarg = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0);
//                 if (pyarg == NULL) {
//                     Py_DECREF(args);
//                     gu_pool_free(tmp_pool);
//                     return NULL;
//                 }
//                 pyarg->pool   = NULL;
//                 pyarg->master = (self->master) ? self->master : (PyObject*) self;
//                 pyarg->expr   = app->args[i];
//                 Py_INCREF(pyarg->master);
//
//                 if (PyTuple_SetItem(method_args, i, (PyObject*) pyarg) == -1) {
//                     Py_DECREF(args);
//                     gu_pool_free(tmp_pool);
//                     return NULL;
//                 }
//             }
//
//             PyObject* method =
//                 PyObject_GetAttrString(py_visitor, method_name);
//             if (method == NULL) {
//                 Py_DECREF(args);
//                 gu_pool_free(tmp_pool);
//                 return NULL;
//             }
//
//             gu_pool_free(tmp_pool);
//
//             return PyObject_CallObject(method, method_args);
//         }
//     }
//
//     gu_pool_free(tmp_pool);
//
//     return PyObject_CallMethod(py_visitor, "default", "O", self);
// }
//
// static PyObject*
// Expr_reduce_ex(ExprObject* self, PyObject *args)
// {
//     int protocol;
//     if (!PyArg_ParseTuple(args, "i", &protocol))
//         return NULL;
//
//     PyObject* myModule = PyImport_ImportModule("pgf");
//     if (myModule == NULL)
//         return NULL;
//     PyObject* py_readExpr = PyObject_GetAttrString(myModule, "readExpr");
//     Py_DECREF(myModule);
//     if (py_readExpr == NULL)
//         return NULL;
//
//     PyObject* py_str = Expr_repr(self);
//     if (py_str == NULL) {
//         Py_DECREF(py_readExpr);
//         return NULL;
//     }
//
//     PyObject* py_tuple =
//         Py_BuildValue("O(O)", py_readExpr, py_str);
//
//     Py_DECREF(py_str);
//     Py_DECREF(py_readExpr);
//
//     return py_tuple;
// }
//
// static PyObject*
// Expr_getattro(ExprObject *self, PyObject *attr_name) {
// #if PY_MAJOR_VERSION >= 3
// #define IS_ATTR(attr) (PyUnicode_CompareWithASCIIString(attr_name,attr) == 0)
// #else
//     const char* name = PyString_AsString(attr_name);
// #define IS_ATTR(attr) (strcmp(name, attr) == 0)
// #endif
//
//     PgfExpr expr = self->expr;
//
// redo:;
//     GuVariantInfo i = gu_variant_open(expr);
//     switch (i.tag) {
//     case PGF_EXPR_APP: {
//         PgfExprApp* eapp = i.data;
//
//         ExprObject* pyexpr = (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0);
//         if (pyexpr == NULL)
//             return NULL;
//         pyexpr->pool   = NULL;
//         pyexpr->master = (self->master) ? self->master : (PyObject*) self;
//         pyexpr->expr   = gu_null_variant;
//         Py_INCREF(pyexpr->master);
//
//         if (IS_ATTR("fun")) {
//             pyexpr->expr = eapp->fun;
//             return ((PyObject*) pyexpr);
//         } else if (IS_ATTR("arg")) {
//             pyexpr->expr = eapp->arg;
//             return ((PyObject*) pyexpr);
//         } else {
//             Py_DECREF(pyexpr);
//         }
//         break;
//     }
//     case PGF_EXPR_LIT: {
//         PgfExprLit* elit = i.data;
//
//         if (IS_ATTR("val")) {
//             GuVariantInfo i = gu_variant_open(elit->lit);
//             switch (i.tag) {
//             case PGF_LITERAL_INT: {
//                 PgfLiteralInt* lint = i.data;
//                 return PyInt_FromLong(lint->val);
//             }
//             case PGF_LITERAL_FLT: {
//                 PgfLiteralFlt* lflt = i.data;
//                 return PyFloat_FromDouble(lflt->val);
//             }
//             case PGF_LITERAL_STR: {
//                 PgfLiteralStr* lstr = i.data;
//                 return PyString_FromString(lstr->val);
//             }
//             }
//         }
//         break;
//     }
//     case PGF_EXPR_META: {
//         PgfExprMeta* emeta = i.data;
//         if (IS_ATTR("id"))
//             return PyInt_FromLong(emeta->id);
//         break;
//     }
//     case PGF_EXPR_FUN: {
//         PgfExprFun* efun = i.data;
//         if (IS_ATTR("name")) {
//             return PyString_FromString(efun->fun);
//         }
//         break;
//     }
//     case PGF_EXPR_VAR: {
//         PgfExprVar* evar = i.data;
//         if (IS_ATTR("index")) {
//             return PyInt_FromLong(evar->var);
//         }
//         break;
//     }
//     case PGF_EXPR_TYPED: {
//         PgfExprTyped* etyped = i.data;
//         expr = etyped->expr;
//         goto redo;
//     }
//     case PGF_EXPR_IMPL_ARG: {
//         PgfExprImplArg* eimpl = i.data;
//         expr = eimpl->expr;
//         goto redo;
//     }
//     default:
//         gu_impossible();
//     }
//
//     return PyObject_GenericGetAttr((PyObject*)self, attr_name);
// }

// ----------------------------------------------------------------------------

// static TypeObject*
// Type_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
// {
//     TypeObject* self = (TypeObject *)type->tp_alloc(type, 0);
//     if (self != NULL) {
//         self->hypos = NULL;
//         self->cat = NULL;
//         self->exprs = NULL;
//     }
//
//     return self;
// }

// static void
// Type_dealloc(TypeObject *self)
// {
//     Py_TYPE(self)->tp_free((PyObject*)self);
// }

// static int
// Type_init(TypeObject *self, PyObject *args, PyObject *kwds)
// {
//     PyObject* py_hypos;
//     const char* catname_s;
//     PyObject* py_exprs;
//     size_t n_exprs;
//     size_t n_hypos;
//
//     if (PyTuple_Size(args) == 1) {
//         py_hypos = NULL;
//         py_exprs = NULL;
//         n_exprs  = 0;
//         n_hypos  = 0;
//         if (!PyArg_ParseTuple(args, "s", &catname_s))
//             return -1;
//     } else {
//         if (!PyArg_ParseTuple(args, "O!sO!",
//                 &PyList_Type, &py_hypos,
//                 &catname_s,
//                 &PyList_Type, &py_exprs))
//             return -1;
//
//         n_exprs = PyList_Size(py_exprs);
//         n_hypos = PyList_Size(py_hypos);
//     }
//
//     self->pool = gu_new_pool();
//     self->master =
//         (n_exprs+n_hypos > 0) ? PyTuple_New(n_exprs+n_hypos) : NULL;
//
//     self->type = gu_new_flex(self->pool, PgfType, exprs, n_exprs);
//
//     self->type->hypos =
//         gu_new_seq(PgfHypo, n_hypos, self->pool);
//
//     for (size_t i = 0; i < n_hypos; i++) {
//         PyObject* obj = PyList_GetItem(py_hypos, i);
//         PyObject* py_bindtype;
//         PgfCId cid;
//         PyObject* py_type;
//
//         if (Py_TYPE(obj) == &pgf_TypeType) {
//             py_bindtype = Py_True;
//             cid = "_";
//             py_type = obj;
//         } else {
//             if (!PyTuple_Check(obj) ||
//                 PyTuple_GET_SIZE(obj) != 3) {
//                 PyErr_SetString(PyExc_TypeError, "the arguments in the first list must be triples of (boolean,string,pgf.Type)");
//                 return -1;
//             }
//
//             py_bindtype = PyTuple_GetItem(obj, 0);
//             if (!PyBool_Check(py_bindtype)) {
//                 PyErr_SetString(PyExc_TypeError, "the arguments in the first list must be triples of (boolean,string,pgf.Type)");
//                 return -1;
//             }
//
//             PyObject* py_var = PyTuple_GetItem(obj, 1);
//             if (!PyString_Check(py_var)) {
//                 PyErr_SetString(PyExc_TypeError, "the arguments in the first list must be triples of (boolean,string,pgf.Type)");
//                 return -1;
//             }
//
//             {
//                 char* s;
//                 Py_ssize_t len;
//
// #if PY_MAJOR_VERSION >= 3
//                 PyObject* bytes = PyUnicode_AsUTF8String(py_var);
//                 if (bytes == NULL)
//                     return -1;
//                 if (PyBytes_AsStringAndSize(bytes,&s,&len) < 0)
//                     return -1;
// #else
//                 if (PyString_AsStringAndSize(py_var,&s,&len) < 0)
//                     return -1;
// #endif
//
//                 cid = gu_malloc(self->pool, len+1);
//                 memcpy((char*)cid, s, len+1);
//
// #if PY_MAJOR_VERSION >= 3
//                 Py_DECREF(bytes);
// #endif
//             }
//
//             py_type = PyTuple_GetItem(obj, 2);
//             if (Py_TYPE(py_type) != &pgf_TypeType) {
//                 PyErr_SetString(PyExc_TypeError, "the arguments in the first list must be triples of (boolean,string,pgf.Type)");
//                 return -1;
//             }
//         }
//
//         PgfHypo* hypo = gu_seq_index(self->type->hypos, PgfHypo, i);
//         hypo->bind_type =
//             (py_bindtype == Py_True) ? PGF_BIND_TYPE_EXPLICIT
//                                      : PGF_BIND_TYPE_IMPLICIT;
//         hypo->cid = cid;
//         hypo->type = ((TypeObject*) py_type)->type;
//
//         PyTuple_SetItem(self->master, i, py_type);
//         Py_INCREF(py_type);
//     }
//
//     self->type->cid = gu_string_copy(catname_s, self->pool);
//
//     self->type->n_exprs = n_exprs;
//     for (Py_ssize_t i = 0; i < n_exprs; i++) {
//         PyObject* obj = PyList_GetItem(py_exprs, i);
//         if (Py_TYPE(obj) != &pgf_ExprType) {
//             PyErr_SetString(PyExc_TypeError, "the arguments in the second list must be expressions");
//             return -1;
//         }
//
//         PyTuple_SetItem(self->master, n_hypos+i, obj);
//         Py_INCREF(obj);
//
//         self->type->exprs[i] = ((ExprObject*) obj)->expr;
//     }
//
//     return 0;
// }

static PyObject *
Type_repr(TypeObject *self)
{
    // GuPool* tmp_pool = gu_local_pool();
    //
    // GuExn* err = gu_exn(tmp_pool);
    // GuStringBuf* sbuf = gu_new_string_buf(tmp_pool);
    // GuOut* out = gu_string_buf_out(sbuf);
    //
    // pgf_print_type(self->type, NULL, 0, out, err);
    //
    // PyObject* pystr = PyString_FromStringAndSize(gu_string_buf_data(sbuf),
    //                                              gu_string_buf_length(sbuf));
    //
    // gu_pool_free(tmp_pool);
    // return pystr;

    PyErr_SetString(PyExc_TypeError, "Type_repr: not implemented");
    Py_RETURN_NOTIMPLEMENTED;
}

static PyObject *
Type_richcompare(TypeObject *t1, TypeObject *t2, int op)
{
    bool same = false;
    if (PyString_Compare(t1->cat, t2->cat) != 0) goto done;

    if (PyList_Size(t1->hypos) != PyList_Size(t2->hypos)) goto done;
    for (Py_ssize_t n = 0; n < PyList_Size(t1->hypos); n++) {
        PyObject *h1 = PyList_GetItem(t1->hypos, n);
        PyObject *h2 = PyList_GetItem(t2->hypos, n);
        if (PyTuple_GetItem(h1, 0) != PyTuple_GetItem(h2, 0)) goto done;
        if (PyString_Compare(PyTuple_GetItem(h1, 1), PyTuple_GetItem(h2, 1)) != 0) goto done;
        TypeObject *ht1 = (TypeObject *)PyTuple_GetItem(h1, 2);
        TypeObject *ht2 = (TypeObject *)PyTuple_GetItem(h2, 2);
        if (Type_richcompare(ht1, ht2, Py_EQ) != Py_True) goto done;
    }

    if (PyList_Size(t1->exprs) != PyList_Size(t2->exprs)) goto done;
    // for (Py_ssize_t n = 0; n < PyList_Size(t1->exprs); n++) {
    //     ExprObject *e1 = PyList_GetItem(t1->exprs, n);
    //     ExprObject *e2 = PyList_GetItem(t2->exprs, n);
    //     if (Expr_richcompare(e1, e2, Py_EQ) != Py_True) goto done; // TODO
    // }

    same = true;
done:

    if (op == Py_EQ) {
        if (same) Py_RETURN_TRUE;  else Py_RETURN_FALSE;
    } else if (op == Py_NE) {
        if (same) Py_RETURN_FALSE; else Py_RETURN_TRUE;
    } else {
        PyErr_SetString(PyExc_TypeError, "comparison operation not supported");
        Py_RETURN_NOTIMPLEMENTED;
    }
}

// static PyObject*
// Type_getHypos(TypeObject *self, void *closure)
// {
//     PgfType* type = self->type;
//
//     PyObject* py_hypos = PyList_New(0);
//     if (py_hypos == NULL)
//         return NULL;
//
//     size_t n_hypos = gu_seq_length(type->hypos);
//     for (size_t i = 0; i < n_hypos; i++) {
//         PgfHypo* hypo = gu_seq_index(type->hypos, PgfHypo, i);
//
//         PyObject* py_bindtype =
//             (hypo->bind_type == PGF_BIND_TYPE_EXPLICIT) ? Py_True
//                                                           : Py_False;
//
//         PyObject* py_var = PyString_FromString(hypo->cid);
//         if (py_var == NULL)
//             goto fail;
//
//         TypeObject* py_type = (TypeObject*) pgf_TypeType.tp_alloc(&pgf_TypeType, 0);
//         if (py_type == NULL) {
//             Py_DECREF(py_var);
//             goto fail;
//         }
//
//         py_type->pool   = NULL;
//         py_type->master = (PyObject*) self;
//         py_type->type   = hypo->type;
//         Py_INCREF(self);
//
//         PyObject* py_hypo =
//             Py_BuildValue("OOO", py_bindtype, py_var, py_type);
//         Py_DECREF(py_var);
//         Py_DECREF(py_type);
//
//         if (py_hypo == NULL)
//             goto fail;
//
//         if (PyList_Append(py_hypos, (PyObject*) py_hypo) == -1)
//             goto fail;
//
//         Py_DECREF(py_hypo);
//     }
//
//     return py_hypos;
//
// fail:
//     Py_DECREF(py_hypos);
//     return NULL;
// }
//
// static PyObject*
// Type_getCat(TypeObject *self, void *closure)
// {
//     return PyString_FromString(self->type->cid);
// }
//
// static PyObject*
// Type_getExprs(TypeObject *self, void *closure)
// {
//     PgfType* type = self->type;
//
//     PyObject* py_exprs = PyList_New(0);
//     if (py_exprs == NULL)
//         return NULL;
//
//     for (size_t i = 0; i < type->n_exprs; i++) {
//         ExprObject* py_expr =
//             (ExprObject*) pgf_ExprType.tp_alloc(&pgf_ExprType, 0);
//         if (py_expr == NULL)
//             goto fail;
//         py_expr->pool   = NULL;
//         py_expr->master = (PyObject*) self;
//         py_expr->expr   = type->exprs[i];
//         Py_INCREF(py_expr->master);
//
//         if (PyList_Append(py_exprs, (PyObject*) py_expr) == -1)
//             goto fail;
//
//         Py_DECREF((PyObject*) py_expr);
//     }
//
//     return py_exprs;
//
// fail:
//     Py_DECREF(py_exprs);
//     return NULL;
// }
//
// static PyObject*
// Type_unpack(TypeObject* self, PyObject *fargs)
// {
//     PyObject* res = NULL;
//     PyObject* py_hypos = NULL;
//     PyObject* py_cat = NULL;
//     PyObject* py_exprs = NULL;
//
//     py_hypos = Type_getHypos(self, NULL);
//     if (py_hypos == NULL)
//         goto fail;
//
//     py_cat = Type_getCat(self, NULL);
//     if (py_cat == NULL)
//         goto fail;
//
//     py_exprs = Type_getExprs(self, NULL);
//     if (py_exprs == NULL)
//         goto fail;
//
//     res = Py_BuildValue("OOO", py_hypos, py_cat, py_exprs);
//
// fail:
//     Py_XDECREF(py_hypos);
//     Py_XDECREF(py_cat);
//     Py_XDECREF(py_exprs);
//     return res;
// }
//
// static PyObject*
// Type_reduce_ex(TypeObject* self, PyObject *args)
// {
//     int protocol;
//     if (!PyArg_ParseTuple(args, "i", &protocol))
//         return NULL;
//
//     PyObject* myModule = PyImport_ImportModule("pgf");
//     if (myModule == NULL)
//         return NULL;
//     PyObject* py_readType = PyObject_GetAttrString(myModule, "readType");
//     Py_DECREF(myModule);
//     if (py_readType == NULL)
//         return NULL;
//
//     PyObject* py_str = Type_repr(self);
//     if (py_str == NULL) {
//         Py_DECREF(py_readType);
//         return NULL;
//     }
//
//     PyObject* py_tuple =
//         Py_BuildValue("O(O)", py_readType, py_str);
//
//     Py_DECREF(py_str);
//     Py_DECREF(py_readType);
//
//     return py_tuple;
// }
//
static PyMethodDef Type_methods[] = {
//     {"unpack", (PyCFunction)Type_unpack, METH_VARARGS,
//      "Decomposes a type into its components"
//     },
//     {"__reduce_ex__", (PyCFunction)Type_reduce_ex, METH_VARARGS,
//      "This method allows for transparent pickling/unpickling of types."
//     },
    {NULL}  /* Sentinel */
};

static PyGetSetDef Type_getseters[] = {
//     {"hypos",
//      (getter)Type_getHypos, NULL,
//      "this is the list of hypotheses in the type signature",
//      NULL},
//     {"cat",
//      (getter)Type_getCat, NULL,
//      "this is the name of the category",
//      NULL},
//     {"exprs",
//      (getter)Type_getExprs, NULL,
//      "this is the list of indices for the category",
//      NULL},
    {NULL}  /* Sentinel */
};

/* static */
PyTypeObject pgf_TypeType = {
    PyVarObject_HEAD_INIT(NULL, 0)
    //0,                         /*ob_size*/
    "pgf.Type",                /*tp_name*/
    sizeof(TypeObject),        /*tp_basicsize*/
    0,                         /*tp_itemsize*/
    0, //(destructor) Type_dealloc, /*tp_dealloc*/
    0,                         /*tp_print*/
    0,                         /*tp_getattr*/
    0,                         /*tp_setattr*/
    0,                         /*tp_compare*/
    0,                         /*tp_repr*/
    0,                         /*tp_as_number*/
    0,                         /*tp_as_sequence*/
    0,                         /*tp_as_mapping*/
    0,                         /*tp_hash */
    0,                         /*tp_call*/
    (reprfunc) Type_repr,      /*tp_str*/
    0,                         /*tp_getattro*/
    0,                         /*tp_setattro*/
    0,                         /*tp_as_buffer*/
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
    "abstract syntax type",    /*tp_doc*/
    0,                         /*tp_traverse */
    0,                         /*tp_clear */
    (richcmpfunc) Type_richcompare, /*tp_richcompare */
    0,                         /*tp_weaklistoffset */
    0,                         /*tp_iter */
    0,                         /*tp_iternext */
    Type_methods,              /*tp_methods */
    0,                         /*tp_members */
    Type_getseters,            /*tp_getset */
    0,                         /*tp_base */
    0,                         /*tp_dict */
    0,                         /*tp_descr_get */
    0,                         /*tp_descr_set */
    0,                         /*tp_dictoffset */
    0, //(initproc) Type_init,      /*tp_init */
    0,                         /*tp_alloc */
    0, //(newfunc) Type_new,        /*tp_new */
};