// AudioSource.cpp: implementation of the AudioSource class.
//
//////////////////////////////////////////////////////////////////////

#include <algorithm>
#include <iostream>

#include "AudioSource.h"
#include "AudioSink.h"
#include "AudioSample.h"

using namespace std;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

AudioSource::AudioSource()
{
	bSourceRunning = false;
	bSourceThreadRunning = false;
	bSourceThreadShouldStop = true;
	sourceThreadHandle = NULL;
	sourceThreadID = 0;
	sourceThreadStartEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	sourceThreadStopEvent  = CreateEvent(NULL, FALSE, FALSE, NULL);
	InitializeCriticalSection(&audioSinksMutex);
	InitializeCriticalSection(&sourceThreadMutex);
	InitializeCriticalSection(&sourceStateMutex);
	InitializeCriticalSection(&sourceStartStopMutex);
}

AudioSource::~AudioSource()
{
	CloseHandle(sourceThreadStartEvent);
	CloseHandle(sourceThreadStopEvent);
	DeleteCriticalSection(&audioSinksMutex);
	DeleteCriticalSection(&sourceThreadMutex);
	DeleteCriticalSection(&sourceStateMutex);
	DeleteCriticalSection(&sourceStartStopMutex);
}

int 
AudioSource::SubscribeAudioSink(AudioSink *audioSink)
{
	EnterCriticalSection(&audioSinksMutex);
	if (find(audioSinks.begin(), audioSinks.end(), audioSink) == audioSinks.end())
	{
		audioSinks.push_back(audioSink);
	}
	LeaveCriticalSection(&audioSinksMutex);
	return 0;
}

int
AudioSource::UnsubscribeAudioSink(AudioSink *audioSink)
{
	EnterCriticalSection(&audioSinksMutex);
	vector<AudioSink *>::iterator position = NULL;
	position = find(audioSinks.begin(), audioSinks.end(), audioSink);
	if (position != audioSinks.end())
	{
		audioSinks.erase(position);
	}
	LeaveCriticalSection(&audioSinksMutex);
	return 0;
}

int
AudioSource::StartSource()
{
	int result(0);
	SetTraceLevel();
	EnterCriticalSection(&sourceStateMutex);
	if (bSourceThreadRunning || bSourceRunning)
	{
		result = -10;
		tracer.tracef(ERR, "StartSource : bSourceThreadRunning = %d, bSourceRunning = %d\n", bSourceThreadRunning, bSourceRunning);
	}
	else
	{
		result = SourceStarted();
		if (result != 0)
		{
			tracer.tracef(ERR, "StartSource : SourceStarted returned error %d\n", result);
			result = -20;
		}
		else
		{
			bSourceRunning = true;
		}
	}
	LeaveCriticalSection(&sourceStateMutex);
	return result;
}

int
AudioSource::StopSource()
{
	int result(0);
	EnterCriticalSection(&sourceStateMutex);
	if (bSourceThreadRunning)
	{
		result = -10;
	}
	else
	{
		result = SourceStopped();
		if (result != 0)
		{
			tracer.tracef(ERR, "StopSource : SourceStopped returned error %d\n", result);
			result = -20;
		}
		bSourceRunning = false;
	}
	LeaveCriticalSection(&sourceStateMutex);
	return result;
}

