/*

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

 */

#include <jni.h>

#include <stdarg.h>

#include "java/lang/Object.h"

#include "java/lang/Class.h"

#include "java/lang/String.h"

#include "java/lang/Throwable.h"

#include "java/lang/Boolean.h"

#include "java/lang/Integer.h"

#include "java/lang/Long.h"

#include "java/lang/Double.h"

#include "java/util/Iterator.h"

#include "JArray.h"

#include "functions.h"

#include "macros.h"

using namespace java::lang;

using namespace java::util;

PyObject *PyExc_JavaError = PyExc_ValueError;

PyObject *PyExc_InvalidArgsError = PyExc_ValueError;

PyObject *_set_exception_types(PyObject *self, PyObject *args)

{

    if (!PyArg_ParseTuple(args, "OO",

                          &PyExc_JavaError, &PyExc_InvalidArgsError))

        return NULL;

    Py_RETURN_NONE;

}

PyObject *_set_function_self(PyObject *self, PyObject *args)

{

    PyObject *object, *module;

    if (!PyArg_ParseTuple(args, "OO", &object, &module))

        return NULL;

    if (!PyCFunction_Check(object))

    {

        PyErr_SetObject(PyExc_TypeError, object);

        return NULL;

    }

    PyCFunctionObject *cfn = (PyCFunctionObject *) object;

    Py_INCREF(module);

    Py_XDECREF(cfn->m_self);

    cfn->m_self = module;

    Py_RETURN_NONE;

}

PyObject *findClass(PyObject *self, PyObject *args)

{

    char *className;

    if (!PyArg_ParseTuple(args, "s", &className))

        return NULL;

    try {

        jclass cls = env->findClass(className);

        if (cls)

            return t_Class::wrap_Object(Class(cls));

    } catch (JCCEnv::pythonError e) {

        return NULL;

    } catch (JCCEnv::exception e) {

        PyErr_SetJavaError(e.throwable);

        return NULL;

    }

    Py_RETURN_NONE;

}

#if defined(_MSC_VER) || defined(__SUNPRO_CC)

int __parseArgs(PyObject *args, char *types, ...)

{

    int count = ((PyTupleObject *)(args))->ob_size;

    va_list list, check;

    va_start(list, types);

    va_start(check, types);

    return _parseArgs(((PyTupleObject *)(args))->ob_item, count, types,

		      list, check);

}

int __parseArg(PyObject *arg, char *types, ...)

{

    va_list list, check;

    va_start(list, types);

    va_start(check, types);

    return _parseArgs(&arg, 1, types, list, check);

}

int _parseArgs(PyObject **args, unsigned int count, char *types,

	       va_list list, va_list check)

