// Packet.cpp: implementation of the CPacket class.
//
//////////////////////////////////////////////////////////////////////

#include "../stdafx.h"
#include "Packet.h"

#include "../LS_TTBotDlg.h"

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

CPacket::CPacket()
{
	Clear();
}

CPacket::CPacket(DWORD ID)
{
	Clear();
	*m_packet_header.m_ID = ID;
	m_currentPos = sizeof(PACKETHEADER);	
}

CPacket::CPacket(const uint8 *buffer, uint32 size) 
{
	Clear();

	if( size >= sizeof(PACKETHEADER) )
	{
		memcpy( m_pBuffer , buffer, sizeof(PACKETHEADER) );
		m_currentPos = sizeof(PACKETHEADER);
	
		if( size >= GetBufferSize() )
		{
			if( GetBufferSize() < m_currentPos )
			{
				MessageBox(NULL, "CPacket error", "error", MB_OK );
				exit(1);
				return;
			}
			memcpy( &m_pBuffer[m_currentPos], &buffer[m_currentPos], GetBufferSize() - m_currentPos );			
		}
	}
}

CPacket::~CPacket()
{

}

void CPacket::Clear()
{
	memset(m_pBuffer,0,MAX_BUFFER);
	m_currentPos = 0;
	m_packet_header.m_ID		= (DWORD*)&m_pBuffer[PK_ID_ADDR];
	m_packet_header.m_Size		= (DWORD*)&m_pBuffer[PK_SIZE_ADDR];
	m_packet_header.m_CheckSum  = (DWORD*)&m_pBuffer[PK_CKSUM_ADDR];
	m_packet_header.m_iState    = (int*)&m_pBuffer[PK_FSM_ADDR];
	*m_packet_header.m_Size = sizeof(PACKETHEADER);
}

void CPacket::SetBufferCopy(char *pBuf,int size)
{
	Clear();

	memcpy( m_pBuffer, pBuf, size );
	m_currentPos = sizeof(PACKETHEADER);
}

void CPacket::SetDataAdd(char *pBuf,int size)
{
	memcpy( &m_pBuffer[m_currentPos], pBuf, size );
	m_currentPos += size;
	*m_packet_header.m_Size = m_currentPos;
}

void CPacket::SetCheckSum( DWORD dwSum )
{
	*m_packet_header.m_CheckSum = dwSum;
}

void CPacket::SetState( int iState )
{
	*m_packet_header.m_iState = iState;
}

const uint8* CPacket::GetBuffer() const
{
	return &m_pBuffer[0];
}

const uint8* CPacket::GetData() const
{
	return &m_pBuffer[0] + sizeof(PACKETHEADER);
}

uint32 CPacket::GetBufferSize() const
{
	return *m_packet_header.m_Size;
}

uint32 CPacket::GetDataSize() const
{
	return *m_packet_header.m_Size - sizeof(PACKETHEADER);
}

DWORD CPacket::GetPacketID() const
{
	return *m_packet_header.m_ID;
}

DWORD CPacket::GetCheckSum() const
{
	return *m_packet_header.m_CheckSum;
}

int CPacket::GetState() const
{
	return *m_packet_header.m_iState;
}

bool CPacket::IsValidHeader() const
{
	return (GetBufferSize() >= sizeof(PACKETHEADER) );
}

bool CPacket::IsValidPacket() const
{
	if(!IsValidHeader()) return false;

	return (GetBufferSize() >= m_currentPos);
}

bool CPacket::CheckLeftPacketSize( int iAddSize )
{	
	if( m_currentPos + iAddSize >= MAX_BUFFER )
	{
		//LOG.PrintTimeAndLog( 0,"[ID:%d - SIZE:%d] << Packat Size Overflow!", GetPacketID(), m_currentPos + iAddSize );
		return false;
	}

	return true;
}

bool CPacket::CheckRightPacketSize( int iAddSize )
{	
	if( m_currentPos + iAddSize >= MAX_BUFFER )
	{
		//LOG.PrintTimeAndLog( 0,"[ID:%d - SIZE:%d] >> Packat Size Overflow!", GetPacketID(), m_currentPos + iAddSize );
		return false;
	}

	return true;
}