#include <nntp/nntpthrd.hpp>

typedef struct tagSERVERINFO
{
  String mServerName;
	String mUserName;
	String mPassword;  
}SERVERINFO;

NNTPThread::NNTPThread(void)
: mIsBlocking(FALSE)
{
  mThreadHandler.setCallback(this,&NNTPThread::threadHandler);
  mEventHandlers.size((MsgPostOpen-MsgPreOpen)+1);
  MessageThread::insertHandler(&mThreadHandler);
}

NNTPThread::NNTPThread(const NNTPThread &someNNTPThread)
{ // private implementation
  mThreadHandler.setCallback(this,&NNTPThread::threadHandler);
  MessageThread::insertHandler(&mThreadHandler);
}

NNTPThread::~NNTPThread()
{
  if(isBlocking())fatalThreadExit();
	else stop();
	MessageThread::removeHandler(&mThreadHandler);
}

WORD NNTPThread::open(const String &serverName)
{
  SERVERINFO *pServerInfo=new SERVERINFO;

	pServerInfo->mServerName=serverName;
  ThreadMessage openMessage(ThreadMessage::TM_USER,MsgOpen,(LONG)pServerInfo);
	return postMessage(openMessage);
}

WORD NNTPThread::open(const String &serverName,const String &userName,const String &password)
{
  SERVERINFO *pServerInfo=new SERVERINFO;

	pServerInfo->mServerName=serverName;
	pServerInfo->mUserName=userName;
	pServerInfo->mPassword=password;
  ThreadMessage openMessage(ThreadMessage::TM_USER,MsgOpen,(LONG)pServerInfo);
	return postMessage(openMessage);
}

void NNTPThread::insertHandler(ThreadCallbackPointer pThreadCallback,HandlerType typeHandler)
{
  mEventHandlers[typeHandler]=ThreadCallbackPointer(pThreadCallback);
}

void NNTPThread::removeHandler(HandlerType typeHandler)
{
  mEventHandlers[typeHandler]=ThreadCallbackPointer();
}

DWORD NNTPThread::callHandler(ThreadMessage &someThreadMessage,HandlerType typeHandler)
{
  return mEventHandlers[typeHandler].callback(someThreadMessage);
}

DWORD NNTPThread::threadHandler(ThreadMessage &someThreadMessage)
{
	switch(someThreadMessage.message())
	{
	 case ThreadMessage::TM_CREATE :
		 break;
	 case ThreadMessage::TM_DESTROY :
		 break;
	 case ThreadMessage::TM_USER :
     if(MsgOpen==someThreadMessage.userDataOne())
		 {
		   SERVERINFO *pServerInfo=(SERVERINFO*)someThreadMessage.userDataTwo();
			 String serverName(pServerInfo->mServerName);
			 String userName(pServerInfo->mUserName);
			 String password(pServerInfo->mPassword);
			 ::delete pServerInfo;
       handleOpen(serverName,userName,password);
		 }
	   break;
	}
	return FALSE;
}

void NNTPThread::handleOpen(const String &serverName,const String &userName,const String &password)
{
  ThreadMessage openMessage;
	int currentPriority;

	currentPriority=::GetThreadPriority(::GetCurrentThread());
  ::SetThreadPriority(::GetCurrentThread(),THREAD_PRIORITY_ABOVE_NORMAL); 
	if(callHandler(openMessage,MsgPreOpen))return;
	isBlocking(TRUE);
  if(!userName.isNull()&&!password.isNull())NNTPClient::open(serverName,userName,password);
	else NNTPClient::open(serverName);
	openMessage.userDataOne(isConnected());
	::SetThreadPriority(::GetCurrentThread(),currentPriority);
	callHandler(openMessage,MsgOpen);
	callHandler(openMessage,MsgPostOpen);
	isBlocking(FALSE);
}