{

    unsigned int typeCount = strlen(types);

    if (count > typeCount)

        return -1;

#else

int _parseArgs(PyObject **args, unsigned int count, char *types, ...)

{

    unsigned int typeCount = strlen(types);

    va_list list, check;

    if (count > typeCount)

        return -1;

    va_start(list, types);

    va_start(check, types);

#endif

    if (!env->vm)

    {

        PyErr_SetString(PyExc_RuntimeError, "initVM() must be called first");

        return -1;

    }

    JNIEnv *vm_env = env->get_vm_env();

    if (!vm_env)

    {

        PyErr_SetString(PyExc_RuntimeError, "attachCurrentThread() must be called first");

        return -1;

    }

    unsigned int pos = 0;

    int array = 0;

    for (unsigned int a = 0; a < count; a++, pos++) {

        PyObject *arg = args[a];

        switch (types[pos]) {

          case '[':

          {

              if (++array > 1)

                  return -1;

              a -= 1;

              break;

          }

          case 'j':           /* Java object, with class$    */

          case 'k':           /* Java object, with initializeClass */

          case 'K':           /* Java object, with initializeClass and params */

          {

              jclass cls = NULL;

              switch (types[pos]) {

                case 'j':

                  cls = (jclass) va_arg(list, Class *)->this$;

                  break;

                case 'k':

                case 'K':

                  try {

                      getclassfn initializeClass = va_arg(list, getclassfn);

                      cls = (*initializeClass)();

                  } catch (JCCEnv::pythonError e) {

                      return -1;

                  } catch (JCCEnv::exception e) {

                      PyErr_SetJavaError(e.throwable);

                      return -1;

                  }

                  break;

              }

              if (arg == Py_None)

                  break;

              /* ensure that class Class is initialized (which may not be the

               * case because of earlier recursion avoidance (JObject(cls)).

               */

              if (!Class::class$)

                  Class::initializeClass();

              if (array)

              {

                  if (PyObject_TypeCheck(arg, JArrayObject$$Type))

                      break;

                  if (PySequence_Check(arg) &&

                      !PyString_Check(arg) && !PyUnicode_Check(arg))

                  {

                      if (PySequence_Length(arg) > 0)

                      {

                          PyObject *obj = PySequence_GetItem(arg, 0);

                          int ok = 0;

                          if (obj == Py_None)

                              ok = 1;

                          else if (PyObject_TypeCheck(obj, &Object$$Type) &&

                                   vm_env->IsInstanceOf(((t_Object *) obj)->object.this$, cls))

                              ok = 1;

                          else if (PyObject_TypeCheck(obj, &FinalizerProxy$$Type))

                          {

                              PyObject *o = ((t_fp *) obj)->object;

                              if (PyObject_TypeCheck(o, &Object$$Type) &&

                                  vm_env->IsInstanceOf(((t_Object *) o)->object.this$, cls))

                                  ok = 1;

                          }

                          Py_DECREF(obj);

                          if (ok)

                              break;

                      }

                      else

                          break;

                  }

              }

              else if (PyObject_TypeCheck(arg, &Object$$Type) &&

                       vm_env->IsInstanceOf(((t_Object *) arg)->object.this$, cls))

                  break;

              else if (PyObject_TypeCheck(arg, &FinalizerProxy$$Type))

              {

                  arg = ((t_fp *) arg)->object;

                  if (PyObject_TypeCheck(arg, &Object$$Type) &&

                      vm_env->IsInstanceOf(((t_Object *) arg)->object.this$, cls))

                      break;

              }

              return -1;

          }

          case 'Z':           /* boolean, strict */

          {

              if (array)

              {

                  if (arg == Py_None)

                      break;

                  if (PyObject_TypeCheck(arg, JArrayBool$$Type))

                      break;

                  if (PySequence_Check(arg))

                  {

                      if (PySequence_Length(arg) > 0)

                      {

                          PyObject *obj = PySequence_GetItem(arg, 0);

                          int ok = obj == Py_True || obj == Py_False;

                          Py_DECREF(obj);

                          if (ok)

                              break;

                      }

                      else

                          break;

                  }

              }

              else if (arg == Py_True || arg == Py_False)

                  break;

              return -1;

          }

          case 'B':           /* byte */

          {

              if (array)

              {

                  if (arg == Py_None)

                      break;

                  if (PyObject_TypeCheck(arg, JArrayByte$$Type))

                      break;

              }

              else if (PyString_Check(arg) && (PyString_Size(arg) == 1))

                  break;

              else if (PyInt_CheckExact(arg))

                  break;

              return -1;

          }

          case 'C':           /* char */

          {

              if (array)

              {

                  if (arg == Py_None)

                      break;

                  if (PyObject_TypeCheck(arg, JArrayChar$$Type))

                      break;

              }

              else if (PyUnicode_Check(arg) && PyUnicode_GET_SIZE(arg) == 1)

                  break;

              return -1;

          }

          case 'I':           /* int */

          {

              if (array)

              {

                  if (arg == Py_None)

                      break;

                  if (PyObject_TypeCheck(arg, JArrayInt$$Type))

                      break;

                  if (PySequence_Check(arg))

                  {

                      if (PySequence_Length(arg) > 0)

                      {

                          PyObject *obj = PySequence_GetItem(arg, 0);

                          int ok = PyInt_CheckExact(obj);

                          Py_DECREF(obj);

                          if (ok)

                              break;

                      }

                      else

                          break;

                  }

              }

              else if (PyInt_CheckExact(arg))

                  break;

              return -1;

          }

          case 'S':           /* short */

          {

              if (array)

              {

                  if (arg == Py_None)

                      break;

                  if (PyObject_TypeCheck(arg, JArrayShort$$Type))

                      break;

                  if (PySequence_Check(arg))

                  {

                      if (PySequence_Length(arg) > 0)

                      {

                          PyObject *obj = PySequence_GetItem(arg, 0);

                          int ok = PyInt_CheckExact(obj);

                          Py_DECREF(obj);

                          if (ok)

                              break;

                      }

                      else

                          break;

                  }

              }

              else if (PyInt_CheckExact(arg))

                  break;

              return -1;

          }

          case 'D':           /* double */

          {

              if (array)

              {

                  if (arg == Py_None)

                      break;

                  if (PyObject_TypeCheck(arg, JArrayDouble$$Type))

                      break;

                  if (PySequence_Check(arg))

                  {

                      if (PySequence_Length(arg) > 0)

                      {

                          PyObject *obj = PySequence_GetItem(arg, 0);

                          int ok = PyFloat_CheckExact(obj);

                          Py_DECREF(obj);