/*

 *   Licensed under the Apache License, Version 2.0 (the "License");

 *   you may not use this file except in compliance with the License.

 *   You may obtain a copy of the License at

 *

 *       http://www.apache.org/licenses/LICENSE-2.0

 *

 *   Unless required by applicable law or agreed to in writing, software

 *   distributed under the License is distributed on an "AS IS" BASIS,

 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 *   See the License for the specific language governing permissions and

 *   limitations under the License.

 */

#ifdef PYTHON

#include <jni.h>

#include <Python.h>

#include "structmember.h"

#include "JArray.h"

#include "functions.h"

#include "java/lang/Class.h"

using namespace java::lang;

template<typename T> class _t_jarray : public t_jarray<T> {

public:

    static PyObject *format;

};

template<typename U>

static PyObject *get(U *self, int n)

{

    return self->array.get(n);

}

template<typename U>

static PyObject *toSequence(U *self)

{

    return self->array.toSequence();

}

template<typename U>

static PyObject *toSequence(U *self, int lo, int hi)

{

    return self->array.toSequence(lo, hi);

}

template<typename U> class _t_iterator {

public:

    PyObject_HEAD

    U *obj;

    Py_ssize_t position;

    static void dealloc(_t_iterator *self)

    {

        Py_XDECREF(self->obj);

        self->ob_type->tp_free((PyObject *) self);

    }

    static PyObject *iternext(_t_iterator *self)

    {

        if (self->position < (Py_ssize_t) self->obj->array.length)

            return get<U>(self->obj, self->position++);

        PyErr_SetNone(PyExc_StopIteration);

        return NULL;

    }

    static PyTypeObject *JArrayIterator;

};

template<typename T, typename U>

static int init(U *self, PyObject *args, PyObject *kwds)

{

    PyObject *obj;

    if (!PyArg_ParseTuple(args, "O", &obj))

        return -1;

    if (PySequence_Check(obj))

    {

        self->array = JArray<T>(obj);

        if (PyErr_Occurred())

            return -1;

    }

    else if (PyGen_Check(obj))

    {

        PyObject *tuple =

            PyObject_CallFunctionObjArgs((PyObject *) &PyTuple_Type, obj, NULL);

        if (!tuple)

            return -1;

        self->array = JArray<T>(tuple);

        Py_DECREF(tuple);

        if (PyErr_Occurred())

            return -1;

    }

    else if (PyInt_Check(obj))

    {

        int n = PyInt_AsLong(obj);

        if (n < 0)

        {

            PyErr_SetObject(PyExc_ValueError, obj);

            return -1;

        }

        self->array = JArray<T>(n);

    }

    else

    {

        PyErr_SetObject(PyExc_TypeError, obj);

        return -1;

    }

    return 0;

}

template<typename T, typename U>

static void dealloc(U *self)

{

    self->array = JArray<T>((jobject) NULL);

    self->ob_type->tp_free((PyObject *) self);

}

template<typename U>

static PyObject *_format(U *self, PyObject *(*fn)(PyObject *))

{

    if (self->array.this$)

    {

        PyObject *list = toSequence<U>(self);

        if (list)

        {

            PyObject *result = (*fn)(list);

            Py_DECREF(list);

            if (result)

            {

                PyObject *args = PyTuple_New(1);

                PyTuple_SET_ITEM(args, 0, result);

                result = PyString_Format(U::format, args);

                Py_DECREF(args);

                return result;

            }

        }

        return NULL;

    }

    return PyString_FromString("<null>");

}

template<typename U>

static PyObject *repr(U *self)

{

    return _format(self, (PyObject *(*)(PyObject *)) PyObject_Repr);

}

template<typename U>

static PyObject *str(U *self)

{

    return _format(self, (PyObject *(*)(PyObject *)) PyObject_Str);

}

template<typename U>

static int _compare(U *self, PyObject *value, int i0, int i1, int op, int *cmp)

{

    PyObject *v0 = get<U>(self, i0);

    PyObject *v1 = PySequence_Fast_GET_ITEM(value, i1);  /* borrowed */

    if (!v0)

        return -1;

    if (!v1)

    {

        Py_DECREF(v0);

        return -1;

    }

    *cmp = PyObject_RichCompareBool(v0, v1, op);

    Py_DECREF(v0);

    if (*cmp < 0)

        return -1;

    return 0;

}

