/**
* Copyright (c) 2003 Sun Microsystems, Inc. All  Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* -Redistribution of source code must retain the above copyright notice, 
* this list of conditions and the following disclaimer.
*
* -Redistribution in binary form must reproduce the above copyright notice, 
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of contributors may 
* be used to endorse or promote products derived from this software without 
* specific prior written permission.
* 
* This software is provided "AS IS," without a warranty of any kind.
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
* ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
* NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN") AND ITS
* LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A
* RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
* IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT
* OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
* PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
* ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed or intended for use in the
* design, construction, operation or maintenance of any nuclear facility.
*/


#include "alcbind.h"
#include "extal.h"

JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_alcGetErrorNative
  (JNIEnv *env, jobject obj, jint pointer) {
  	return alcGetError((ALCdevice*)pointer);
}

/*
JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_openDeviceNative
  (JNIEnv *env, jobject obj, jstring deviceName) {
	printf("Entering openDeviceNative()\n");
  	printf("In openDeviceNative() test 1\n");
  	jint result;
  	ALubyte *str;
  	ALCdevice *device;
  	if(deviceName != NULL) {
  		printf("In openDeviceNative() test 2a.1\n");
	  	str = (ALubyte*)(*env)->GetStringUTFChars(env,deviceName,NULL);
  		printf("In openDeviceNative() test 2a.2 -- %i\n", *alcOpenDevice);
	  	device = alcOpenDevice(str);
	  	printf("In openDeviceNative() test 2a.3 -- %s - %i\n", str, (jint)device);
	  	(*env)->ReleaseStringUTFChars(env,deviceName,str);
	} else {
	  	printf("In openDeviceNative() test 2b.1\n");
	  	device = alcOpenDevice(NULL);
	  	printf("In openDeviceNative() test 2b.2 -- NULL - %i\n", (jint)device);
	}
  	result = (jint)device;
  	printf("In openDeviceNative() test 3\n");
	printf("Exiting openDeviceNative()\n");
  	return result;
}
*/
JNIEXPORT jobject JNICALL Java_net_java_games_joal_ALCImpl_openDeviceNative
  (JNIEnv *env, jobject obj, jstring deviceName) {
	const char * tokenstring;

	jboolean isCopy = JNI_FALSE;
	if(deviceName != NULL) {
		tokenstring = ((*env)->GetStringUTFChars(env, deviceName, &isCopy));
	} else {
		tokenstring = NULL;
	}

	/* get device */
	ALCdevice* device = alcOpenDevice((ALubyte *) tokenstring);

	/* if error - cleanup and get out */
	if(device == NULL) {
		if(tokenstring != NULL) {
			// (*env)->ReleaseStringUTFChars(env, deviceName, tokenstring);
		}
		return NULL;
	}

	/* get ready to create ALCdevice instance */
	jobject alcDevice_object	= NULL;
	jclass alcDevice_class		= NULL;
	jmethodID alcDevice_method	= NULL;

	/* find class and constructor */
	alcDevice_class		= (*env)->FindClass(env, "net/java/games/joal/ALC$Device");
	alcDevice_method	= (*env)->GetMethodID(env, alcDevice_class, "<init>", "(I)V");

	/* create instance */
	alcDevice_object = (*env)->NewObject(env, alcDevice_class, alcDevice_method, (int) device);

	/* clean up */
	if (tokenstring != NULL)
		// (*env)->ReleaseStringUTFChars(env, deviceName, tokenstring);

	return alcDevice_object;
}

JNIEXPORT void JNICALL Java_net_java_games_joal_ALCImpl_closeDeviceNative
  (JNIEnv *env, jobject obj, jint pointer) {
	ALCdevice* device = (ALCdevice*)pointer;
	alcCloseDevice(device);
}
/*
JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_createContextNative
  (JNIEnv *env, jobject obj, jint pointer, jintArray attrs) {
  	ALCdevice* device = (ALCdevice*)pointer;
  	ALint* attrList = NULL;
  	if(attrs != NULL) {
	  	attrList = (ALint*)(*env)->GetPrimitiveArrayCritical(env,attrs,0);
	  	jint ctxPtr = (jint)alcCreateContext(device,attrList);
	  	(*env)->ReleasePrimitiveArrayCritical(env,attrs,attrList,0);
	  	return ctxPtr;
  	} else {
  		jint ctxPtr = (jint)alcCreateContext(device,NULL);
		return ctxPtr;
  	}
}
*/

