// WMsgFrame.cpp: implementation of the CWMsgPacket class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
//tts #include "WSMModule.h"
#include "WMsgPacket.h"
#include "ByteHexStrConvert.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

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

CWMsgPacket::CWMsgPacket()
{
	Reset();
}

CWMsgPacket::~CWMsgPacket()
{

}

BOOL CWMsgPacket::SetPhoneNumberBegin(BYTE toSet)
{
	BOOL bResult = toSet == PHONE_NUMBER_BEGIN;
	m_numberDigitReceived = 0;
	return bResult;
}

BOOL CWMsgPacket::SetPhoneNumberDigit(BYTE toSet)
{
	BOOL bResult = IsValidPhoneNumberDigit(toSet);
	
	if(bResult) 
		m_szPhoneNumber[m_numberDigitReceived++] = toSet;

	return bResult;
}

BOOL CWMsgPacket::SetPhoneNumberEnd(BYTE toSet)
{
	BOOL bResult = toSet == PHONE_NUMBER_END;
	
	if (bResult)
	{
		m_szPhoneNumber[m_numberDigitReceived] = '\0';
		
		// remove +86
		CString strTmp(m_szPhoneNumber);
		strTmp.Replace("+86", "");
		strcpy(m_szPhoneNumber, strTmp);
		m_numberDigitReceived = strTmp.GetLength();
	}

	return bResult;
}

void CWMsgPacket::AppendPacketByte(BYTE byData)
{
	ASSERT(m_dataReceived < MAX_SHORT_MSG_LEN);
	m_msgFrameData[m_dataReceived++] = byData;
}

BOOL CWMsgPacket::SetFrameBegin(BYTE toSet)
{
	BOOL bResult = toSet == FRAME_BEGIN_ID;
	if (bResult) AppendPacketByte(toSet);

	return bResult;
}

BOOL CWMsgPacket::SetFrameNo(BYTE toSet)
{
	BOOL bResult = IsValidFrameNo(toSet);
	if(bResult) AppendPacketByte(toSet);

	return bResult;
}

BOOL CWMsgPacket::SetPacketNo(BYTE toSet)
{
	BOOL bResult = IsValidPacketNo(toSet);
	if(bResult) AppendPacketByte(toSet);
	
	return bResult;
}

BOOL CWMsgPacket::SetLastPacketFlag(BYTE toSet)
{
	BOOL bResult = toSet == LAST_PACKET_ID;
	if(bResult)
	{
		m_bLastPacket = TRUE;
		AppendPacketByte(toSet);
	}

	return bResult;
}

BOOL CWMsgPacket::IsValidMsgType(BYTE byType)
{
	switch(byType)
	{
	case DASHI_MSG:
	case DIAODU_MSG_NEED_ANSWER:
	case DIAODU_MSG_NEEDNOT_ANSWER :
	case ANSWER_FRAME_MSG :
	case SEND_PACKET_AGAIN_MSG :
	case SEND_FRAME_AGAIN_MSG :
		return TRUE;
	default :
		return FALSE;
	}
}

BOOL CWMsgPacket::SetMessageType(BYTE toSet)
{
	BOOL bResult = IsValidMsgType(toSet);
	if(bResult) AppendPacketByte(toSet);
	
	return bResult;
}


BOOL CWMsgPacket::IsValidTextOrCheckSumByte(BYTE byData)
{
	return isxdigit(byData); 
}

BOOL CWMsgPacket::IsValidPhoneNumberDigit(BYTE byDigit)
{
	return isdigit(byDigit) || byDigit == '+';		// +86---
}

BOOL CWMsgPacket::AppendMsgTextOrCheckSum(BYTE toSet)
{
	BOOL bResult = IsValidTextOrCheckSumByte(toSet);
	if(bResult) AppendPacketByte(toSet);

	return bResult;
}

BOOL CWMsgPacket::SetFrameEnd(BYTE toSet)
{
	BOOL bResult = toSet == FRAME_END_ID;
	if(bResult) AppendPacketByte(toSet);

	return bResult;
}

BOOL CWMsgPacket::CheckCheckSum()
{
	int nBytes = m_dataReceived - 3;		// 2 check sum + 1 end char
	BYTE currSum = CalculateSum(nBytes);

	LPBYTE lpCheckSum = m_msgFrameData + nBytes;
	
	BYTE checkSum;
	HexStrLenToByte((const char*)lpCheckSum, 2, &checkSum);

	return (BYTE)(checkSum + currSum) == 0;

}

