/*******************************************************************************

 * Copyright (c) 2009, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - initial implementation

 *******************************************************************************/

#include <QRect>

#include <QStringList>

#include <QByteArray>

#include <QStack>

#include "jniutils.h"

#include "swtlog.h"

#include "autorelease.h"

#include "swtapplication.h"

#include "execexceptionhandler.h"

#include "graphics.h"

namespace Java { namespace eSWT {

using namespace Java::GFX;

// Ids for cached jmethodIDs

typedef enum

{

    // [CLASS]_[METHOD]_[PARAMS]_[RETURN]

    DISPLAY_EVENTPROCESS_IIIIIIIISTRING_Z = 0,

    RECTANGLE_INIT_IIII_V,

    POINT_INIT_II_V,

    SWT_ERROR_I_V,

    NUM_SWT_JMETHODIDS

} SwtJMethodId;

// Ids for cached jclasses

typedef enum

{

    // [CLASS]

    RECTANGLE = 0,

    POINT,

    SWT,

    STRING,

    DISPLAY,

    NUM_SWT_JCLASSES

} SwtJClass;

JniUtils::JniUtils(JNIEnv* aEnv) : mUIThreadJniEnv(aEnv)

{

    SWT_LOG_FUNC_CALL();

    // Get local class refs. These classes are needed by Display so they should

    // be already loaded at this point. This doesn't cause any additional

    // classes, that wouldn't potentially be needed, to be loaded.

    mJclasses = new jclass[NUM_SWT_JCLASSES];

    ::memset( mJclasses, 0, sizeof(jclass)*NUM_SWT_JCLASSES );

    mJclasses[RECTANGLE] = mUIThreadJniEnv->FindClass("org/eclipse/swt/graphics/Rectangle");

    mJclasses[POINT] = mUIThreadJniEnv->FindClass("org/eclipse/swt/graphics/Point");

    mJclasses[SWT] = mUIThreadJniEnv->FindClass("org/eclipse/swt/SWT");

    mJclasses[STRING] = mUIThreadJniEnv->FindClass("java/lang/String");

    mJclasses[DISPLAY] = mUIThreadJniEnv->FindClass("org/eclipse/swt/widgets/Display");

    // Check that local class refs ok

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

    {

        if (!mJclasses[i])

        {

            throw std::bad_alloc();

        }

    }

    // Create global class refs for caching. Global refs can be used across 

    // threads. Keeping global class refs ensures that the classes won't get

    // unloaded. 

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

    {

        jclass globalRef = static_cast<jclass>(mUIThreadJniEnv->NewGlobalRef( mJclasses[i] ));

        mUIThreadJniEnv->DeleteLocalRef( mJclasses[i] );

        mJclasses[i] = globalRef;

    }

    // Check that all global class refs ok

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

    {

        if (!mJclasses[i])

        {

            // Free the ones already allocated before throwing

            for (int j = 0; j < NUM_SWT_JCLASSES; ++j)

            {

                if( mJclasses[j] )

                {

                    mUIThreadJniEnv->DeleteGlobalRef(mJclasses[j]);

                    mJclasses[j] = NULL;

                }

            }

            throw std::bad_alloc();

        }

    }

    // Compute methodIDs for caching. MethodIDs have the same values for all 

    // threads so the cached values may be used by any thread. MethodIDs are 

    // valid until objects are garbage collected or classes unloaded. 

    mJmethodIds = new jmethodID[NUM_SWT_JMETHODIDS];

    ::memset( mJmethodIds, 0, sizeof(jmethodID)*NUM_SWT_JMETHODIDS );

    mJmethodIds[DISPLAY_EVENTPROCESS_IIIIIIIISTRING_Z] = mUIThreadJniEnv->GetStaticMethodID(mJclasses[DISPLAY], "eventProcess", "(IIIIIIIILjava/lang/String;)Z");

    mJmethodIds[RECTANGLE_INIT_IIII_V] = mUIThreadJniEnv->GetMethodID(mJclasses[RECTANGLE], "<init>", "(IIII)V");

    mJmethodIds[POINT_INIT_II_V] = mUIThreadJniEnv->GetMethodID(mJclasses[POINT], "<init>", "(II)V");

    mJmethodIds[SWT_ERROR_I_V] = mUIThreadJniEnv->GetStaticMethodID(mJclasses[SWT], "error", "(I)V");

    // Check that methodIDs are ok

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

    {

        if (!mJmethodIds[i])

        {

            throw std::bad_alloc();

        }

    }

}

JniUtils::~JniUtils()

{

    SWT_LOG_FUNC_CALL();

    for (int j = 0; j < NUM_SWT_JCLASSES; ++j)

    {

        if (mJclasses[j])

        {

            mUIThreadJniEnv->DeleteGlobalRef(mJclasses[j]);

            mJclasses[j] = NULL;

        }

    }

    delete mJclasses;

    mJclasses = NULL;

    delete mJmethodIds;

    mJmethodIds = NULL;

}

bool JniUtils::eventProcess(const QObject* aQObject, const int& aQEventType,

                            const int& a1, const int& a2, const int& a3,

                            const int& a4, const int& a5,

                            const jstring aString)

{

    SWT_LOG_FUNC_CALL();

    return eventProcess(

            NULL, 

            mJclasses[DISPLAY], 

            mJmethodIds[DISPLAY_EVENTPROCESS_IIIIIIIISTRING_Z], 

            reinterpret_cast<int>(aQObject),

            aQEventType, a1, a2, a3, a4, a5, aString);

}

bool JniUtils::eventProcess(jobject aObject, const jmethodID aMethodID,

        const QObject* aQObject, const int& aQEventType, const int& a1,

        const int& a2, const int& a3, const int& a4, const int& a5,

        const jstring aString)

{

    return eventProcess(

            aObject, 

            NULL, 

            aMethodID, 

            reinterpret_cast<int>(aQObject),

            aQEventType, a1, a2, a3, a4, a5, aString);

}

bool JniUtils::eventProcess(jclass aClazz, const jmethodID aMethodID,

        const QObject* aQObject, const int& aQEventType, const int& a1,

        const int& a2, const int& a3, const int& a4, const int& a5,

        const jstring aString)

{

    return eventProcess(

            NULL, 

            aClazz, 

            aMethodID, 

            reinterpret_cast<int>(aQObject),

            aQEventType, a1, a2, a3, a4, a5, aString);

}

bool JniUtils::eventProcess(jobject aObject, jclass aClazz, const jmethodID aMethodID,

        const int& aQObject, const int& aQEventType, const int& a1,

        const int& a2, const int& a3, const int& a4, const int& a5,

        const jstring aString)

{

    SWT_LOG_FUNC_CALL();

    // Can't attempt callback if JVM is processing an exception. Event is

    // possibly lost by Java listener.

    if (mUIThreadJniEnv->ExceptionCheck() == JNI_TRUE)

    {

        return false;

    }

    if (aMethodID != NULL)

    {

        // Add object to the list of objects being handled. It's not safe to 

        // delete an object in its event or signal handler because that could

        // result in freeing memory that is still going to be accessed as we

        // return back through the call stack. This list of objects can be used

        // to determine if deletion of an object is safe in these terms. 

        JavaCallbackCounter counter(mObjectsBeingHandled, reinterpret_cast<QObject*>(aQObject));

        jboolean result;

        // Callback Java

        if(aObject == NULL)

        {

            result = mUIThreadJniEnv->CallStaticBooleanMethod(aClazz, aMethodID,

                    aQObject, aQEventType, swtApp->eventTime(), a1, a2, a3, a4, a5, aString);        

        }

        else

        {

            result = mUIThreadJniEnv->CallBooleanMethod(aObject, aMethodID,

                    aQObject, aQEventType, swtApp->eventTime(), a1, a2, a3, a4, a5, aString);

        }

        // If an exception has occurred then any native eventloop we have

        // started, e.g. when opening a QDialog, must exit to allow Java stack

        // unwinding to continue.

        if (mUIThreadJniEnv->ExceptionCheck() == JNI_TRUE)

        {

            if(!mExecStack.isEmpty())

            {

                ExecExceptionHandler* exec = mExecStack.top();

                if( !exec->isTerminated() )

                {

                    exec->terminate();

                }

            }

        }

        return (result == JNI_TRUE ? true : false);

    }

    return false;

}

void JniUtils::enterExec(QObject* aObject)

{

    QDialog* dialog = qobject_cast<QDialog*>( aObject );

    if( dialog )

    {

        mExecStack.push( new DialogExecExceptionHandler( dialog ) );

        return;

    }

    QMenu* menu = qobject_cast<QMenu*>( aObject );

    if( menu )

    {

        mExecStack.push( new MenuExecExceptionHandler( menu ) );

        return;

    }

    Q_ASSERT(false); // Something was given we don't know how to handle

}

void JniUtils::leaveExec()

{

    mExecStack.pop();

}

jobject JniUtils::NewJavaRectangle(JNIEnv* aEnv, const QRect& aRect)

{

    SWT_LOG_FUNC_CALL();

    jobject result = aEnv->NewObject(mJclasses[RECTANGLE],

            mJmethodIds[RECTANGLE_INIT_IIII_V], aRect.x(), aRect.y(),

            aRect.width(), aRect.height());

    if (!result)

    {

        throw std::bad_alloc();

    }

    return result;

}

jobject JniUtils::NewJavaPoint(JNIEnv* aEnv, const QSize& aSize)

{

    SWT_LOG_FUNC_CALL();

    jobject result = aEnv->NewObject(mJclasses[POINT],

            mJmethodIds[POINT_INIT_II_V], aSize.width(), aSize.height());

    if (!result)

    {

        throw std::bad_alloc();

    }

    return result;

}

jobject JniUtils::NewJavaPoint(JNIEnv* aEnv, const QPoint& aPoint)

{

    SWT_LOG_FUNC_CALL();

    jobject result = aEnv->NewObject(mJclasses[POINT],

            mJmethodIds[POINT_INIT_II_V], aPoint.x(), aPoint.y());

    if (!result)

    {

        throw std::bad_alloc();

    }

    return result;

}

SWTQT_EXPORT QString JniUtils::JavaStringToQString(JNIEnv* aEnv, jstring aJavaString)

{

    SWT_LOG_FUNC_CALL();

    if (aJavaString == NULL)

    {

        return QString();

    }

    jboolean isCopy;

    const jchar* javaChars = aEnv->GetStringChars(aJavaString, &isCopy);

    if (javaChars)

    {

        AutoReleaseStringChars cleaner(aEnv, aJavaString, javaChars);

        // This conversion should be ok for UCS-2 and UTF-16

        jsize length = aEnv->GetStringLength(aJavaString);

        return QString::fromUtf16(javaChars, length);

    }

    else

    {

        throw std::bad_alloc();

    }

 }

SWTQT_EXPORT jstring JniUtils::QStringToJavaString(JNIEnv* aEnv, const QString& aQString)

{

    SWT_LOG_FUNC_CALL();

    jstring result = aEnv->NewString(aQString.utf16(), aQString.size());

    if (!result)

    {

        throw std::bad_alloc();

    }

    return result;

}

jintArray JniUtils::NewJavaIntArray(JNIEnv* aEnv, int* aArray, const int& aItemCount)

{

    SWT_LOG_FUNC_CALL();

    jintArray result = aEnv->NewIntArray(aItemCount);

    if (result != NULL)

    {

        if (sizeof(int) != sizeof(jint))

        {

            jint* tmp = new jint[aItemCount];

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

            {

                tmp[i] = static_cast<jint> (aArray[i]);

            }

            aEnv->SetIntArrayRegion(result, 0, aItemCount, tmp);

            delete[] tmp;

        }

        else

        {

            // This reinterpret_cast is safe now because we know that jint and int are same size.

            aEnv->SetIntArrayRegion(result, 0, aItemCount,

                    reinterpret_cast<jint*> (aArray));

        }

    }

    if (!result)

    {

        throw std::bad_alloc();

    }

    return result;

}

jobjectArray JniUtils::NewJavaStringArray(JNIEnv* aEnv, const QStringList& aStrList)

{

    SWT_LOG_FUNC_CALL();

    const int count = aStrList.size();

    jobjectArray result = aEnv->NewObjectArray(count, mJclasses[STRING],

            NULL);

    if (!result)

    {

        throw std::bad_alloc();

    }

    jstring javaString;

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

    {

        javaString = QStringToJavaString(aEnv, aStrList.at(i));

        aEnv->SetObjectArrayElement(result, i, javaString);

        aEnv->DeleteLocalRef(javaString);

    }

    return result;

}

QStringList JniUtils::JavaStringArrayToQStringList(JNIEnv* aEnv, jobjectArray aObjectArray)

{

    SWT_LOG_FUNC_CALL();

    jsize len = aEnv->GetArrayLength(aObjectArray);

    QStringList result;

    QString qtString;

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

    {

        qtString = JavaStringToQString(aEnv, 

                (jstring) aEnv->GetObjectArrayElement(aObjectArray, i));

        result.insert(i, qtString);

    }

    return result;

}

jbyteArray JniUtils::NewJavaByteArray(JNIEnv* aEnv, const QByteArray& aArray)

{

    SWT_LOG_FUNC_CALL();

    const int count = aArray.count();

    char* data = const_cast<char*> (aArray.data());

    jbyteArray result = aEnv->NewByteArray(count);

    if (result != NULL)

    {

        if (sizeof(char) != sizeof(jbyte))

        {

            jbyte* tmp = new jbyte[count];

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

            {

                tmp[i] = static_cast<jbyte> (data[i]);

            }

            aEnv->SetByteArrayRegion(result, 0, count, tmp);

            delete[] tmp;

        }

        else

        {

            aEnv->SetByteArrayRegion(result, 0, count,

                    reinterpret_cast<jbyte*> (data));

        }

    }

    else

    {

        throw std::bad_alloc();

    }

    return result;

}

QByteArray JniUtils::JavaByteArrayToQByteArray(JNIEnv* aEnv, jbyteArray aByteArray)

{

    SWT_LOG_FUNC_CALL();

    jsize len = aEnv->GetArrayLength(aByteArray);

    QByteArray result = QByteArray(len,0);

    aEnv->GetByteArrayRegion(aByteArray, 0, len, reinterpret_cast<jbyte*>(result.data()));

    return result;

}

SWTQT_EXPORT void JniUtils::Throw(JNIEnv* aEnv, const int& aError)

{

    SWT_LOG_FUNC_CALL();

    aEnv->CallStaticVoidMethod(mJclasses[SWT], mJmethodIds[SWT_ERROR_I_V],

            aError);

}

void JniUtils::Throw(JNIEnv* aEnv, GfxException& aException)

{

    SWT_LOG_FUNC_CALL();

    jclass javaException = aEnv->FindClass(resolveException(aException.getErrorCode()));

    if( javaException )

    {

        aEnv->ThrowNew(javaException, aException.getMsg());

    }

}

jmethodID JniUtils::FindJavaMethodID(JNIEnv* aEnv, jobject aObject, const char* aMethodName,

        const char* aMethodSignature)

{

    SWT_LOG_FUNC_CALL();

    jclass clazz = aEnv->GetObjectClass(aObject);

    if (clazz)

    {

        jmethodID methodID = aEnv->GetMethodID(clazz, aMethodName,

                aMethodSignature);

        aEnv->DeleteLocalRef(clazz);SWT_LOG_DATA_3("MethodId for %s %s is %d", aMethodName, aMethodSignature, methodID);

        return methodID;

    }

    return NULL;

}

int JniUtils::javaCallbackCount()

{ 

    return mObjectsBeingHandled.size();

}

void JniUtils::GetJavaIntArrayRegionToIntArray(JNIEnv* aEnv, jintArray aArray, jsize aStart, jsize aLength, int* aBuffer)

{

    SWT_LOG_FUNC_CALL();

    if(sizeof(jint) == sizeof(int))

    {

        aEnv->GetIntArrayRegion(aArray, aStart, aLength, static_cast<jint*>(aBuffer));

    }

    else

    {

        jint* tmpBuffer = new jint[aLength];

        if(tmpBuffer)

        {

            aEnv->GetIntArrayRegion(aArray, aStart, aLength, tmpBuffer);

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

            {

                aBuffer[i] = tmpBuffer[i];

            }

            delete[] tmpBuffer;

            tmpBuffer = NULL;

        }

    }

}

void JniUtils::SetJavaIntArrayRegionFromIntArray(JNIEnv* aEnv, jintArray aArray, jsize aStart, jsize aLength, int* aBuffer)

{

    SWT_LOG_FUNC_CALL();

    if(sizeof(jint) == sizeof(int))

    {

        aEnv->SetIntArrayRegion(aArray, aStart, aLength, reinterpret_cast<jint*>(aBuffer));

    }

    else

    {

        jint* tmpBuffer = new jint[aLength];

        if(tmpBuffer)

        {

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

            {

                 tmpBuffer[i] = aBuffer[i];