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

#include <algorithm>

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

using namespace std;

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

AudioSink::AudioSink()
{
	bSinkRunning = false;
	bSinkThreadRunning = false;
	sinkThreadHandle = NULL;
	sinkThreadID = 0;
	sinkThreadStartEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	sinkThreadStopEvent  = CreateEvent(NULL, FALSE, FALSE, NULL);
	InitializeCriticalSection(&audioSourcesMutex);
	InitializeCriticalSection(&sinkThreadMutex);
	InitializeCriticalSection(&sinkStateMutex);
	InitializeCriticalSection(&sinkStartStopMutex);
}

AudioSink::~AudioSink()
{
	CloseHandle(sinkThreadStartEvent);
	CloseHandle(sinkThreadStopEvent);
	DeleteCriticalSection(&audioSourcesMutex);
	DeleteCriticalSection(&sinkThreadMutex);
	DeleteCriticalSection(&sinkStateMutex);
	DeleteCriticalSection(&sinkStartStopMutex);
}

int
AudioSink::SubscribeAudioSource(AudioSource *audioSource)
{
	EnterCriticalSection(&audioSourcesMutex);
	if (find(audioSources.begin(), audioSources.end(), audioSource) == audioSources.end())
	{
		audioSources.push_back(audioSource);
	}
	LeaveCriticalSection(&audioSourcesMutex);
	return 0;
}

int
AudioSink::UnsubscribeAudioSource(AudioSource *audioSource)
{
	EnterCriticalSection(&audioSourcesMutex);
	vector<AudioSource *>::iterator position = NULL;
	position = find(audioSources.begin(), audioSources.end(), audioSource);
	if (position != audioSources.end())
	{
		audioSources.erase(position);
	}
	LeaveCriticalSection(&audioSourcesMutex);
	return 0;
}

int
AudioSink::RenderAudioSamples(std::vector<std::pair<AudioSample *, AudioSource *> > &data)
{
	tracer.tracef(ERR, "RenderAudioSamples : ERROR : pure virtual function call !!!\n");
	return 0;
}

int
AudioSink::TakeNextAudioSample(AudioSample *audioSample, AudioSource *audioSource)
{
	int result(0);
	inputData.clear();
	if (audioSample)
	{
		audioSample->AddRef(this);	// we later release it
		inputData.push_back(make_pair(audioSample, audioSource));
	}

	EnterCriticalSection(&audioSourcesMutex);
	vector<AudioSource *>::iterator iter = audioSources.begin();
	for (iter=audioSources.begin(); iter!=audioSources.end(); iter++)
	{
		if (*iter == audioSource)
		{
			continue;
		}
		AudioSample *pAudioSample = NULL;
//		tracer.tracef(DET, "TakeNextAudioSample : calling GiveNextAudioSample\n");
		result = (*iter)->GiveNextAudioSample(&pAudioSample, this);
		if (result != 0)
		{
			tracer.tracef(ERR, "TakeNextAudioSample : GiveNextAudioSample from %s returned error %d\n", (*iter)->TraceName(), result);
			if (pAudioSample)
			{
				pAudioSample->Release(this);
				pAudioSample = NULL;
			}
		}
		else
		{
			if (pAudioSample)
			{
				inputData.push_back(make_pair(pAudioSample, *iter));
			}
		}
	}
	LeaveCriticalSection(&audioSourcesMutex);
	result = RenderAudioSamples(inputData);
	for (int i=0; i<inputData.size(); i++)
	{
		AudioSample *sample = inputData[i].first;
		if (sample)
		{
			sample->Release(this);
			sample = NULL;
		}
	}
	return result;
}

int
AudioSink::StartSink()
{
	int result(0);
	SetTraceLevel();
	EnterCriticalSection(&sinkStateMutex);
	if (bSinkThreadRunning || bSinkRunning)
	{
		result = -10;
		tracer.tracef(ERR, "StartSink : bSinkRunning = %d, bSinkThreadRunning = %d\n", bSinkRunning, bSinkThreadRunning);
	}
	else
	{
		result = SinkStarted();
		if (result != 0)
		{
			tracer.tracef(ERR, "StartSink : SinkStarted returned %d\n", result);
			result = -20;
		}
		else
		{
			bSinkRunning = true;
		}
	}
	LeaveCriticalSection(&sinkStateMutex);
	return result;
}

