/*

 *   Copyright (c) 2007-2008 Open Source Applications Foundation

 *

 *   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.

 */

#ifndef _JArray_H

#define _JArray_H

#ifdef PYTHON

#include <Python.h>

#include "macros.h"

extern jobjectArray fromPySequence(jclass cls, PyObject *sequence);

extern PyObject *PyErr_SetJavaError(jthrowable throwable);

extern PyTypeObject *JArrayObject$$Type;

extern PyTypeObject *JArrayString$$Type;

extern PyTypeObject *JArrayBool$$Type;

extern PyTypeObject *JArrayByte$$Type;

extern PyTypeObject *JArrayChar$$Type;

extern PyTypeObject *JArrayDouble$$Type;

extern PyTypeObject *JArrayFloat$$Type;

extern PyTypeObject *JArrayInt$$Type;

extern PyTypeObject *JArrayLong$$Type;

extern PyTypeObject *JArrayShort$$Type;

#endif

#include "JCCEnv.h"

#include "java/lang/Object.h"

template<typename T> class JArray : public java::lang::Object {

public:

    int length;

    explicit JArray<T>(jobject obj) : java::lang::Object(obj) {

        length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;

    }

    JArray<T>(const JArray<T>& obj) : java::lang::Object(obj) {

        length = obj.length;

    }

#ifdef PYTHON

    JArray<T>(PyObject *sequence) : java::lang::Object(fromPySequence(T::initializeClass(), sequence)) {

        length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;

    }

    JArray<T>(jclass cls, PyObject *sequence) : java::lang::Object(fromPySequence(cls, sequence)) {

        length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;

    }

    PyObject *toSequence(PyObject *(*wrapfn)(const T&))

    {

        if (this$ == NULL)

            Py_RETURN_NONE;

        PyObject *list = PyList_New(length);

        for (int i = 0; i < length; i++)

            PyList_SET_ITEM(list, i, (*wrapfn)((*this)[i]));

        return list;

    }

    PyObject *get(int n, PyObject *(*wrapfn)(const T&))

    {

        if (this$ != NULL)

        {

            if (n < 0)

                n = length + n;

            if (n >= 0 && n < length)

                return (*wrapfn)((*this)[n]);

        }

        PyErr_SetString(PyExc_IndexError, "index out of range");

        return NULL;

    }

#endif

    T operator[](int n) {

        return T(env->getObjectArrayElement((jobjectArray) this$, n));

    }

};

template<> class JArray<jobject> : public java::lang::Object {

  public:

    int length;

    JArray<jobject>(jclass cls, int n) : java::lang::Object(env->get_vm_env()->NewObjectArray(n, cls, NULL)) {

        length = env->getArrayLength((jobjectArray) this$);

    }

    JArray<jobject>(jobject obj) : java::lang::Object(obj) {

        length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;

    }

    JArray<jobject>(const JArray& obj) : java::lang::Object(obj) {

        length = obj.length;

    }

#ifdef PYTHON

    JArray<jobject>(jclass cls, PyObject *sequence) : java::lang::Object(fromPySequence(cls, sequence)) {

        length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;

    }

    PyObject *toSequence(PyObject *(*wrapfn)(const jobject&))

    {

        return toSequence(0, length, wrapfn);

    }

    PyObject *toSequence(int lo, int hi, PyObject *(*wrapfn)(const jobject&))

    {

        if (this$ == NULL)

            Py_RETURN_NONE;

        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 *list = PyList_New(hi - lo);

        if (!wrapfn)

            wrapfn = java::lang::t_Object::wrap_jobject;

        for (int i = lo; i < hi; i++) {

            jobject jobj = env->getObjectArrayElement((jobjectArray) this$, i);

            PyObject *obj = (*wrapfn)(jobj);

            PyList_SET_ITEM(list, i - lo, obj);

        }

        return list;

    }

    PyObject *get(int n, PyObject *(*wrapfn)(const jobject&))

    {

        if (this$ != NULL)

        {

            if (n < 0)

                n = length + n;

            if (n >= 0 && n < length)

            {

                if (!wrapfn)

                    wrapfn = java::lang::t_Object::wrap_jobject;

                jobject jobj =

                    env->getObjectArrayElement((jobjectArray) this$, n);

                return (*wrapfn)(jobj);

            }

        }

        PyErr_SetString(PyExc_IndexError, "index out of range");

        return NULL;

    }

    int set(int n, PyObject *obj)

    {

        if (this$ != NULL)

        {

            if (n < 0)

                n = length + n;

            if (n >= 0 && n < length)

            {

                if (!PyObject_TypeCheck(obj, &JObject$$Type))

                {

                    PyErr_SetObject(PyExc_TypeError, obj);

                    return -1;

                }

                jobject jobj = ((t_JObject *) obj)->object.this$;

                try {

                    env->setObjectArrayElement((jobjectArray) this$, n, jobj);

                } catch (JCCEnv::exception e) {

                    PyErr_SetJavaError(e.throwable);

                    return -1;

                }

                return 0;

            }

        }

        PyErr_SetString(PyExc_IndexError, "index out of range");

        return -1;

    }

    PyObject *wrap(PyObject *(*wrapfn)(const jobject&));

#endif

    jobject operator[](int n) {

        return (jobject) env->getObjectArrayElement((jobjectArray) this$, n);

    }

};

