/*

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

#include <string.h>

#include <jni.h>

#include "JCCEnv.h"

#if defined(_MSC_VER) || defined(__WIN32)

_DLL_EXPORT DWORD VM_ENV = 0;

#else

pthread_key_t JCCEnv::VM_ENV = (pthread_key_t) NULL;

#endif

#if defined(_MSC_VER) || defined(__WIN32)

static CRITICAL_SECTION *mutex = NULL;

class lock {

public:

    lock() {

        EnterCriticalSection(mutex);

    }

    virtual ~lock() {

        LeaveCriticalSection(mutex);

    }

};

#else

static pthread_mutex_t *mutex = NULL;

class lock {

public:

    lock() {

        pthread_mutex_lock(mutex);

    }

    virtual ~lock() {

        pthread_mutex_unlock(mutex);

    }

};

#endif

JCCEnv::JCCEnv(JavaVM *vm, JNIEnv *vm_env)

{

#if defined(_MSC_VER) || defined(__WIN32)

    if (!mutex)

    {

        mutex = new CRITICAL_SECTION();

        InitializeCriticalSection(mutex);

    }

#else

    if (!mutex)

    {

        mutex = new pthread_mutex_t();

        pthread_mutex_init(mutex, NULL);

    }

#endif

    if (vm)

        set_vm(vm, vm_env);

    else

        this->vm = NULL;

}

void JCCEnv::set_vm(JavaVM *vm, JNIEnv *vm_env)

{

    this->vm = vm;

    set_vm_env(vm_env);

    _sys = (jclass) vm_env->NewGlobalRef(vm_env->FindClass("java/lang/System"));

    _obj = (jclass) vm_env->NewGlobalRef(vm_env->FindClass("java/lang/Object"));

#ifdef _jcc_lib

    _thr = (jclass) vm_env->NewGlobalRef(vm_env->FindClass("org/apache/jcc/PythonException"));

#else

    _thr = (jclass) vm_env->NewGlobalRef(vm_env->FindClass("java/lang/RuntimeException"));

#endif

    _mids = new jmethodID[max_mid];

    _mids[mid_sys_identityHashCode] =

        vm_env->GetStaticMethodID(_sys, "identityHashCode",

                                  "(Ljava/lang/Object;)I");

    _mids[mid_sys_setProperty] =

        vm_env->GetStaticMethodID(_sys, "setProperty",

                                  "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;");

    _mids[mid_sys_getProperty] =

        vm_env->GetStaticMethodID(_sys, "getProperty",

                                  "(Ljava/lang/String;)Ljava/lang/String;");

    _mids[mid_obj_toString] =

        vm_env->GetMethodID(_obj, "toString",

                            "()Ljava/lang/String;");

    _mids[mid_obj_hashCode] =

        vm_env->GetMethodID(_obj, "hashCode",

                            "()I");

    _mids[mid_obj_getClass] =

        vm_env->GetMethodID(_obj, "getClass",

                            "()Ljava/lang/Class;");

    _mids[mid_iterator_next] =

        vm_env->GetMethodID(vm_env->FindClass("java/util/Iterator"),

                            "next", "()Ljava/lang/Object;");

    _mids[mid_enumeration_nextElement] =

        vm_env->GetMethodID(vm_env->FindClass("java/util/Enumeration"),

                            "nextElement", "()Ljava/lang/Object;");

}

#if defined(_MSC_VER) || defined(__WIN32)

void JCCEnv::set_vm_env(JNIEnv *vm_env)

{

    if (!VM_ENV)

        VM_ENV = TlsAlloc();

    TlsSetValue(VM_ENV, (LPVOID) vm_env);

}

#else

void JCCEnv::set_vm_env(JNIEnv *vm_env)

{

    if (!VM_ENV)

        pthread_key_create(&VM_ENV, NULL);

    pthread_setspecific(VM_ENV, (void *) vm_env);

}

#endif

jint JCCEnv::getJNIVersion() const

{

    return get_vm_env()->GetVersion();

}

jstring JCCEnv::getJavaVersion() const

{

    return (jstring)

        callStaticObjectMethod(_sys, _mids[mid_sys_getProperty],

                               get_vm_env()->NewStringUTF("java.version"));

}

jobject JCCEnv::iteratorNext(jobject obj) const

{

    return callObjectMethod(obj, _mids[mid_iterator_next]);

}

jobject JCCEnv::enumerationNext(jobject obj) const

{

    return callObjectMethod(obj, _mids[mid_enumeration_nextElement]);

}

jclass JCCEnv::findClass(const char *className) const

{

    jclass cls = NULL;

    if (vm)

    {

        JNIEnv *vm_env = get_vm_env();

        if (vm_env)

            cls = vm_env->FindClass(className);

#ifdef PYTHON

        else

        {

            PythonGIL gil;

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

            throw pythonError(NULL);

        }

#else

        else

            throw exception(NULL);

#endif

    }

#ifdef PYTHON

    else

    {

        PythonGIL gil;

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

        throw pythonError(NULL);

    }

#else

    else

        throw exception(NULL);

#endif

    reportException();

    return cls;

}

void JCCEnv::registerNatives(jclass cls, JNINativeMethod *methods, int n) const

{

    get_vm_env()->RegisterNatives(cls, methods, n);

}

jobject JCCEnv::newGlobalRef(jobject obj, int id)

{

    if (obj)

    {

        if (id)  /* zero when weak global ref is desired */

        {

            lock locked;

            for (std::multimap<int, countedRef>::iterator iter = refs.find(id);

                 iter != refs.end();

                 iter++) {

                if (iter->first != id)

                    break;

                if (isSame(obj, iter->second.global))

                {

                    /* If it's in the table but not the same reference,

                     * it must be a local reference and must be deleted.

                     */

                    if (obj != iter->second.global)

                        get_vm_env()->DeleteLocalRef(obj);

                    iter->second.count += 1;

                    return iter->second.global;

                }

            }

            JNIEnv *vm_env = get_vm_env();

            countedRef ref;

            ref.global = vm_env->NewGlobalRef(obj);

            ref.count = 1;

            refs.insert(std::pair<const int, countedRef>(id, ref));

            vm_env->DeleteLocalRef(obj);

            return ref.global;

        }

        else

            return (jobject) get_vm_env()->NewWeakGlobalRef(obj);

    }

    return NULL;

}

