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

#include "stdafx.h"
#include "cIocpContext.h"
#include "cPacket.h"
#include "cSystem.h"
#include "cWorkerThread.h"
#include "../include/cSingleton.h"


#ifndef CONTAINING_RECORD 
#define CONTAINING_RECORD(address, type, field) \ 
((type *)((PCHAR)(address) - (ULONG_PTR)(&((type *)0)->field))) 
#endif


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

cWorkerThread::cWorkerThread() : m_packet(NULL)
{
	Init();
}

cWorkerThread::~cWorkerThread()
{
	Destroy();
}

void cWorkerThread::Init()
{
	uint32 maxPacket = cSingleton<cSystem>::GetInstance()->GetPacket();
	uint32 encoding = cSingleton<cSystem>::GetInstance()->GetEncoding();

	m_packet = new cPacket( encoding );
	m_storage.Create( maxPacket * 4 );
}

void cWorkerThread::Destroy()
{
	if(m_packet)
	{
		delete m_packet;
		m_packet = NULL;
	}
}

//////////////////////////////////////////////////////////////////////
// operation
//////////////////////////////////////////////////////////////////////

void cWorkerThread::Process()
{
	BOOL success;
	DWORD bytesTransferred;

	cSystem* system = cSingleton<cSystem>::GetInstance();

	cOverlapped*	iocpOv			= NULL;
	cIocpContext*	iocpContext		= NULL;
	LPWSAOVERLAPPED	lpOverlapped	= NULL;
	
	cIOCP* IOCP			= system->GetIOCP();
	cNetwork* network	= system->GetNetwork();

	Trace( _T("WorkerThread :: %lu\r\n"), GetCurrentThreadId() );

	while( !IsTerminated() )
	{
		iocpContext	= NULL;
		lpOverlapped	= NULL;

		success = IOCP->GetIocpStatus(	&bytesTransferred, 
											reinterpret_cast<PULONG>(&iocpContext), 
											&lpOverlapped );	
		if( !lpOverlapped )	
		{
			Trace( _T("GQCS timeout\r\n") );
			continue;
		}

		// À̺¥Æ® °Ë»ç
		iocpOv = reinterpret_cast<cOverlapped*>(lpOverlapped);
		switch( iocpOv->GetOperation() )
		{
		case E_IO_ACCEPT : // ¿©±â¼­ iocpContext´Â cServerSocket°´Ã¼ÀÓ
			{
				iocpContext = CONTAINING_RECORD( lpOverlapped, cIocpContext, m_olAccept );

				// Accept ¿äû¿Ï·á
				network->AcceptCompleted( iocpContext->GetPortID() );

				if( !success )
				{
					// Á¢¼Ó ´ë±â Áß ¿À·ù - backlogµÈ ¼ÒÄÏÀÌ Á¾·áµÆÀ»¶§
					Debug( _T("WorkerThread :: E_IO_ACCEPT failed\r\n") );

					network->Finish( iocpContext );
					continue;
				}
				
				if( !iocpContext->IsAssociated() )
				{
					// ¹Ìµî·ÏµÈ Context¸¦ IOCP¿¡ µî·Ï
					if( !IOCP->AssocInstance(	reinterpret_cast<HANDLE>(iocpContext->GetSockHandle()),
												reinterpret_cast<DWORD>(iocpContext) ) )
					{
						// Á¢¼Ó ´ë±â Áß ¿À·ù - ÀÌ¹Ì µî·ÏµÇ¾î Àְųª ±âŸ ¿À·ù½Ã
						Debug( _T("WorkerThread :: AssocInstance failed\r\n") );
						network->Finish( iocpContext );
						continue;
					}
					iocpContext->Associate();
				}

				// Á¢¼Ó¼º°ø
				iocpContext->Reset();

				// Receive ¿äû
				if( !iocpContext->ReceiveRequest() )
				{
					iocpContext->Disconnect();
				}

				OnConnect( iocpContext );

				// »õ·Î¿î Accept ¿äû
				network->AcceptReqeust( iocpContext->GetPortID() );
			}
			break;

		case E_IO_RECEIVE :
			{
				if( !success || !bytesTransferred )	
				{
					OnDisconnect( iocpContext );
					continue;
				}

				// ÆÐŶ ó¸®
				if( OnReceive( iocpContext, bytesTransferred ) )
				{
					// Receive ¿äû
					if( !iocpContext->ReceiveRequest() )
					{
						OnDisconnect( iocpContext );
					}
				}
			}
			break;

		case E_IO_SEND :
			{
				cIocpOv* sendOvl = reinterpret_cast<cIocpOv*>(lpOverlapped);
				if( iocpContext )
				{
					// Àü¼Û¹öÆÛ push
					iocpContext->SendCompleted( sendOvl );
					//Debug( _T("WorkerThread :: Sent(%lu)\r\n"), bytesTransferred );
				}
				if( !success )
				{
					Debug( _T("WorkerThread :: E_IO_SEND failed\r\n") );
				}
			}
			break;

		case E_IO_DISCONNECT :
			{
				if( success && iocpContext )
				{
					// Context¸¦ ¹ÝȯÇÏ°í »õ·Î¿î Á¢¼ÓÀ» ¿äû
					network->Finish( iocpContext );
				}
				else
				{
					Debug( _T("WorkerThread :: E_IO_DISCONNECT failed\r\n") );
				}
			}
			break;

		default :
			{
				Debug( _T("WorkerThread :: Bad operation\r\n") );
			}
			break;
		}
	}
}