template<> class JArray<jstring> : public java::lang::Object {

  public:

    int length;

    JArray<jstring>(jobject obj) : java::lang::Object(obj) {

        length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;

    }

    JArray<jstring>(const JArray& obj) : java::lang::Object(obj) {

        length = obj.length;

    }

    JArray<jstring>(int n) : java::lang::Object(env->get_vm_env()->NewObjectArray(n, env->findClass("java/lang/String"), NULL)) {

        length = env->getArrayLength((jobjectArray) this$);

    }

#ifdef PYTHON

    JArray<jstring>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewObjectArray(PySequence_Length(sequence), env->findClass("java/lang/String"), NULL)) {

        length = env->getArrayLength((jobjectArray) this$);

        for (int i = 0; i < length; i++) {

            PyObject *obj = PySequence_GetItem(sequence, i);

            if (obj == NULL)

                break;

            jstring str = env->fromPyString(obj);

            Py_DECREF(obj);

            if (PyErr_Occurred())

                break;

            env->setObjectArrayElement((jobjectArray) this$, i, str);

            env->get_vm_env()->DeleteLocalRef(str);

        }

    }

    PyObject *toSequence()

    {

        return toSequence(0, length);

    }

    PyObject *toSequence(int lo, int hi)

    {

        if (this$ == NULL)

            Py_RETURN_NONE;

        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 *list = PyList_New(hi - lo);

        for (int i = lo; i < hi; i++) {

            jstring str = (jstring)

                env->getObjectArrayElement((jobjectArray) this$, i);

            PyObject *obj = env->fromJString(str, 1);

            PyList_SET_ITEM(list, i - lo, obj);

        }

        return list;

    }

    PyObject *get(int n)

    {

        if (this$ != NULL)

        {

            if (n < 0)

                n = length + n;

            if (n >= 0 && n < length)

            {

                jstring str = (jstring)

                    env->getObjectArrayElement((jobjectArray) this$, n);

                PyObject *obj = env->fromJString(str, 1);

                return obj;

            }

        }

        PyErr_SetString(PyExc_IndexError, "index out of range");

        return NULL;

    }

    int set(int n, PyObject *obj)

    {

        if (this$ != NULL)

        {

            if (n < 0)

                n = length + n;

            if (n >= 0 && n < length)

            {

                jstring str = env->fromPyString(obj);

                if (PyErr_Occurred())

                    return -1;

                env->setObjectArrayElement((jobjectArray) this$, n, str);

                return 0;

            }

        }

        PyErr_SetString(PyExc_IndexError, "index out of range");

        return -1;

    }

    PyObject *wrap();

#endif

    jstring operator[](int n) {

        return (jstring) env->getObjectArrayElement((jobjectArray) this$, n);

    }

};

template<> class JArray<jboolean> : public java::lang::Object {

  public:

    int length;

    class arrayElements {

    private:

        jboolean isCopy;

        jbooleanArray array;

        jboolean *elts;

    public:

        arrayElements(jbooleanArray array) {

            this->array = array;

            elts = env->get_vm_env()->GetBooleanArrayElements(array, &isCopy);

        }

        virtual ~arrayElements() {

            env->get_vm_env()->ReleaseBooleanArrayElements(array, elts, isCopy);

        }

        operator jboolean *() {

            return elts;

        }

    };