int
AudioSink::StopSink()
{
	int result(0);
	EnterCriticalSection(&sinkStateMutex);
	if (bSinkThreadRunning)
	{
		result = -10;
		tracer.tracef(ERR, "StopSink : bSinkThreadRunning = %d\n", bSinkThreadRunning);
	}
	else
	{
		if (bSinkRunning)
		{
			result = SinkStopped();
			if (result != 0)
			{
				tracer.tracef(ERR, "StartSink : SinkStarted returned %d\n", result);
				result = -20;
			}
			else
			{
				bSinkRunning = false;
			}
		}
		else
		{
			tracer.tracef(SIG, "StopSink : bSinkRunning = false\n");
		}
	}
	LeaveCriticalSection(&sinkStateMutex);
	return result;
}

int
AudioSink::StartSinkThread()
{
	int result(0);
	int returnCode(0);
	tracer.tracef(EE, "StartSinkThread\n");
	SetTraceLevel();
	EnterCriticalSection(&sinkStateMutex);
	tracer.tracef(ARB, "StartSinkThread : entered sinkStateMutex\n");
	do
	{
		if (bSinkRunning || bSinkThreadRunning)
		{
			tracer.tracef(ERR, "StartSinkThread : e-error : bSinkRunning = %d, bSinkThreadRunning = %d\n", bSinkRunning, bSinkThreadRunning);
			result = -10;
			break;
		}
		if (sinkThreadHandle != NULL || sinkThreadID != 0)
		{
			tracer.tracef(ERR, "StartSinkThread : e-error : sinkThreadHandle = 0x%x, sinkThreadID = 0x%x\n", sinkThreadHandle, sinkThreadID);
			result = -20;
			break;
		}
		ResetEvent(sinkThreadStartEvent);
		ResetEvent(sinkThreadStopEvent);
		bSinkThreadShouldStop = true;		// we make it false only if everything else succeeds
		sinkThreadHandle = CreateThread(NULL, 0, SinkThreadProc, (void *)this, CREATE_SUSPENDED, &sinkThreadID);
		if (sinkThreadHandle == NULL)
		{
			sinkThreadID = 0;
			tracer.tracef(ERR, "StartSinkThread : e-CreateThread\n");
			result = -30;
			break;
		}
		returnCode = SinkThreadStarted(sinkThreadHandle, sinkThreadID);
		if (returnCode != 0)
		{
			tracer.tracef(ERR, "StartSinkThread : e-SinkThreadStarted : %d 0x%x\n", returnCode, returnCode);
			result = -40;
		}
		if (result == 0)	// this ensures that if SinkThreadStarted failed, then we stop the thread
		{
			bSinkThreadShouldStop = false;
		}
		returnCode = ResumeThread(sinkThreadHandle);
		if (result == -1)
		{
			TerminateThread(sinkThreadHandle, 0);
			sinkThreadHandle = NULL;
			sinkThreadID = 0;
			tracer.tracef(ERR, "StartSinkThread : e-ResumeThread : %d 0x%x\n", returnCode, returnCode);
			result = -50;
			break;
		}
		WaitForSingleObject(sinkThreadStartEvent, INFINITE);
	}
	while (false);
	LeaveCriticalSection(&sinkStateMutex);
	tracer.tracef(ARB, "StartSinkThread : left  sinkStateMutex\n");
	tracer.tracef(EE, "~StartSinkThread : returning %d\n", result);
	return result;
}

