#include <jni.h>
#include <fftw.h>
#include <fftw-int.h>
#include "fft_Fft.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>


#define REAL 0
#define IMAG 1

fftw_complex* readData(JNIEnv *, jobject, jobjectArray, jint*);
static jobjectArray writeData(JNIEnv *, fftw_complex * , jint, fftw_direction);


JNIEXPORT jobjectArray JNICALL Java_fft_Fft_n_1Direct_11D_1Estim_1fft(JNIEnv * env, jobject obj, jobjectArray valuesJ)
{
	fftw_complex * input;
	jint len;
	jobjectArray finalOutputArray;
	fftw_plan plan;
	fftw_complex * output;

	/*---------INPUT----------*/
	input = readData(env, obj, valuesJ, &len);

	/*--------------------CALCULATION-----------------------*/
	output = (fftw_complex*)malloc((len)*sizeof(fftw_complex));
	plan = fftw_create_plan(len, FFTW_FORWARD, FFTW_ESTIMATE);
	fftw_one(plan, input, output);
	free(input);
	fftw_destroy_plan(plan);

	/*---------OUTPUT----------*/
	finalOutputArray = writeData(env, output, len, FFTW_FORWARD);
	free(output);
	return (jobjectArray)finalOutputArray;
}


JNIEXPORT jobjectArray JNICALL Java_fft_Fft_n_1Direct_11D_1Measure_1fft(JNIEnv * env, jobject obj, jobjectArray valuesJ)
{
	fftw_complex * input;
	jint len;
	jobjectArray finalOutputArray;
	fftw_plan plan;
	fftw_complex * output;

	/*---------INPUT----------*/
	len = (*env)->GetArrayLength(env, valuesJ);
	input = readData(env, obj, valuesJ, &len);

	/*--------------------CALCULATION-----------------------*/
	output = (fftw_complex*)malloc((len)*sizeof(fftw_complex));
	plan = fftw_create_plan(len, FFTW_FORWARD, FFTW_MEASURE);
	fftw_one(plan, input, output);
	free(input);
	fftw_destroy_plan(plan);

	/*---------OUTPUT----------*/
	finalOutputArray = writeData(env, output, len, FFTW_FORWARD);
	free(output);
	return (jobjectArray)finalOutputArray;
}


JNIEXPORT jobjectArray JNICALL Java_fft_Fft_n_1Reverse_11D_1Estim_1fft(JNIEnv * env, jobject obj, jobjectArray valuesJ)
{
	fftw_complex * input;
	jint len;
	jobjectArray finalOutputArray;
	fftw_plan plan;
	fftw_complex * output;

	/*---------INPUT----------*/
	len = (*env)->GetArrayLength(env, valuesJ);
	input = readData(env, obj, valuesJ, &len);

	/*--------------------CALCULATION-----------------------*/
	output = (fftw_complex*)malloc((len)*sizeof(fftw_complex));
	plan = fftw_create_plan(len, FFTW_BACKWARD, FFTW_ESTIMATE);
	fftw_one(plan, input, output);
	free(input);
	fftw_destroy_plan(plan);

	/*---------OUTPUT----------*/
	finalOutputArray = writeData(env, output, len, FFTW_BACKWARD);
	free(output);
	return (jobjectArray)finalOutputArray;
}


JNIEXPORT jobjectArray JNICALL Java_fft_Fft_n_1Reverse_11D_1Measure_1fft(JNIEnv * env, jobject obj, jobjectArray valuesJ)
{
	fftw_complex * input;
	jint len;
	jobjectArray finalOutputArray;
	fftw_plan plan;
	fftw_complex * output;

	/*---------INPUT----------*/
	len = (*env)->GetArrayLength(env, valuesJ);
	input = readData(env, obj, valuesJ, &len);

	/*--------------------CALCULATION-----------------------*/
	output = (fftw_complex*)malloc((len)*sizeof(fftw_complex));
	plan = fftw_create_plan(len, FFTW_BACKWARD, FFTW_MEASURE);
	fftw_one(plan, input, output);
	free(input);
	fftw_destroy_plan(plan);

	/*---------OUTPUT----------*/
	finalOutputArray = writeData(env, output, len, FFTW_BACKWARD);
	free(output);
	return (jobjectArray)finalOutputArray;
}