int
AudioSource::StartSourceThread()
{
	tracer.tracef(EE, "StartSourceThread\n");
	int result(0);
	SetTraceLevel();
	tracer.tracef(ARB, "StartSourceThread : entering  sourceStateMutex\n");
	EnterCriticalSection(&sourceStateMutex);
	do
	{
		if (bSourceRunning || bSourceThreadRunning)
		{
			tracer.tracef(ERR, "StartSourceThread : e-error : bSourceRunning = %d, bSourceThreadRunning = %d\n", bSourceRunning, bSourceThreadRunning);
			result = -10;
			break;
		}
		if (sourceThreadHandle != NULL || sourceThreadID != 0)
		{
			tracer.tracef(ERR, "StartSourceThread : e-error : sourceThreadHandle = 0x%x, sourceThreadID = 0x%x\n", sourceThreadHandle, sourceThreadID);
			result = -20;
			break;
		}
		BOOL resetResult;
		tracer.tracef(ARB, "StartSourceThread : resetting sourceThreadStartEvent and sourceThreadStopEvent\n");
		resetResult = ResetEvent(sourceThreadStartEvent);
		if (resetResult == 0)
		{
			tracer.tracef(ERR, "StartSourceThread : e-ResetEvent(sourceThreadStartedEvent) : 0x%x\n", GetLastError());
		}
		resetResult = ResetEvent(sourceThreadStopEvent);
		if (resetResult == 0)
		{
			tracer.tracef(ERR, "StartSourceThread : e-ResetEvent(sourceThreadStopEvent) : 0x%x\n", GetLastError());
		}
		bSourceThreadShouldStop = true;		// we make it false only if everything else succeeds
		sourceThreadHandle = CreateThread(NULL, 0, SourceThreadProc, (void *)this, CREATE_SUSPENDED, &sourceThreadID);
		if (sourceThreadHandle == NULL)
		{
			sourceThreadID = 0;
			result = -20;
			break;
		}
		result = SourceThreadStarted(sourceThreadHandle, sourceThreadID);
		if (result != 0)
		{
			result = -30;
		}
		if (result == 0)	// otherwise, if there is an error in SourceThreadStarted, we should stop the thread
		{
			bSourceThreadShouldStop = false;
		}
		DWORD result = ResumeThread(sourceThreadHandle);
		if (result == -1)
		{
			TerminateThread(sourceThreadHandle, 0);
			sourceThreadHandle = NULL;
			sourceThreadID = 0;
			result = -40;
			break;
		}
		tracer.tracef(ARB, "StartSourceThread : before WaitForSingleObject(sourceThreadStartEvent, INFINITE)\n");
		DWORD waitResult = WaitForSingleObject(sourceThreadStartEvent, INFINITE);
		tracer.tracef(ARB, "StartSourceThread : waitResult = 0x%x\n", waitResult);
		if (waitResult == WAIT_FAILED)
		{
			waitResult = GetLastError();
			tracer.tracef(ERR, "StartSourceThread : e-WaitForSingleObject : %d 0x%x\n", waitResult, waitResult);
		}
	} while (false);
	LeaveCriticalSection(&sourceStateMutex);
	tracer.tracef(ARB, "StartSourceThread : left  sourceStateMutex\n");
	tracer.tracef(EE, "~StartSourceThread : returning %d\n", result);
	return result;
}

int
AudioSource::StopSourceThread()
{
	int result(0);
	bool waitForThread = true;
	tracer.tracef(EE, "StopSourceThread\n");
	EnterCriticalSection(&sourceStartStopMutex);
	tracer.tracef(ARB, "StopSourceThread : entered  sourceStartStopMutex\n");
	EnterCriticalSection(&sourceStateMutex);
	tracer.tracef(ARB, "StopSourceThread : entered  sourceStateMutex\n");
	do
	{
		if (!bSourceThreadRunning)
		{
			tracer.tracef(SIG, "StopSourceThread : bSourceThreadRunning = false\n");
			result = 0;
			waitForThread = false;
			break;
		}
		bSourceThreadShouldStop = true;
	} while (false);

	LeaveCriticalSection(&sourceStateMutex);
	tracer.tracef(ARB, "StopSourceThread : left  sourceStateMutex\n");
	if (waitForThread)
	{
		tracer.tracef(ARB, "StopSourceThread : before WaitForSingleObject(sourceThreadStopEvent, INFINITE)\n");
		DWORD waitResult = WaitForSingleObject(sourceThreadStopEvent, INFINITE);
		tracer.tracef(ARB, "StopSourceThread : waitResult = 0x%x\n", waitResult);
		if (waitResult == WAIT_FAILED)
		{
			waitResult = GetLastError();
			tracer.tracef(ERR, "StopSourceThread : e-WaitForSingleObject : %d 0x%x\n", waitResult, waitResult);
		}
	}
	LeaveCriticalSection(&sourceStartStopMutex);
	tracer.tracef(ARB, "StopSourceThread : left  sourceStartStopMutex\n");
	tracer.tracef(EE, "~StopSourceThread : returning %d\n", result);
	return result;
}