JNIEXPORT jobject JNICALL Java_net_java_games_joal_ALCImpl_createContextNative
  (JNIEnv *env, jobject obj, jint deviceAddress, jintArray attrs) {
   ALint* address = NULL;

  	if(attrs != NULL) {
	  	address = (ALint*)(*env)->GetPrimitiveArrayCritical(env,attrs,0);
	}
    ALCcontext* context = alcCreateContext((ALCdevice*)deviceAddress, address);
    if(address != NULL) {
	  	(*env)->ReleasePrimitiveArrayCritical(env,attrs,address,0);    
    }
	/* if error - get out */
	if(context == NULL) {
		return NULL;
	}	

	/* get ready to create ALCcontext instance */
	jobject alcContext_object	= NULL;
	jclass alcContext_class		= NULL;
	jmethodID alcContext_method	= NULL;

	/* find class and constructor */
	alcContext_class	= (*env)->FindClass(env, "net/java/games/joal/ALC$Context");
	alcContext_method	= (*env)->GetMethodID(env, alcContext_class, "<init>", "(Lnet/java/games/joal/ALC;I)V");

	/* create instance */
	alcContext_object = (*env)->NewObject(env, alcContext_class, alcContext_method, obj, (int) context);

	return alcContext_object;
}


JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_makeContextCurrentNative
  (JNIEnv *env, jobject obj, jint pointer) {
  	ALvoid* alcHandle = (ALvoid*)pointer;
  	alcMakeContextCurrent(alcHandle);
}

JNIEXPORT void JNICALL Java_net_java_games_joal_ALCImpl_processContextNative
  (JNIEnv *env, jobject obj, jint pointer) {
	ALvoid* alcHandle = (ALvoid*)pointer;
	alcProcessContext(alcHandle);
}

JNIEXPORT void JNICALL Java_net_java_games_joal_ALCImpl_suspendContextNative
  (JNIEnv *env, jobject obj, jint pointer) {
  	ALvoid* alcHandle = (ALvoid*)pointer;
	alcSuspendContext(alcHandle);
}

JNIEXPORT void JNICALL Java_net_java_games_joal_ALCImpl_destroyContextNative
  (JNIEnv *env, jobject obj, jint pointer) {
  	ALvoid* alcHandle = (ALvoid*)pointer;
	alcDestroyContext(alcHandle);
}
/*
JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_getError
  (JNIEnv *env, jobject obj) {
  	jint result = 0;
//  	result = alcGetError();
  	return result;
}
*/
JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_getCurrentContextNative
  (JNIEnv *env, jobject obj) {
	jint result;
	result = (jint)alcGetCurrentContext();
	return result;
}

JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_getEnumValueNative
  (JNIEnv *env, jobject obj, jint pointer, jstring enumName) {
  	jint result;
  	ALCdevice* device = (ALCdevice*)pointer;
  	ALubyte* str;
  	str = (ALubyte*)(*env)->GetStringUTFChars(env,enumName,NULL);
  	result = alcGetEnumValue(device, str);
  	(*env)->ReleaseStringUTFChars(env,enumName,str);
	return result;  	
}

JNIEXPORT jint JNICALL Java_net_java_games_joal_ALCImpl_getContextsDeviceNative
  (JNIEnv *env, jobject obj, jint ptr) {
  	jint result;
  	ALvoid* alcHandle = (ALvoid*)ptr;
  	result = (jint)alcGetContextsDevice(alcHandle);
  	return result;
}
JNIEXPORT jstring JNICALL Java_net_java_games_joal_ALCImpl_alcGetStringNative
  (JNIEnv *env, jobject obj, jint ptr, jint pname) {
  	ALCdevice *device = (ALCdevice*)ptr;
  	ALubyte* p = alcGetString(device,(ALenum)pname);
  	return (*env)->NewStringUTF(env, p);
}

JNIEXPORT void JNICALL Java_net_java_games_joal_ALCImpl_alcGetIntegervNative
  (JNIEnv *env, jobject obj, jint ptr, jint pname, jint size, jintArray data) {
	ALint *p = (ALint*)(*env)->GetPrimitiveArrayCritical(env,data,0);
	ALCdevice *device = (ALCdevice*)ptr;
	if(p) {
		alcGetIntegerv(device,(ALenum)pname,(ALsizei)size,p);
	}
	(*env)->ReleasePrimitiveArrayCritical(env,data,p,0);
}