static jobjectArray writeData(JNIEnv * env, fftw_complex * output, jint len, fftw_direction direction)
{
	int i;
	jclass dclass;
	jdoubleArray outputArrayX, outputArrayY;
	jobjectArray finalOutputArray;
	double* outputX;
	double* outputY;

	dclass = (*env)->FindClass(env, "[D");
	finalOutputArray = (*env)->NewObjectArray(env, 2, dclass, NULL);

	outputArrayX = (*env)->NewDoubleArray(env, len);
	outputX = (double *)malloc(len*sizeof(jdouble));
	if (direction==FFTW_FORWARD){
		for (i=0;i<(int)(len/2);i++)
			{outputX[i]=output[i+(int)(len/2)].re;
			outputX[i+(int)(len/2)]=output[i].re;}
	}else{
		for (i=0;i<len;i++){outputX[i]=output[i].re;}
	}
	(*env)->SetDoubleArrayRegion(env, outputArrayX, 0, len, outputX);
	(*env)->SetObjectArrayElement(env, finalOutputArray, REAL, outputArrayX);
	free(outputX);

	outputArrayY = (*env)->NewDoubleArray(env, len);
	outputY = (double *)malloc(len*sizeof(jdouble));
	if (direction==FFTW_FORWARD){
		for (i=0;i<(int)(len/2);i++)
			{outputY[i]=output[i+(int)(len/2)].im;
			outputY[i+(int)(len/2)]=output[i].im;}
	}else{
		for (i=0;i<len;i++){outputY[i]=output[i].im;}
	}
	(*env)->SetDoubleArrayRegion(env, outputArrayY, 0, len, outputY);
	(*env)->SetObjectArrayElement(env, finalOutputArray, IMAG, outputArrayY);
	free(outputY);

	return (jobjectArray)finalOutputArray;
}

/*static fftw_complex* readData(JNIEnv * env, jobject obj, jobjectArray array, jint* len)*/
fftw_complex* readData(JNIEnv * env, jobject obj, jobjectArray array, jint* len)
{
	int i;
	jdouble * inputReal;
	jdouble * inputImag;
	jdoubleArray inputRealPart;
	jdoubleArray inputImagPart;
	fftw_complex* tempArray;
/*printf("fft read 0 %d\n",REAL);*/

	inputRealPart = (jdoubleArray)(*env)->GetObjectArrayElement(env, array, REAL);
/*printf("fft read 1\n");*/
	inputImagPart = (jdoubleArray)(*env)->GetObjectArrayElement(env, array, IMAG);

/*printf("fft read 2\n");*/

	(*len) = (*env)->GetArrayLength(env, inputRealPart);
/*printf("fft read 3 %d %d\n", (int)(*len), sizeof(fftw_complex));*/

	tempArray = (fftw_complex*)malloc(((int)(*len))*sizeof(fftw_complex));

/*printf("fft read 3.1\n");*/

	inputReal = (*env)->GetDoubleArrayElements(env, (jdoubleArray)inputRealPart, 0);
	inputImag = (*env)->GetDoubleArrayElements(env, (jdoubleArray)inputImagPart, 0);
/*printf("fft read 4\n");*/

	for (i = 0;i<(*len);i++)
	{
		tempArray[i].re = (jdouble)inputReal[i];
		tempArray[i].im = (jdouble)inputImag[i];
	}
/*printf("fft read 5\n");*/

	(*env)->ReleaseDoubleArrayElements(env, inputRealPart, inputReal, 0);
	(*env)->ReleaseDoubleArrayElements(env, inputImagPart, inputImag, 0);
/*printf("fft read\n");*/

	return tempArray;
}