#ifndef _THREAD_MESSAGETHREAD_HPP_
#define _THREAD_MESSAGETHREAD_HPP_
#ifndef _COMMON_BLOCK_HPP_
#include <common/block.hpp>
#endif
#ifndef _THREAD_QUEUETHREAD_HPP_
#include <thread/qthread.hpp>
#endif
#ifndef _THREAD_MESSAGEQUEUE_HPP_
#include <thread/msgqueue.hpp>
#endif
#ifndef _THREAD_THREADCALLBACK_HPP_
#include <thread/tcallbck.hpp>
#endif

class MessageThread : protected QueueThread
{
public:
	MessageThread(bool startup=true);
	virtual ~MessageThread();
	WORD postMessage(ThreadMessage &someThreadMessage);
  WORD sendMessage(ThreadMessage &someThreadMessage);
	WORD peekMessage(ThreadMessage &someThreadMessage);
	WORD messageCount(void);
	DWORD suspend(void);
  DWORD resume(void);
	DWORD wait(DWORD timeout=INFINITE,bool alertable=false)const;
  void stop(void);
	void isAlertable(WORD isAlertable);
	WORD insertHandler(PureThreadCallback *lpThreadCallback);
 	void removeHandler(PureThreadCallback *lpThreadCallback);
protected:
	void startup(void);
  void shutdown(void);
	void messageLoop(void);
private:
	WORD getMessage(ThreadMessage &someThreadMessage);
	void dispatchMessage(ThreadMessage &someThreadMessage);
	void removeHandlers(void);

	MessageQueue mMessageQueue;
	Mutex mMessageThreadMutex;
	Block<ThreadCallbackPointer> mThreadCallback;
};

inline
WORD MessageThread::postMessage(ThreadMessage &someThreadMessage)
{
  someThreadMessage.messageTime().refresh();
	mMessageQueue.postMessage(someThreadMessage);
  return TRUE;
}

inline
WORD MessageThread::sendMessage(ThreadMessage &someThreadMessage)
{
  someThreadMessage.messageTime().refresh();
  someThreadMessage.priority(ThreadMessage::PriorityHigh);
	postMessage(someThreadMessage);
	::SleepEx(0,FALSE);    // give up remainder of quantum so message can be processed
	return TRUE;
}

inline
WORD MessageThread::getMessage(ThreadMessage &someThreadMessage)
{
  return mMessageQueue.waitMessage(someThreadMessage);
}

inline
WORD MessageThread::peekMessage(ThreadMessage &someThreadMessage)
{
  return mMessageQueue.peekMessage(someThreadMessage);
}

inline
WORD MessageThread::messageCount(void)
{
  return mMessageQueue.itemsInQueue();
}

inline
DWORD MessageThread::suspend(void)
{
  return QueueThread::suspend();
}

inline
DWORD MessageThread::resume(void)
{
  return QueueThread::resume();
}

inline
DWORD MessageThread::wait(DWORD timeout,bool alertable)const
{
  return QueueThread::wait(timeout,alertable);
}

inline
void MessageThread::isAlertable(WORD isAlertable)
{
  mMessageQueue.isAlertable(isAlertable);  
}
#endif