BOOL cWorkerThread::OnConnect( cIocpContext* iocpContext )
{
	if( iocpContext->IsActive() )	
	{
		PushCommand( EVENT_CONNECT, iocpContext );
		return TRUE;
	}
	return FALSE;
}

BOOL cWorkerThread::OnDisconnect( cIocpContext* iocpContext )
{
	if( iocpContext->IsActive() )	
	{
		PushCommand( EVENT_CLOSE, iocpContext );
		return TRUE;
	}
	return FALSE;
}

BOOL cWorkerThread::OnReceive( cIocpContext* iocpContext, DWORD length )
{
	if( iocpContext->IsActive() )	
	{
		//Trace( _T("[%lu]OnReceive : %lu\r\n"), GetCurrentThreadId(), length );

		// ÀӽùöÆÛ¿¡ º¸°üµÈ µ¥ÀÌŸ¿Í ÇöÀç¹ÞÀº µ¥ÀÌŸ¸¦ º¹»çÇÑ´Ù
		if( iocpContext->GetStorageLength() > 0 )
		{
			m_storage.Erase();
			if( !m_storage.Copy( iocpContext->GetStorageBuffer(), iocpContext->GetStorageLength() ) )	
			{
				OnDisconnect( iocpContext );
				return FALSE;
			}
			if( !m_storage.Append( iocpContext->GetWsaBuffer(), length ) ) 
			{
				OnDisconnect( iocpContext );
				return FALSE;
			}
		}
		else
		{
			m_storage.Erase();
			if( !m_storage.Copy( iocpContext->GetWsaBuffer(), length ) ) 
			{
				OnDisconnect( iocpContext );
				return FALSE;
			}
		}

		// ÀúÀåµÈ ¹öÆÛ¸¦ ÃʱâÈ­
		iocpContext->CleanStorage();

		// ÀӽùöÆÛ¿¡ ÀúÀåµÈ ÆÐŶÀ» °Ë»çÇÏ°í ÇÁ·ÎÅäÄÝ º°·Î ³ª´©¾î¼­ command queue¿¡ push
		return CheckPacket(	iocpContext, 
							m_storage.GetBuffer(), 
							m_storage.GetLength() );
	}

	return FALSE;
}