int
AudioSink::StopSinkThread()
{
	int result(0);
	int returnCode(0);
	bool waitForThread = true;
	tracer.tracef(EE, "StopSinkThread\n");
	EnterCriticalSection(&sinkStartStopMutex);
	tracer.tracef(ARB, "StopSinkThread : entered sinkStartStopMutex\n");
	EnterCriticalSection(&sinkStateMutex);
	tracer.tracef(ARB, "StopSinkThread : entered sinkStateMutex\n");
	do
	{
		if (!bSinkThreadRunning)
		{
			tracer.tracef(SIG, "StopSinkThread : bSinkThreadRunning = false\n");
			result = 0;
			waitForThread = false;
			break;
		}
		bSinkThreadShouldStop = true;
	}
	while (false);

	LeaveCriticalSection(&sinkStateMutex);
	tracer.tracef(ARB, "StopSinkThread : left  sinkStateMutex\n");
	if (waitForThread)
	{
		tracer.tracef(ARB, "StopSinkThread : before WaitForSingleObject\n");
		WaitForSingleObject(sinkThreadStopEvent, INFINITE);
	}
	LeaveCriticalSection(&sinkStartStopMutex);
	tracer.tracef(ARB, "StopSinkThread : left  sinkStartStopMutex\n");
	tracer.tracef(EE, "~StopSinkThread : returning %d\n", result);
	return result;
}

DWORD WINAPI
AudioSink::SinkThreadProc(LPVOID params)
{
	int result(0);
	int returnCode(0);
	AudioSink *audioSink = (AudioSink *)params;
	Tracer &tracer = audioSink->tracer;
	tracer.tracef(EE, "SinkThreadProc : begin\n");
	audioSink->bSinkThreadRunning = true;
	tracer.tracef(ARB, "SinkThreadProc : setting sinkThreadStartEvent\n");
	SetEvent(audioSink->sinkThreadStartEvent);
	while (!audioSink->bSinkThreadShouldStop)
	{
		(audioSink->inputData).clear();
		tracer.tracef(DET, "SinkThreadProc : Entering audioSourcesMutex\n");
		EnterCriticalSection(&(audioSink->audioSourcesMutex));
		vector<AudioSource *>::iterator iter = (audioSink->audioSources).begin();
		for (iter = (audioSink->audioSources).begin(); iter != (audioSink->audioSources).end(); iter++)
		{
			AudioSample *pAudioSample = NULL;
			returnCode = (*iter)->GiveNextAudioSample(&pAudioSample, audioSink);
			if (returnCode != 0)
			{
				if (pAudioSample)
				{
					pAudioSample->Release(audioSink);
					pAudioSample = NULL;
				}
			}
			else
			{
				if (pAudioSample)
				{
					(audioSink->inputData).push_back(make_pair(pAudioSample, *iter));
				}
			}
		}
		LeaveCriticalSection(&(audioSink->audioSourcesMutex));
		tracer.tracef(DET, "SinkThreadProc : Left audioSourcesMutex\n");
		tracer.tracef(DET, "SinkThreadProc : Rendering audioSamples\n");
		returnCode = audioSink->RenderAudioSamples(audioSink->inputData);
		for (int i=0; i<(audioSink->inputData).size(); i++)
		{
			AudioSample *sample = (audioSink->inputData[i]).first;
			if (sample)
			{
				sample->Release(audioSink);
				sample = NULL;
			}
		}
	}
	tracer.tracef(ARB, "SinkThreadProc : broke out of while loop\n");

	tracer.tracef(EE, "SinkThreadProc : entering sinkStateMutex\n");
	EnterCriticalSection(&(audioSink->sinkStateMutex));
	audioSink->bSinkThreadRunning = false;
	
	tracer.tracef(ARB, "SinkThreadProc : calling SinkThreadStopped\n");
	audioSink->SinkThreadStopped(audioSink->sinkThreadHandle, audioSink->sinkThreadID);
	
	CloseHandle(audioSink->sinkThreadHandle);
	audioSink->sinkThreadHandle = NULL;
	audioSink->sinkThreadID = 0;
	
	LeaveCriticalSection(&(audioSink->sinkStateMutex));
	tracer.tracef(EE, "SinkThreadProc : left sinkStateMutex\n");

	tracer.tracef(ARB, "SinkThreadProc : setting sinkThreadStopEvent and exiting\n");
	BOOL setResult = SetEvent(audioSink->sinkThreadStopEvent);
	return result;
}

int
AudioSink::SinkThreadStarted(HANDLE sinkThreadHandle, DWORD sinkThreadID)
{
	return 0;
}

int
AudioSink::SinkThreadStopped(HANDLE sinkThreadHandle, DWORD sinkThreadID)
{
	return 0;
}

int
AudioSink::SinkStarted()
{
	return 0;
}

int
AudioSink::SinkStopped()
{
	return 0;
}