jobject JCCEnv::deleteGlobalRef(jobject obj, int id)

{

    if (obj)

    {

        if (id)  /* zero when obj is weak global ref */

        {

            lock locked;

            for (std::multimap<int, countedRef>::iterator iter = refs.find(id);

                 iter != refs.end();

                 iter++) {

                if (iter->first != id)

                    break;

                if (isSame(obj, iter->second.global))

                {

                    if (iter->second.count == 1)

                    {

                        get_vm_env()->DeleteGlobalRef(iter->second.global);

                        refs.erase(iter);

                    }

                    else

                        iter->second.count -= 1;

                    return NULL;

                }

            }

            printf("deleting non-existent ref: 0x%x\n", id);

        }

        else

            get_vm_env()->DeleteWeakGlobalRef((jweak) obj);

    }

    return NULL;

}

jobject JCCEnv::newObject(jclass (*initializeClass)(), jmethodID **mids,

                          int m, ...)

{

    jclass cls = (*initializeClass)();

    JNIEnv *vm_env = get_vm_env();

    jobject obj;

    if (vm_env)

    {

        va_list ap;

        va_start(ap, m);

        obj = vm_env->NewObjectV(cls, (*mids)[m], ap);

        va_end(ap);

    }

#ifdef PYTHON

    else

    {

        PythonGIL gil;

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

        throw pythonError(NULL);

    }

#else

    else

        throw exception(NULL);

#endif

    reportException();

    return obj;

}

jobjectArray JCCEnv::newObjectArray(jclass cls, int size)

{

    jobjectArray array = get_vm_env()->NewObjectArray(size, cls, NULL);

    reportException();

    return array;

}

void JCCEnv::setObjectArrayElement(jobjectArray array, int n,

                                   jobject obj) const

{

    get_vm_env()->SetObjectArrayElement(array, n, obj);

    reportException();

}

jobject JCCEnv::getObjectArrayElement(jobjectArray array, int n) const

{

    jobject obj = get_vm_env()->GetObjectArrayElement(array, n);

    reportException();

    return obj;

}

int JCCEnv::getArrayLength(jarray array) const

{

    int len = get_vm_env()->GetArrayLength(array);

    reportException();

    return len;

}

#ifdef PYTHON

jclass JCCEnv::getPythonExceptionClass() const

{

    return _thr;

}

#endif

void JCCEnv::reportException() const

{

    JNIEnv *vm_env = get_vm_env();

    jthrowable throwable = vm_env->ExceptionOccurred();

    if (throwable)

    {

        if (!env->handlers)

            vm_env->ExceptionDescribe();

        vm_env->ExceptionClear();

#ifdef PYTHON

        PythonGIL gil;

        if (PyErr_Occurred())

        {

            /* _thr is PythonException ifdef _jcc_lib (shared mode)

             * if not shared mode, _thr is RuntimeException

             */

            jobject cls = (jobject) vm_env->GetObjectClass(throwable);

            if (vm_env->IsSameObject(cls, _thr))

                throw pythonError(throwable);

        }

#endif

        throw exception(throwable);

    }

}

#define DEFINE_CALL(jtype, Type)                                         \

    jtype JCCEnv::call##Type##Method(jobject obj,                        \

                                     jmethodID mid, ...) const           \

    {                                                                    \

        va_list ap;                                                      \

        jtype result;                                                    \

                                                                         \

        va_start(ap, mid);                                               \

        result = get_vm_env()->Call##Type##MethodV(obj, mid, ap);        \

        va_end(ap);                                                      \

                                                                         \

        reportException();                                               \

                                                                         \

        return result;                                                   \

    }