/*
 * Copyright (c) 2007, 2018, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

#include <jni.h>
#include <stdio.h>
#include <stdlib.h>
#include "jnihelper.h"

#define BOOL  0
#define BYTE  1
#define CHAR  2
#define SHORT 3
#define INT   4
#define LONG  5
#define FLOAT 6
#define DOUBLE 7

JNIEXPORT jobjectArray JNICALL
Java_nsk_stress_jni_JNIter003_jniInitArrays (JNIEnv *env, jobject jobj, jint size) {

    jobject *arrayArray;
    jboolean *boolBuf;
    jbyte *byteBuf;
    jchar *charBuf;
    jshort *shortBuf;
    jint *intBuf;
    jlong *longBuf;
    jfloat *floatBuf;
    jdouble *doubleBuf;
    jobjectArray objectsArray;

    int i;
    int SIZE=size;
    const char *classname="java/lang/Object";
    jclass clazz = (*env)->FindClass(env,classname); CE
    objectsArray = (*env)->NewObjectArray(env,8,clazz,(*env)->AllocObject(env,clazz));

    arrayArray=(jobject *)malloc(8*sizeof(jobject)); CE
    arrayArray[BOOL]=(*env)->NewBooleanArray(env,SIZE); CE
    arrayArray[BYTE]=(*env)->NewByteArray(env, SIZE); CE
    arrayArray[CHAR]=(*env)->NewCharArray(env, SIZE); CE
    arrayArray[SHORT]=(*env)->NewShortArray(env, SIZE); CE
    arrayArray[INT]=(*env)->NewIntArray(env, SIZE); CE
    arrayArray[LONG]=(*env)->NewLongArray(env, SIZE); CE
    arrayArray[FLOAT]=(*env)->NewFloatArray(env, SIZE); CE
    arrayArray[DOUBLE]=(*env)->NewDoubleArray(env, SIZE); CE

    for(i=0;i<8;i++)
    {(*env)->SetObjectArrayElement(env,objectsArray,i,arrayArray[i]); CE }

    boolBuf=(jboolean *)malloc(SIZE*sizeof(jboolean));
    byteBuf=(jbyte *)malloc(SIZE*sizeof(jbyte));
    charBuf=(jchar *)malloc(SIZE*sizeof(jchar));
    shortBuf=(jshort *)malloc(SIZE*sizeof(jshort));
    intBuf=(jint *)malloc(SIZE*sizeof(jint));
    longBuf=(jlong *)malloc(SIZE*sizeof(jlong));
    floatBuf=(jfloat *)malloc(SIZE*sizeof(jfloat));
    doubleBuf=(jdouble *)malloc(SIZE*sizeof(jdouble));

    for (i=0;i<SIZE;i++) {
    if (i%2==0) boolBuf[i]=JNI_TRUE;
    else boolBuf[i]=JNI_FALSE;
    /*
      byteBuf[i]=(jbyte)random();
      charBuf[i]=(jchar)random();
      shortBuf[i]=(jshort)random();
      intBuf[i]=(jint)random();
      longBuf[i]=(jlong)random();
      floatBuf[i]=(jfloat)((random()));
      doubleBuf[i]=(jdouble)((random()));
    */
    byteBuf[i]=(jbyte)109;
    charBuf[i]=(jchar)214;
    shortBuf[i]=(jshort)9223;
    intBuf[i]=(jint)872634;
    longBuf[i]=(jlong)276458276;
    floatBuf[i]=(jfloat)235.4576284;
    doubleBuf[i]=(jdouble)98275.716253567;
    }
    (*env)->SetBooleanArrayRegion(env,arrayArray[BOOL],0,i,boolBuf); CE
    (*env)->SetByteArrayRegion(env,arrayArray[BYTE],0,i,byteBuf); CE
    (*env)->SetCharArrayRegion(env,arrayArray[CHAR],0,i,charBuf); CE
    (*env)->SetShortArrayRegion(env,arrayArray[SHORT],0,i,shortBuf); CE
    (*env)->SetIntArrayRegion(env,arrayArray[INT],0,i,intBuf); CE
    (*env)->SetLongArrayRegion(env,arrayArray[LONG],0,i,longBuf); CE
    (*env)->SetFloatArrayRegion(env,arrayArray[FLOAT],0,i,floatBuf); CE
    (*env)->SetDoubleArrayRegion(env,arrayArray[DOUBLE],0,i,doubleBuf); CE

    free(doubleBuf);
    free(floatBuf);
    free(longBuf);
    free(intBuf);
    free(shortBuf);
    free(byteBuf);
    free(charBuf);
    free(boolBuf);
    free(arrayArray);

    return objectsArray;
}