template<typename U>

static PyObject *richcompare(U *self, PyObject *value, int op)

{

    PyObject *result = NULL;

    int s0, s1;

    if (!PySequence_Check(value))

    {

        Py_INCREF(Py_NotImplemented);

        return Py_NotImplemented;

    }

    value = PySequence_Fast(value, "not a sequence");

    if (!value)

        return NULL;

    s0 = PySequence_Fast_GET_SIZE(value);

    s1 = self->array.length;

    if (s1 < 0)

    {

        Py_DECREF(value);

        return NULL;

    }

    if (s0 != s1)

    {

        switch (op) {

          case Py_EQ: result = Py_False; break;

          case Py_NE: result = Py_True; break;

        }

    }

    if (!result)

    {

        int i0, i1, cmp = 1;

        for (i0 = 0, i1 = 0; i0 < s0 && i1 < s1 && cmp; i0++, i1++) {

            if (_compare(self, value, i0, i1, Py_EQ, &cmp) < 0)

            {

                Py_DECREF(value);

                return NULL;

            }                

        }

        if (cmp)

        {

            switch (op) {

              case Py_LT: cmp = s0 < s1; break;

              case Py_LE: cmp = s0 <= s1; break;

              case Py_EQ: cmp = s0 == s1; break;

              case Py_NE: cmp = s0 != s1; break;

              case Py_GT: cmp = s0 > s1; break;

              case Py_GE: cmp = s0 >= s1; break;

              default: cmp = 0;

            }

            result = cmp ? Py_True : Py_False;

        }

        else if (op == Py_EQ)

            result = Py_False;

        else if (op == Py_NE)

            result = Py_True;

        else if (_compare(self, value, i0, i1, op, &cmp) < 0)

        {

            Py_DECREF(value);

            return NULL;

        }

        else

            result = cmp ? Py_True : Py_False;

    }

    Py_DECREF(value);

    Py_INCREF(result);

    return result;

}

template<typename U>

static PyObject *iter(U *self)

{

    _t_iterator<U> *it =

        PyObject_New(_t_iterator<U>, _t_iterator<U>::JArrayIterator);

    if (it)

    {

        it->position = 0;

        it->obj = self; Py_INCREF((PyObject *) self);

    }

    return (PyObject *) it;

}

template<typename U>

static Py_ssize_t seq_length(U *self)

{

    if (self->array.this$)

        return self->array.length;

    return 0;

}

template<typename U>

static PyObject *seq_get(U *self, Py_ssize_t n)

{

    return get<U>(self, n);

}

template<typename U>

static int seq_contains(U *self, PyObject *value)

{

    return 0;

}

template<typename U>

static PyObject *seq_concat(U *self, PyObject *arg)

{

    PyObject *list = toSequence<U>(self);

    if (list != NULL &&

        PyList_Type.tp_as_sequence->sq_inplace_concat(list, arg) < 0)

    {

        Py_DECREF(list);

        return NULL;

    }

    return list;

}

template<typename U>

static PyObject *seq_repeat(U *self, Py_ssize_t n)

{

    PyObject *list = toSequence<U>(self);

    if (list != NULL &&

        PyList_Type.tp_as_sequence->sq_inplace_repeat(list, n) < 0)

    {

        Py_DECREF(list);

        return NULL;

    }

    return list;

}

template<typename U>

static PyObject *seq_getslice(U *self, Py_ssize_t lo, Py_ssize_t hi)

{

    return toSequence<U>(self, lo, hi);

}

template<typename U>

static int seq_set(U *self, Py_ssize_t n, PyObject *value)

{

    return self->array.set(n, value);

}

template<typename U>

static int seq_setslice(U *self, Py_ssize_t lo, Py_ssize_t hi, PyObject *values)

{

    int length = self->array.length;

    if (values == NULL)

    {

        PyErr_SetString(PyExc_ValueError, "array size cannot change");

        return -1;

    }

    if (lo < 0) lo = length + lo;

    if (lo < 0) lo = 0;

    else if (lo > length) lo = length;

    if (hi < 0) hi = length + hi;

    if (hi < 0) hi = 0;

    else if (hi > length) hi = length;

    if (lo > hi) lo = hi;

    PyObject *sequence = PySequence_Fast(values, "not a sequence");

    if (!sequence)

        return -1;