DWORD WINAPI
AudioSource::SourceThreadProc(LPVOID params)
{
	int result(0);
	AudioSource *audioSource = (AudioSource *)params;
	audioSource->tracer.tracef(EE, "SourceThreadProc : begin\n");
	audioSource->bSourceThreadRunning = true;
	SetEvent(audioSource->sourceThreadStartEvent);
	while (!audioSource->bSourceThreadShouldStop)
	{
		AudioSample *pAudioSample = NULL;
		if ((result = audioSource->GenerateData(&pAudioSample)) < 0)
		{
			audioSource->tracer.tracef(ERR, "SourceThreadProc : GenerateData returned %d\n", result);
			break;
		}
		if (!pAudioSample)
		{
			audioSource->tracer.tracef(ERR, "SourceThreadProc : GenerateData returned NULL\n");
		}
		EnterCriticalSection(&(audioSource->audioSinksMutex));
		vector<AudioSink *>::iterator iter = (audioSource->audioSinks).begin();
		for (iter = (audioSource->audioSinks).begin(); iter != (audioSource->audioSinks).end(); iter++)
		{
			int i = audioSource->SendAudioSample(pAudioSample, *iter);
		}
		LeaveCriticalSection(&(audioSource->audioSinksMutex));
		if (pAudioSample)
		{
			pAudioSample->Release(audioSource);
			pAudioSample = NULL;
		}
	}
	audioSource->tracer.tracef(ARB, "SourceThreadProc : broke out of while loop. bSourceThreadShouldStop = %d\n", audioSource->bSourceThreadShouldStop);

	audioSource->tracer.tracef(EE, "SourceThreadProc : entering sourceStateMutex\n");
	EnterCriticalSection(&(audioSource->sourceStateMutex));
	audioSource->bSourceThreadRunning = false;
	
	audioSource->tracer.tracef(ARB, "SourceThreadProc : calling SourceThreadStopped\n");
	audioSource->SourceThreadStopped(audioSource->sourceThreadHandle, audioSource->sourceThreadID);
	
	CloseHandle(audioSource->sourceThreadHandle);
	audioSource->sourceThreadHandle = NULL;
	audioSource->sourceThreadID = 0;

	LeaveCriticalSection(&(audioSource->sourceStateMutex));
	audioSource->tracer.tracef(EE, "SourceThreadProc : left sourceStateMutex\n");

	audioSource->tracer.tracef(EE, "SourceThreadProc : setting sourceThreadStopEvent and exiting\n");
	BOOL setResult = SetEvent(audioSource->sourceThreadStopEvent);
	return 0;
}

int
AudioSource::SendAudioSample(AudioSample *audioSample, AudioSink *audioSink)
{
//	tracer.tracef(DET, "SendAudioSample : calling TakeNextAudioSample\n");
	return audioSink->TakeNextAudioSample(audioSample, this);
}

int
AudioSource::SourceThreadStarted(HANDLE sourceThreadHandle, DWORD sourceThreadID)
{
	return 0;
}

int
AudioSource::SourceThreadStopped(HANDLE sourceThreadHandle, DWORD sourceThreadID)
{
	return 0;
}

int
AudioSource::SourceStarted()
{
	return 0;
}

int
AudioSource::SourceStopped()
{
	return 0;
}

int
AudioSource::GiveNextAudioSample(AudioSample **ppAudioSample, AudioSink *audioSink)
{
	*ppAudioSample = NULL;
	int result = GenerateData(ppAudioSample);
	if (result != 0 || *ppAudioSample == NULL)
	{
		tracer.tracef(ERR, "GiveNextAudioSample : GenerateData returned error %d, audioSample 0x%x\n", result, *ppAudioSample);
		if (*ppAudioSample)
		{
			(*ppAudioSample)->Release(this);
			*ppAudioSample = NULL;
		}
	}
	EnterCriticalSection(&audioSinksMutex);
	vector<AudioSink *>::iterator iter = audioSinks.begin();
	for (iter = audioSinks.begin(); iter != audioSinks.end(); iter++)
	{
		if (*(iter) == audioSink)
		{
			continue;
		}
		SendAudioSample(*ppAudioSample, *iter);
	}
	LeaveCriticalSection(&audioSinksMutex);
	return result;
}

int
AudioSource::GenerateData(AudioSample **audioSample)
{
	tracer.tracef(ERR, "GenerateData : ERROR : Pure Virtual Function Call !!!\n");
	return 0;
}