#include <thread/msgqueue.hpp>

WORD MessageQueue::postMessage(ThreadMessage &someThreadMessage)
{
	mMutexSemaphore.requestMutex();
	mNamedEvent.resetEvent();
	if(isQueueLocked()){mMutexSemaphore.releaseMutex();return FALSE;}
	putQueueMessage(someThreadMessage);
	mNamedEvent.setEvent();
	mMutexSemaphore.releaseMutex();
	return TRUE;
}

WORD MessageQueue::itemsInQueue(void)
{
	WORD queueMessages;

	mMutexSemaphore.requestMutex();
	queueMessages=mMessageQueueHigh.size();
	queueMessages+=mMessageQueueNormal.size();
	queueMessages+=mMessageQueueLow.size();
	mMutexSemaphore.releaseMutex();
	return queueMessages;
}

WORD MessageQueue::waitMessage(ThreadMessage &someThreadMessage)
{
	mNamedEvent.waitEvent(INFINITE,mIsAlertable);
	mMutexSemaphore.requestMutex();
  if(!getQueueMessage(someThreadMessage))
	{
    mMutexSemaphore.releaseMutex();
		mNamedEvent.resetEvent();
		return FALSE;
	}
	if(isQueueEmpty())mNamedEvent.resetEvent();
	mMutexSemaphore.releaseMutex();
	return TRUE;
}

WORD MessageQueue::peekMessage(ThreadMessage &someThreadMessage)
{
	WORD returnCode;
	mMutexSemaphore.requestMutex();
	returnCode=peekQueueMessage(someThreadMessage);
	mMutexSemaphore.releaseMutex();
	return returnCode;
}

WORD MessageQueue::putQueueMessage(ThreadMessage &someThreadMessage)
{
	if(ThreadMessage::PriorityNormal==someThreadMessage.priority())
	 mMessageQueueNormal.insert(&someThreadMessage);
	else if(ThreadMessage::PriorityHigh==someThreadMessage.priority())
	 mMessageQueueHigh.insert(&someThreadMessage);
	else mMessageQueueLow.insert(&someThreadMessage);
	return TRUE;
}

WORD MessageQueue::getQueueMessage(ThreadMessage &someThreadMessage)
{
	if(isQueueEmpty())return FALSE;

	if(mMessageQueueHigh.size())
	{
	  someThreadMessage=mMessageQueueHigh[0];
		mMessageQueueHigh.remove(0L);
	}
	else if(mMessageQueueNormal.size())
	{
	  someThreadMessage=mMessageQueueNormal[0];
	  mMessageQueueNormal.remove(0L);
	}
	else
	{
	  someThreadMessage=mMessageQueueLow[0];
		mMessageQueueLow.remove(0L);
	}
	return TRUE;
}

WORD MessageQueue::peekQueueMessage(ThreadMessage &someThreadMessage)
{
	if(isQueueEmpty())return FALSE;
	if(mMessageQueueHigh.size())someThreadMessage=mMessageQueueHigh[mMessageQueueHigh.size()-1];
	else if(mMessageQueueNormal.size())someThreadMessage=mMessageQueueNormal[mMessageQueueNormal.size()-1];
	else if(mMessageQueueLow.size())someThreadMessage=mMessageQueueLow[mMessageQueueLow.size()-1];
	else return FALSE;
	return TRUE;
}

WORD MessageQueue::isQueueEmpty(void)const
{
	WORD queueMessages;

	queueMessages=mMessageQueueHigh.size();
	queueMessages+=mMessageQueueNormal.size();
	queueMessages+=mMessageQueueLow.size();
	return (0==queueMessages);
}

void MessageQueue::shutdownQueue(void)
{
	mMutexSemaphore.requestMutex();
	mMessageQueueHigh.remove();
	mMessageQueueNormal.remove();
	mMessageQueueLow.remove();
	mQueueStatus=QueueLocked;
	mMutexSemaphore.releaseMutex();
	mNamedEvent.setEvent();
}

void MessageQueue::restartQueue(void)
{
	mMutexSemaphore.requestMutex();
	mMessageQueueHigh.remove();
	mMessageQueueNormal.remove();
	mMessageQueueLow.remove();
	mQueueStatus=QueueOpen;
	mMutexSemaphore.releaseMutex();
  mNamedEvent.setEvent();
}