JNIEXPORT jboolean JNICALL
Java_nsk_stress_jni_JNIter003_jniBodyChangeArray (JNIEnv *env, jobject jobj,
                jobjectArray orig, jobjectArray clone, jint limit) {

#define SWAP(param1, param2) tmparr=param2; param2=param1; param1=tmparr;
#define SIZE(type) (*env)->GetArrayLength(env,arrayClone[type])

    static volatile long count=0;
    jobject *arrayOrig, *arrayClone;
    jboolean *boolOrig, *boolClone;
    jbyte *byteOrig, *byteClone;
    jchar *charOrig, *charClone;
    jshort *shortOrig, *shortClone;
    jint *intOrig, *intClone;
    jlong *longOrig, *longClone;
    jfloat *floatOrig, *floatClone;
    jdouble *doubleOrig, *doubleClone;
    int i;

    if ((orig==NULL) || (clone==NULL)) {
    fprintf(stderr,"JNI received a NULL array from Java\n");
    return JNI_FALSE;
    }
    if (count == limit) {
    jclass clazz;
    const char *classname = "nsk/stress/jni/JNIter003";
    const char *setdone = "halt";
    const char *setdonesig = "()V";
    jmethodID jmethod;

    fprintf(stderr, "Count and limit are: %ld\t%d cons.\n", count, limit);
    clazz=(*env)->FindClass(env, classname); CE
        jmethod=(*env)->GetMethodID(env, clazz, setdone, setdonesig); CE
        (*env)->CallVoidMethod(env, jobj, jmethod); CE

    return JNI_TRUE;
    }
    (*env)->MonitorEnter(env, jobj); CE
    ++count;
    (*env)->MonitorExit(env, jobj); CE
    arrayOrig=(jobject *)malloc(8*sizeof(jobject));
    arrayClone=(jobject *)malloc(8*sizeof(jobject));
    for(i=0;i<8;i++) {
    arrayOrig[i]=(*env)->GetObjectArrayElement(env,orig,i); CE
    arrayClone[i]=(*env)->GetObjectArrayElement(env,clone,i); CE
    }

    /* Take the elements from Java arrays into native buffers */
    /* Use Get<Type>ArrayElements */
    boolOrig = (*env)->GetBooleanArrayElements(env,arrayOrig[BOOL],0); CE
    byteOrig = (*env)->GetByteArrayElements(env,arrayOrig[BYTE],0); CE
    charOrig = (*env)->GetCharArrayElements(env,arrayOrig[CHAR],0); CE
    shortOrig = (*env)->GetShortArrayElements(env,arrayOrig[SHORT],0); CE
    intOrig = (*env)->GetIntArrayElements(env,arrayOrig[INT],0); CE
    longOrig = (*env)->GetLongArrayElements(env,arrayOrig[LONG],0); CE
    floatOrig = (*env)->GetFloatArrayElements(env,arrayOrig[FLOAT],0); CE
    doubleOrig = (*env)->GetDoubleArrayElements(env,arrayOrig[DOUBLE],0); CE

    /* Alloc some memory for cloned arrays buffers */
    boolClone=(jboolean *)malloc(SIZE(BOOL)*sizeof(jboolean));
    byteClone=(jbyte *)malloc(SIZE(BYTE)*sizeof(jbyte));
    charClone=(jchar *)malloc(SIZE(CHAR)*sizeof(jchar));
    shortClone=(jshort *)malloc(SIZE(SHORT)*sizeof(jshort));
    intClone=(jint *)malloc(SIZE(INT)*sizeof(jint));
    longClone=(jlong *)malloc(SIZE(LONG)*sizeof(jlong));
    floatClone=(jfloat *)malloc(SIZE(FLOAT)*sizeof(jfloat));
    doubleClone=(jdouble *)malloc(SIZE(DOUBLE)*sizeof(jdouble));

  /* Take the elements from cloned Java arrays into native buffers */
  /* Use Get<Type>ArrayRegion */
    (*env)->GetBooleanArrayRegion(env,arrayClone[BOOL],0,SIZE(BOOL),boolClone); CE
    (*env)->GetByteArrayRegion(env,arrayClone[BYTE],0,SIZE(BYTE),byteClone); CE
    (*env)->GetCharArrayRegion(env,arrayClone[CHAR],0,SIZE(CHAR),charClone); CE
    (*env)->GetShortArrayRegion(env,arrayClone[SHORT],0,SIZE(SHORT),shortClone); CE
    (*env)->GetIntArrayRegion(env,arrayClone[INT],0,SIZE(INT),intClone); CE
    (*env)->GetLongArrayRegion(env,arrayClone[LONG],0,SIZE(LONG),longClone); CE
    (*env)->GetFloatArrayRegion(env,arrayClone[FLOAT],0,SIZE(FLOAT),floatClone); CE
    (*env)->GetDoubleArrayRegion(env,arrayClone[DOUBLE],0,SIZE(DOUBLE),doubleClone); CE

  /* In this code section I should make some changes for elements into both */
  /* (original and cloned) arrays and than copied new values back to Java */

/*
Can't change the pointer into the Java structure.  It's illegal JNI.
    SWAP(boolOrig,boolClone)
    SWAP(byteOrig,byteClone)
    SWAP(charOrig,charClone)
    SWAP(shortOrig,shortClone)
    SWAP(intOrig,intClone)
    SWAP(longOrig,longClone)
    SWAP(floatOrig,floatClone)
    SWAP(doubleOrig,doubleClone)
*/

    /* Coping new values of elements back to Java and releasing native buffers */
    /* Use Set<Type>ArrayRegion */
/*
Use Orig pointers to get the original effect of the test.
    (*env)->SetBooleanArrayRegion(env,arrayClone[BOOL],0,SIZE(BOOL),boolClone);
    (*env)->SetByteArrayRegion(env,arrayClone[BYTE],0,SIZE(BYTE),byteClone);
    (*env)->SetCharArrayRegion(env,arrayClone[CHAR],0,SIZE(CHAR),charClone);
    (*env)->SetShortArrayRegion(env,arrayClone[SHORT],0,SIZE(SHORT),shortClone);
    (*env)->SetIntArrayRegion(env,arrayClone[INT],0,SIZE(INT),intClone);
    (*env)->SetLongArrayRegion(env,arrayClone[LONG],0,SIZE(LONG),longClone);
    (*env)->SetFloatArrayRegion(env,arrayClone[FLOAT],0,SIZE(FLOAT),floatClone);
    (*env)->SetDoubleArrayRegion(env,arrayClone[DOUBLE],0,SIZE(DOUBLE),doubleClone);
*/
    (*env)->SetBooleanArrayRegion(env,arrayClone[BOOL],0,SIZE(BOOL),boolOrig); CE
    (*env)->SetByteArrayRegion(env,arrayClone[BYTE],0,SIZE(BYTE),byteOrig); CE
    (*env)->SetCharArrayRegion(env,arrayClone[CHAR],0,SIZE(CHAR),charOrig); CE
    (*env)->SetShortArrayRegion(env,arrayClone[SHORT],0,SIZE(SHORT),shortOrig); CE
    (*env)->SetIntArrayRegion(env,arrayClone[INT],0,SIZE(INT),intOrig); CE
    (*env)->SetLongArrayRegion(env,arrayClone[LONG],0,SIZE(LONG),longOrig); CE
    (*env)->SetFloatArrayRegion(env,arrayClone[FLOAT],0,SIZE(FLOAT),floatOrig); CE
    (*env)->SetDoubleArrayRegion(env,arrayClone[DOUBLE],0,SIZE(DOUBLE),doubleOrig); CE

    /* Use Release<Type>ArrayElements */
    (*env)->ReleaseDoubleArrayElements(env,arrayOrig[DOUBLE],doubleOrig,0); CE
    (*env)->ReleaseFloatArrayElements(env,arrayOrig[FLOAT],floatOrig,0); CE
    (*env)->ReleaseLongArrayElements(env,arrayOrig[LONG],longOrig,0); CE
    (*env)->ReleaseIntArrayElements(env,arrayOrig[INT],intOrig,0); CE
    (*env)->ReleaseShortArrayElements(env,arrayOrig[SHORT],shortOrig,0); CE
    (*env)->ReleaseCharArrayElements(env,arrayOrig[CHAR],charOrig,0); CE
    (*env)->ReleaseByteArrayElements(env,arrayOrig[BYTE],byteOrig,0); CE
    (*env)->ReleaseBooleanArrayElements(env,arrayOrig[BOOL],boolOrig,0); CE
    free(arrayOrig);

    free(doubleClone);
    free(floatClone);
    free(longClone);
    free(intClone);
    free(shortClone);
    free(byteClone);
    free(charClone);
    free(boolClone);
    free(arrayClone);

    return JNI_TRUE;
}