BOOL cWorkerThread::CheckPacket( cIocpContext* iocpContext, uint8* buffer, uint32 length )
{
	//Trace( _T("[%lu]CheckPacket : %lu\r\n"), GetCurrentThreadId(), length );

	// ÆÐŶÀÇ Çì´õ±æÀÌ °Ë»ç
	if( length < sizeof(cHeader) )	
	{
		// Çì´õº¸´Ù ÀÛÀº ÆÐŶÀÌ µé¾î¿ÔÀ» °æ¿ì ÀúÀåÇÏ°í ³¡³­´Ù
		iocpContext->StoreBuffer( buffer, length );
		//Trace( _T("[%lu]very short header : %lu, total : %lu\r\n"), GetCurrentThreadId(), length, iocpContext->GetBufferLength() );
		return TRUE;
	}

	// Çì´õ·Î ÆäÀÌ·Îµå ±æÀÌ È®ÀÎ
	cHeader* header = reinterpret_cast<cHeader*>(buffer);
	Trace(_T("header : %lu, context : %lu\r\n"), header->GetSequence(), iocpContext->GetSequence());
	if( !header->IsPerfect(iocpContext->GetSequence()) )
	{
		// À߸øµÈ Çì´õ°¡ µé¾î¿ÔÀ»¶§ ÆÐŶÀ» dropÇÑ´Ù
		OnDisconnect( iocpContext );
		Debug( _T("[%lu]invalid packet : %lu\r\n"), GetCurrentThreadId() );
		return FALSE;
	}
	
	if( header->GetPayload() > (m_storage.GetMaxLength()-m_storage.GetLength()) )
	{
		Debug( _T("[%lu]too large payload : %lu\r\n"), GetCurrentThreadId(), header->GetPayload() );
		OnDisconnect( iocpContext );
		return FALSE;
	}

	// ÆÐŶ Çì´õ¿¡ µû¸¥ ±æÀÌ °Ë»ç
	uint32 packetLength = sizeof(cHeader) + header->GetPayload();
	if( length < packetLength ) // ÆÐŶ±æÀÌ°¡ Àß·Á¼­ µé¾î¿Ô´Ù
	{
		//Trace( _T("[%lu]short than payload : %lu\r\n"), GetCurrentThreadId(), packetLength );
		iocpContext->StoreBuffer( buffer, length );
		Trace( _T("[%lu]very short payload : %lu, store : %lu, total : %lu\r\n"), GetCurrentThreadId(), header->GetPayload(), length, iocpContext->GetStorageLength() );
	}
	else if( length == packetLength ) // ÆÐŶ±æÀÌ°¡ Á¤È®ÇÏ°Ô µé¾î¿Ô´Ù
	{
		Trace( _T("[%lu]good payload : %lu\r\n"), GetCurrentThreadId(), header->GetPayload() );

		// decryption ÈÄ command queue¿¡ push
		if( !PushCommand(	EVENT_RECEIVE,
							iocpContext,	
							buffer, 
							packetLength ) )
		{
			OnDisconnect( iocpContext );
			return FALSE;
		}
	}
	else if( length > packetLength )	// ÆÐŶ±æÀÌ°¡ ºÙ¾î¼­ µé¾î¿Ô´Ù
	{
		Trace( _T("[%lu]too large payload : %lu\r\n"), GetCurrentThreadId(), header->GetPayload() );

		// decryption ÈÄ command queue¿¡ push
		if( !PushCommand(	EVENT_RECEIVE,
							iocpContext, 
							buffer, 
							packetLength ) )
		{
			OnDisconnect( iocpContext );
			return FALSE;
		}
		// ´Ù½Ã Çѹø ÆÐŶ °Ë»ç
		return CheckPacket( iocpContext, buffer+packetLength, length-packetLength );
	}
	return TRUE;
}

BOOL cWorkerThread::PushCommand( EventID eventId, cIocpContext* iocpContext, uint8* buffer, uint32 length )
{
	cSystem* system = cSingleton<cSystem>::GetInstance();

	cCommandQueue* commandQueue = system->GetCommandQueue();
	if( !commandQueue ) return TRUE;

	switch( eventId )
	{
	case EVENT_CONNECT :
		{
			commandQueue->PushCommand( iocpContext, system->GetConnectEvent() );
		}
		break;

	case EVENT_CLOSE :
		{
			commandQueue->PushCommand( iocpContext, system->GetDisconnectEvent() );
		}
		break;

	case EVENT_RECEIVE :
		{
			if( length == 0 )
			{
				// µðÄÚµù ½ÇÆÐ
				OnDisconnect( iocpContext );
				return FALSE;
			}

			// ½ÃÄö½º Ãß°¡
			iocpContext->PopSequence();

			//// ÆÐŶÀÇ À¯È¿¼º °Ë»ç
			cHeader* header = reinterpret_cast<cHeader*>(buffer);
			//if( !header->IsPerfect(iocpContext->GetSequence()) )
			//{
			//	OnDisconnect( iocpContext );
			//	return FALSE;
			//}

			uint8* packet	= buffer + sizeof(cHeader);
			uint32 payload	= length - sizeof(cHeader);

			// ÆÐŶ µðÄÚµù
			uint32 result = 0;
			if(TRUE == m_packet->Decode(
				packet,
				length - sizeof(cHeader),
				header->GetSequence(),
				result))
			{
				commandQueue->PushCommand(		
					iocpContext,
					header->GetCommand(),
					m_packet->GetOutput(),
					result );
			}
			else
			{
				commandQueue->PushCommand(		
					iocpContext,
					header->GetCommand(),
					packet,
					static_cast<uint16>(payload) );
			}
		}
		break;
	}
	return TRUE;
}