module main;

private
{
	import std.stdio;
	import derelict.openal.al;
}

const uint frequency = 44100;
const uint seconds = 5;
ALuint Source, Buffer;

void* capture(out uint size)
{
	//ALCchar* deviceName = alcGetString(null,0x310);
        ALCchar* deviceName = alcGetString(null, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
	writefln("DEVICE: %s",cast(char*)deviceName);
	ALCdevice *captureDevice = alcCaptureOpenDevice(deviceName /*Just get first one*/,frequency /*Frequency*/,AL_FORMAT_MONO16,frequency * 2 * seconds /*10 Seconds worth*/);
        ALCvoid *buf;
 	alcCaptureStart(captureDevice);
        int frameCount;
	do
   	{
       		alcGetIntegerv(captureDevice,ALC_CAPTURE_SAMPLES,1,&frameCount);
		//alcCaptureSamples(captureDevice, buf, frameCount);
                writefln("FrameCount: %d",frameCount);
   	}
   	//10 Seconds at least
   	while(frameCount <= frequency * seconds);     //Stop since we are done 
        writefln("DEVICE: %s",cast(char*)deviceName);
	foreach(i,error;[AL_NO_ERROR,AL_INVALID_NAME,AL_INVALID_ENUM,AL_INVALID_VALUE,AL_INVALID_OPERATION,AL_OUT_OF_MEMORY])
	{
		if(error != AL_NO_ERROR)
       		{
			writefln("ERROR: %s",cast(char*)alGetString(error));
		}
	}
	return buf;
}

ALboolean LoadALData()
{
	ALCdevice* device = alcOpenDevice(null);

	ALCcontext* context = alcCreateContext(device,null);
	alcMakeContextCurrent(context);
	alGenBuffers(1, &Buffer);

   	int error = alGetError();
   	if(error != AL_NO_ERROR)
   	{
       		writef("ERROR: ");
		writefln(error);
       		return AL_FALSE;
   	}

   	uint size;
        ALCvoid *buff;
	buff = capture(size);
   	alBufferData(Buffer, AL_FORMAT_MONO16, cast(void*)buff, size, frequency);
 
   	error = alGetError();
   	if(error != AL_NO_ERROR)
   	{
		writef("ERROR2: ");
                writefln(error);
       		return AL_FALSE;   		
	}

   	// Bind the buffer with the source.
   	alGenSources(1, &Source);
   	error = alGetError();
   	if(error != AL_NO_ERROR)
   	{
		writef("ERROR3: ");
                writefln(error);
       		return AL_FALSE;
   	}

   	alSourcef (Source, AL_PITCH,    1.0      );
   	alSourcef (Source, AL_GAIN,     2.0      );
   	alSourcei (Source, AL_LOOPING,  true     );
   	alSourcei (Source, AL_BUFFER,  Buffer     );
 
   	// Do another error check and return.
   	error = alGetError();
   	if(error == AL_NO_ERROR)
       		return AL_TRUE;

	writef("ERROR4: ");
        writefln(error);
   	return AL_FALSE;
}

void KillALData()
{
	alDeleteBuffers(1, &Buffer);
	alDeleteSources(1, &Source);
}

int main(char[][] args)
{
	DerelictAL.load();
	
	// Initialize OpenAL and clear the error bit.
   	alGetError();

	// Load the wav data.
   	if(LoadALData() == AL_FALSE)
   	{
		writefln("Error loading data.");
		writefln("");
       		return 1;
   	}
	alSourcePlay(Source);
	scope(exit)
	{
		KillALData();
		DerelictAL.unload();
	}
	return 0;
}