module main;

import derelict.openal.al;
import derelict.openal.alut;
import derelict.util.exception;
import derelict.util.loader;
import std.stdio;
import std.string;
import std.stream;
import fftw3: fftw_plan,fftw_r2r_kind,fftw_r2r_kind_do_not_use_me,FFTW_ESTIMATE,FFTW_FORWARD,fftw_complex;

GenericLoader DerelictFFTW;

void load(SharedLib lib)
{
    bindFunc(fftw_plan_dft_1d)("fftw_plan_dft_1d", lib);
    bindFunc(fftw_execute)("fftw_execute", lib);
    bindFunc(fftw_execute_dft)("fftw_execute_dft", lib);
    bindFunc(fftw_malloc)("fftw_malloc", lib);
    bindFunc(fftw_destroy_plan)("fftw_destroy_plan", lib);
    bindFunc(fftw_free)("fftw_free", lib);
}

static this()
{
	DerelictFFTW.setup(
        "",
        "./libfftw3.so.1",
        "",
        &load
    	);
}

typedef fftw_plan function(int n, cdouble *d_in, cdouble *d_out, int sign, uint flags) pffftw_plan_dft_1d;
typedef void function(fftw_plan p) pffftw_execute;
typedef void function(fftw_plan p, cdouble *d_in, cdouble *d_out) pffftw_execute_dft;
typedef void *function(size_t n) pffftw_malloc;
typedef void function(fftw_plan p) pffftw_destroy_plan;
typedef void function(void *p) pffftw_free;

pffftw_plan_dft_1d fftw_plan_dft_1d;
pffftw_execute fftw_execute;
pffftw_execute_dft fftw_execute_dft;
pffftw_malloc fftw_malloc;
pffftw_destroy_plan fftw_destroy_plan;
pffftw_free fftw_free;


bool missingProcCallback(char[] libName, char[] procName)
{
    if( procName.cmp("gluErrorUnicodeStringEXT") == 0 )
    {
        DerelictErrors ~= "Could not load gluErrorUnicodeStringEXT -- ignoring\n";
        return true;
    }
    else if( procName.cmp("alSource3i") == 0 )
    {
	    DerelictErrors ~= "Could not load alSource3i -- ignoring\n";
        return true;
    }
    else if( procName.cmp("alSourceiv") == 0 )
    {
	    DerelictErrors ~= "Could not load alSourceiv -- ignoring\n";
	    return true;
    }
    else if( procName.cmp("alutLoadMemoryHelloWorld") == 0)
    {
	    DerelictErrors ~= "Could not load alutLoadMemoryHelloWorld -- ignoring\n";
        return true;
    }
    else if( procName.cmp("alutLoadMemoryWaveform") == 0)
    {
	    DerelictErrors ~= "Could not load alutLoadMemoryWaveform -- ignoring***\n";
	    return true;
    }
	else if( procName.cmp("vorbis_synthesis_idheader") == 0)
	{
	    DerelictErrors ~= "Could not load vorbis_synthesis_idheader -- ignoring\n";
	    return true;
	}
    return false;
}

char[] DerelictErrors;

ALenum format;
ALsizei size;
ALvoid* data;
ALsizei freq;
ALboolean loop;
double[] _data;

ALuint buffer;
ALuint source;
ALfloat[3] sourcePos = [0.0, 0.0, 0.0];
ALfloat[3] sourceVel = [0.0, 0.0, 0.0];
ALfloat[3] sourceOri = [0.0, 0.0, 0.0];

ALfloat[3] listenerPos = [0.0, 0.0, 1.0];
ALfloat[3] listenerVel = [0.0, 0.0, 0.0];
ALfloat[3] listenerOri = [0.0, 0.0, 0.0];

cdouble[] idata;
cdouble[] odata;

ALboolean LoadALData(char* filename)
{
   alutInit(null,null);
   //buffer = alutCreateBufferFromFile("./Gong.wav");
   if (filename == "")
   	buffer = alutCreateBufferHelloWorld ();
   else
   {
        alGenBuffers(1, &buffer);
        alutLoadWAVFile(cast(ALbyte *)filename, &format, &data, &size, &freq, &loop);
        alBufferData(buffer, format, data, size, freq);
   }
   alGenSources(1, &source);
   alSourcei(source, AL_BUFFER, buffer);
   alSourcefv(source, AL_POSITION, sourcePos.ptr);
   alSourcefv(source, AL_VELOCITY, sourceVel.ptr);
   alSourcefv(source, AL_DIRECTION, sourceOri.ptr);
   alListenerfv(AL_POSITION,listenerPos.ptr);
   alListenerfv(AL_VELOCITY,listenerVel.ptr);
   alListenerfv(AL_ORIENTATION,listenerOri.ptr);
   return AL_FALSE;
}

void FFTW(char[] filename)
{
   int bits;
   int val, val2;
   alGetBufferi(buffer,AL_BITS,&bits);
   writefln(size);
   writefln(bits);
   _data.length = size;
   File f = new File(filename, FileMode.In);
   f.seekCur(44);
   char[] b;
   b.length = size;
   writefln(f.readBlock(cast(void*)b, size));
   f.close;
   for(uint i=0; i<size; i++)
   {
        val = cast(int)b[i];
	if (bits == 16)
	{
		val2 = cast(int)b[i];
                if (val2 > 127) { val2 = val2 - 255; }
		_data[i] = 256*val2 + val;
	}
	else
	{
		_data[i] = val;
	}
        //writefln(_data[i]);
   }
   idata.length = size;
   odata.length = size;
   fftw_plan rplan;
   //rdata = cast(fftw_complex*)fftw_malloc(fftw_complex.sizeof * size);
   //idata = cast(fftw_complex*)fftw_malloc(fftw_complex.sizeof * size);
   //rdata[1] = cast(fftw_complex)0;
   //fftw_execute(rplan);
   //fftw_free(rdata);
   //for (uint i = 0; i < size; i++) { idata[i] = cast(cdouble)0; }
   for (uint i = 0; i < size; i++) 
   { 
   	idata[i] = _data[i] + 0i; 
   }
   rplan = fftw_plan_dft_1d(size, idata.ptr, odata.ptr, FFTW_FORWARD, FFTW_ESTIMATE);
   fftw_execute(rplan);
   for (uint i = 0; i < size; i++) { writefln(odata[i]); }
   //fftw_execute(rplan);
   //for (uint i = 0; i < size; i++) { idata[i] = 0; }
   //for (uint i = 0; i < size; i++) { rdata[i] = cast(cdouble)_data[i]; }
   //fftw_execute_dft(rplan,idata.ptr, odata.ptr);
}

void KillALData()
{
   alDeleteBuffers(1, &buffer);
   alDeleteSources(1, &source);
}


void main()
{
   Derelict_SetMissingProcCallback(&missingProcCallback);
   DerelictAL.load("./libopenal.so, ./libopenal.so.1");
   DerelictALUT.load("./libalut.so, ./libalut.so.0, ./libfftw3.so.1 ");
   DerelictFFTW.load();
   // Initialize OpenAL and clear the error bit.
   alGetError();

   // Load the wav data.
   if(LoadALData("Gong.wav") != AL_FALSE)
   {
       return;
   }
   FFTW("Gong.wav");
   ALenum state=AL_PLAYING;
   alSourcePlay(source);
   while(state==AL_PLAYING)
   {
	   alGetSourcei(source, AL_SOURCE_STATE, &state);
   }

   scope(exit)    {KillALData;}
}