void CWMsgPacket::Reset()
{
	m_dataReceived = 0;
	m_numberDigitReceived = 0;
	m_bLastPacket = FALSE;
}

void CWMsgPacket::GenerateMsgPacket(LPCSTR lpszPhoneNumber, BYTE msgType, BYTE frameNo, BYTE packetNo, 
									const BYTE* lpBinData, DWORD dwDataSize, BOOL bLastPacket)
{
	
	// set phone number
	strcpy(m_szPhoneNumber, lpszPhoneNumber);
	m_numberDigitReceived = strlen(m_szPhoneNumber);

	VERIFY(SetFrameBegin(FRAME_BEGIN_ID));
	VERIFY(SetFrameNo(frameNo));
	if(bLastPacket) VERIFY(SetLastPacketFlag(LAST_PACKET_ID));
	VERIFY(SetPacketNo(packetNo));
	VERIFY(SetMessageType((BYTE)msgType));

	// convert and get text
	ConvertAndAppend(lpBinData, dwDataSize);
	AppendCheckSum();

	SetFrameEnd(FRAME_END_ID);
	
}

void CWMsgPacket::ConvertAndAppend(const BYTE* lpBinData, int binDataSize)
{
	BYTE* pDest = m_msgFrameData + m_dataReceived;
	m_dataReceived += ByteToHexStr(lpBinData, binDataSize, (char*)pDest);
}

void CWMsgPacket::AppendCheckSum()
{
	BYTE currSum = CalculateSum(m_dataReceived);
	BYTE sumNeed = 0 - currSum;

	ConvertAndAppend(&sumNeed, 1);
}

BYTE CWMsgPacket::PacketIndex2PacketNo(int idx)
{
	ASSERT(idx < MAX_PACKETS_PER_FRAME);
	return idx + MIN_PACKET_NO;
}

int  CWMsgPacket::PacketNo2PacketIndex(BYTE byNo)
{
	ASSERT(byNo <= MAX_PACKET_NO);
	return byNo - MIN_PACKET_NO;
}


BYTE CWMsgPacket::CalculateSum(int nBytes) const
{
	BYTE byteRes = 0;

	const BYTE* pStart = (const BYTE*)m_msgFrameData;
	const BYTE* pEnd = pStart + nBytes - 1;

	for( const BYTE* pData = pStart; pData <= pEnd; pData++)
		byteRes += *pData;

	return byteRes;
}

const BYTE* CWMsgPacket::GetDataAndSize(int& dataSize) const
{
	dataSize = m_dataReceived;
	return m_msgFrameData;
}

LPCSTR CWMsgPacket::GetPhoneNumber() const
{
	return m_szPhoneNumber;
}

BYTE CWMsgPacket::GetMessageType() const
{
	int idxMsgType = 3;
	if(m_bLastPacket) idxMsgType ++;

	return m_msgFrameData[idxMsgType];
}

int  CWMsgPacket::GetMsgBinaryData(LPBYTE lpDest) const
{
	// get position of first byte

	int idxFirstData = 4;
	if(m_bLastPacket) idxFirstData ++;
	const char* pDataBegin = (const char*)m_msgFrameData + idxFirstData;

	// get data size
	int idxLastData = m_dataReceived - 1;		// position of end flag
	idxLastData -= 3;							// 2 check sum + 1 end flag
	int nDataSize = idxLastData - idxFirstData + 1;
	ASSERT(nDataSize >= 0);

	return HexStrLenToByte(pDataBegin, nDataSize, lpDest);
}

BYTE CWMsgPacket::GetFrameNo() const
{
	int idxFrameNo = 1;
	return m_msgFrameData[idxFrameNo];
}

BYTE CWMsgPacket::GetPacketNo() const
{
	int idxPacketNo = 2;
	if(m_bLastPacket) idxPacketNo++;

	return m_msgFrameData[idxPacketNo];
}

BOOL CWMsgPacket::IsLastPacket() const
{
	return m_bLastPacket;
}

BOOL   CWMsgPacket::IsValidPacketNo(BYTE byNo)
{
	return byNo >= MIN_PACKET_NO && byNo <= MAX_PACKET_NO;
}

BOOL   CWMsgPacket::IsValidFrameNo(BYTE byNo)
{
	return byNo >= MIN_FRAME_NO && byNo <= MAX_FRAME_NO;
}