#include "stdafx.h"
#include "CSM315Protocol.h"
#include <AlarmDefine.h>
//#include "MonitorObject.h"

int	CCSM315Protocol::m_CSMCmdRegion_DataVersion = 1;

CCSM315Protocol::CCSM315Protocol(int nDataVersion/*CLinkAdmin* pLinkAdmin, const char* strLogName*/)// :CLogEvent(strLogName)
{

	m_CSMCmdRegion_DataVersion = nDataVersion;
}

CCSM315Protocol::~CCSM315Protocol()
{
	//DeleteCriticalSection(&m_LOGMutex);

}

//心跳包 时间4B+0xFF+0xFF+0xFF
BOOL CCSM315Protocol::Parse(StHeartBeat315& data, LPVOID buf, int len)
{
	ZeroMemory(&data, sizeof(data));

	if (len != 4 + 3)
		return FALSE;

	memcpy_s(&data, 4 + 3, buf, 4 + 3);

	return TRUE;
}

//buf:缓冲区   size:缓冲区大小   len:取出的数据长度
BOOL CCSM315Protocol::GetFrameData(LPBYTE& buf, int& size, int& len)
{
	int nMinLen = 5 + 1 + 1 + 1 + 4 + 4;

	if (buf == NULL || size < nMinLen)
		return FALSE;

	LPBYTE pos = (LPBYTE)buf;

	int cnt = size;
	while (cnt > 0)
	{
		if (*pos == 'q')
		{
			if (cnt >= nMinLen
				&& memcmp(pos, FRAME_HEADER_315, 5) == 0)
			{
				break;
			}
		}

		++pos;
		--cnt;
	}

	if (cnt < nMinLen)
		return FALSE;

	int datalen = *(int*)(pos + 5 + 1 + 1 + 1);
	if (datalen == 0)
	{
		//TRACE("报文长度为0\n");
		datalen = size - nMinLen;
	}
	if (datalen < 0 || cnt < nMinLen + datalen)
		return FALSE;

	DWORD tail = *(DWORD*)(pos + 5 + 1 + 1 + 1 + 4 + datalen);
	if (tail != FRAME_TAIL_315)
		return FALSE;

	buf = pos;
	size = cnt;
	len = nMinLen + datalen;

	return TRUE;
}


void CCSM315Protocol::InitFrmHead12B(BYTE* pBuf, BYTE frmtype, BYTE datVer)
{
	int ipos = 0;
	char head[5] = { 'q','k','n','e','t' };
	memcpy(pBuf + ipos, head, 5);
	ipos += 5;

	datVer = m_CSMCmdRegion_DataVersion;

	*(BYTE*)(pBuf + ipos) = PROTOCAL_CODE;
	ipos += 1;
	*(BYTE*)(pBuf + ipos) = datVer;
	ipos += 1;
	*(BYTE*)(pBuf + ipos) = frmtype;  //0x0F 表示心跳帧  0x8F 表示数据帧
	ipos += 1;

	*(DWORD*)(pBuf + ipos) = 0;
	ipos += 4;
}

void CCSM315Protocol::InitFrmHead12B(CPTL_HEAD* pHead, BYTE frmtype, BYTE datVer)
{
	char head[5] = { 'q','k','n','e','t' };
	memcpy(&pHead->sHead, head, 5);
	pHead->byDataVersion = m_CSMCmdRegion_DataVersion;
	pHead->byProtocolCode = PROTOCAL_CODE;
	pHead->byFrameType = frmtype;
	pHead->dwFrameLen = 0;
}

void CCSM315Protocol::InitFrmHead12B(C315CommData& CommData, BYTE frmtype, BYTE datVer)
{
	CPTL_HEAD pHead;
	InitFrmHead12B(&pHead, frmtype, datVer);
	CommData.Push_Data(&pHead, sizeof(pHead));
}


E_315_PROTOCOL_TYPE  CCSM315Protocol::GetProtocolType(BYTE* pBuf, WORD wDataSize)
{
	if (wDataSize < 8) return E_315_PROTOCOL_TYPE(0xFF);	//无效数据

	BYTE frmtype = *(pBuf + 7);
	if(frmtype == 0x0f) return E_315_PROTOCOL_TYPE(0);		//心跳包

	if (wDataSize < 13) return E_315_PROTOCOL_TYPE(0xFF);	//无效数据

	BYTE cmd = *(pBuf + 12);

	return E_315_PROTOCOL_TYPE(cmd);						//普通包
}

BOOL CCSM315Protocol::IsReceiptProtocol(E_315_PROTOCOL_TYPE protocol)
{
	return /*protocol == E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x42
		|| */protocol == E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x52
// 		|| protocol == E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x62
// 		|| protocol == E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x44
		|| protocol == E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x54
// 		|| protocol == E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x64
// 		|| protocol == E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x48
		|| protocol == E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x58
		/*|| protocol == E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x68*/;
}

BOOL CCSM315Protocol::GetResendProtocol(E_315_PROTOCOL_TYPE e, int& nReSendCount, int& nReSendInterval)
{
	nReSendCount = 0;
	nReSendInterval = 0;
	switch (e)
	{
// 		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x41:		//全行程最新值	 		
		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x51:		//受力最新值	 		
// 		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x61:		//框架最新值	 		
		{
			nReSendCount = 0;
			nReSendInterval = 0;  //实时数据不用重发
		}
		break;
// 		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x43:		//全行程预报警信息	 		
		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x53:		//受力预报警信息	 		
// 		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x63:		//框架预报警信息	 		
		{
			nReSendCount = 3;
			nReSendInterval = 5;
		}
		break;
// 		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x47:		//查询曲线数据	 		
		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x57:		//查询曲线数据	 		
// 		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x67:		//查询曲线数据	 		
		{
			nReSendCount = 3;
			nReSendInterval = 5;
		}
		break;
		default:
			break;
	}

	return FALSE;
}



BOOL CCSM315Protocol::RecvParse(StCurveCfgRes& data, LPVOID buf, int len, FRAME_KIND& e)
{
	ZeroMemory(&data, sizeof(data));

	int szcnt = 0;
	LPBYTE pos = (LPBYTE)buf;
	BOOL failed = FALSE;

	data.cmdid = *pos;
	//判断包的类型 命令包还是应答包
	if (!(/*data.cmdid == (uint8_t)E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x46
		|| */data.cmdid == (uint8_t)E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x56
		/*|| data.cmdid == (uint8_t)E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x66*/))
	{
		return FALSE;
	}

	//应答包：帧头5B + 协议码1B + 数据版本1B + 帧类型1B + 帧内容长度4B + 命令码1B（0x23） + 总配置数(2B) + {转辙机配置i} + 帧尾4B
	//转辙机配置i:......
	size_t sz;
	{
		sz = 1 + 10;
		szcnt += sz;
		if (szcnt > len)
			return FALSE;
		memcpy_s(&data, sz, pos, sz);
		pos += sz;

		if (sizeof(StTractionCfg) * data.cnt == len - sz)
		{
			sz = sizeof(StTractionCfg) * data.cnt;
			StTractionCfg* lpcfg = new StTractionCfg[data.cnt];
			memcpy_s(lpcfg, sz, pos, sz);

			data.lpcfg = lpcfg;

			e = FRAME_KIND::RECV;
		}
		else
		{
			e = FRAME_KIND::SEND;

			sz = sizeof(StTractionCfg1) * data.cnt;
			
			StTractionCfg1* lpcfg = new StTractionCfg1[data.cnt];
			//memcpy_s(lpcfg, sz, pos, sz);
			ZeroMemory(lpcfg, sz);

			for (int i = 0; i < data.cnt; ++i)
			{
				StTractionCfg1& cfg = lpcfg[i];
				memcpy_s(&cfg, sizeof(StTractionCfg1), pos, sizeof(StTractionCfg1));
				szcnt += sizeof(StTractionCfg1);

				if (szcnt > len)
				{
					failed = TRUE;
					break;
				}
				pos += sizeof(StTractionCfg1);

				if (cfg.cnt != 0)
				{
					sz = sizeof(StTractionCfg11) * cfg.cnt;

					StTractionCfg11* lpcfg1 = new StTractionCfg11[cfg.cnt];

					szcnt += sz;
					if (szcnt > len)
					{
						failed = TRUE;
						break;
					}
					
					memcpy_s(lpcfg1, sz, pos, sz);
					pos += sz;

					cfg.lpcrecord = lpcfg1;
				}
			}//for

			data.lpcfg = lpcfg;

		}
	}

	if (failed || pos != (LPBYTE)buf + len)
	{
		CCSM315Protocol::Release(data, e);
		return FALSE;
	}

	return TRUE;
}

//道岔缺口配置信息 buf指向数据内容部分 len数据内容的长度
BOOL CCSM315Protocol::RecvParse(StGapCfgRes& data, LPVOID buf, int len)
{
	ZeroMemory(&data, sizeof(data));

	int szcnt = 0;
	LPBYTE pos = (LPBYTE)buf;
	BOOL failed = FALSE;

	data.cmdid = *pos;
	//判断包的类型 命令包还是应答包
	if (1 == len && (*pos == (uint8_t)E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x23))
	{
		pos += 1;
		return TRUE;
	}

	//应答包：帧头5B + 协议码1B + 数据版本1B + 帧类型1B + 帧内容长度4B + 命令码1B（0x23） + 总配置数(2B) + {转辙机配置i} + 帧尾4B
	//转辙机配置i:......
	size_t sz;
	{
		sz = 1 + 2;
		szcnt += sz;
		if (szcnt > len)
			return FALSE;
		memcpy_s(&data, sz, pos, sz);
		pos += sz;

		if (data.cfgcnt > len)
			return FALSE;

		if (data.cfgcnt != 0)
		{
			sz = sizeof(StSwitchCfg) * data.cfgcnt;
			StSwitchCfg* lpcfg = new StSwitchCfg[data.cfgcnt];
			ZeroMemory(lpcfg, sz);

			for (int i = 0; i < data.cfgcnt; ++i)
			{
				StSwitchCfg& cfg = lpcfg[i];

				sz = 1;
				szcnt += sz;
				if (szcnt > len)
				{
					failed = TRUE;
					break;
				}
				memcpy_s(&cfg.nlen, sz, pos, sz);
				pos += sz;

				if (cfg.nlen != 0)
				{
					sz = cfg.nlen;
					szcnt += sz;
					if (szcnt > len)
					{
						failed = TRUE;
						break;
					}
					cfg.lpname = new CHAR[sz];
					memcpy_s(cfg.lpname, sz, pos, sz);
					pos += sz;
				}

				sz = 1;
				szcnt += sz;
				if (szcnt > len)
				{
					failed = TRUE;
					break;
				}
				memcpy_s(&cfg.stype, sz, pos, sz);
				pos += sz;

				sz = 2;
				szcnt += sz;
				if (szcnt > len)
				{
					failed = TRUE;
					break;
				}
				memcpy_s(&cfg.sid, sz, pos, sz);
				pos += sz;

				sz = 2;
				szcnt += sz;
				if (szcnt > len)
				{
					failed = TRUE;
					break;
				}
				memcpy_s(&cfg.cnt, sz, pos, sz);
				pos += sz;

				if (cfg.cnt != 0)
				{
					sz = 2 * cfg.cnt;
					szcnt += sz;
					if (szcnt > len)
					{
						failed = TRUE;
						break;
					}
					cfg.lpinfo = new WORD[cfg.cnt];
					memcpy_s(cfg.lpinfo, sz, pos, sz);
					pos += sz;
				}
			}//for

			data.lpcfg = lpcfg;
		}
	}

	if (failed || pos != (LPBYTE)buf + len)
	{
		CCSM315Protocol::Release(data);
		return FALSE;
	}

	return TRUE;
}


BOOL CCSM315Protocol::Release(StGapCfgRes& data)
{
	if (data.cfgcnt == 0 || data.lpcfg == NULL)
		return TRUE;

	if (data.cmdid == (uint8_t)E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x23)
	{
		for (int i = 0; i < data.cfgcnt; ++i)
		{
			StSwitchCfg& cfg = ((StSwitchCfg*)data.lpcfg)[i];

			if (cfg.nlen && cfg.lpname)
				delete[] cfg.lpname;

			if (cfg.cnt && cfg.lpinfo)
				delete[] cfg.lpinfo;
		}
	}

	delete[] data.lpcfg;
	data.lpcfg = NULL;

	return TRUE;
}


BOOL CCSM315Protocol::Release(StCurveCfgRes& data, FRAME_KIND &e)
{
	if (data.lpcfg == 0 || data.lpcfg == NULL)
		return TRUE;

	if (e == FRAME_KIND::SEND)
	{
		StTractionCfg1* plpcfg = (StTractionCfg1*)data.lpcfg;
		for (int i = 0; i < data.cnt; i++)
		{
			delete[] plpcfg[i].lpcrecord;
			plpcfg[i].lpcrecord = NULL;
		}
	}

	delete[] data.lpcfg;
	data.lpcfg = NULL;

	return TRUE;
}


std::string CCSM315Protocol::GetStrFromData(const BYTE* buf, int dwLen)
{
	int dwLoop;
	std::string strReturn = "";

	char tmpch[4] = { 0 };

	BYTE bval = 0;
	for (dwLoop = 0; dwLoop < dwLen; dwLoop++)
	{
		bval = *(buf + dwLoop);
		if (dwLoop == 0)
		{
			sprintf_s(tmpch, sizeof(tmpch), "%02X ", bval);
			strReturn += tmpch;
		}
		else
		{
			sprintf_s(tmpch, sizeof(tmpch), "%02X ", bval);
			strReturn += tmpch;
		}
	}

	return strReturn;
}

//E_315_PROTOCOL_0x53
BOOL CCSM315Protocol::DataSerialize(BYTE byProtocalCMD, bool bPush, int no, const std::vector<stAlarmItem>& vctAlarm, C315CommData& CommData)
{
	//开始组装，清空数据
	CommData.Clear_Data();
	//插入帧头
	InitFrmHead12B(CommData, FRAME_TYPE_DATA, PROTOCAL_CODE);

	CommData.Push_Data(byProtocalCMD);
	CommData.Push_Data((BYTE)(bPush ? 0 : 1));
	CommData.Push_Data((BYTE)(no));
	auto size = (WORD)vctAlarm.size();
	CommData.Push_Data(size);
	CommData.Push_Data(vctAlarm.data(), size * sizeof(stAlarmItem));
	
	//插入帧尾
	CommData.Push_Tail();

	//组装结束，更新帧长度
	CommData.Update_FrameLen();

	return TRUE;
}

//曲线列表 E_315_PROTOCOL_0x56
BOOL CCSM315Protocol::DataSerialize(BYTE byProtocalCMD, const std::map<WORD, std::vector<DWORD>>& mapData, C315CommData& CommData)
{
	//开始组装，清空数据
	CommData.Clear_Data();
	//插入帧头
	InitFrmHead12B(CommData, FRAME_TYPE_DATA, PROTOCAL_CODE);

	CommData.Push_Data(byProtocalCMD);
	auto size = (WORD)mapData.size();
	CommData.Push_Data(size);
	for (auto &it : mapData)
	{
		CommData.Push_Data(it.first);
		auto len = (WORD)it.second.size();
		CommData.Push_Data(len);
		CommData.Push_Data(it.second.data(), len * sizeof(DWORD));
	}

	//插入帧尾
	CommData.Push_Tail();

	//组装结束，更新帧长度
	CommData.Update_FrameLen();

	return TRUE;
}

//E_315_PROTOCOL_0x50
BOOL CCSM315Protocol::DataSerialize(BYTE byProtocalCMD, const std::vector<NodeConfig>& vecConfig, C315CommData& CommData)
{
	//开始组装，清空数据
	CommData.Clear_Data();
	//插入帧头
	InitFrmHead12B(CommData, FRAME_TYPE_DATA, PROTOCAL_CODE);

	CommData.Push_Data(byProtocalCMD);
	auto size = (WORD)vecConfig.size();
	CommData.Push_Data(size);
	for (WORD i = 0; i < size; i++)
	{
		auto namelen = (BYTE)vecConfig[i].strNodeName.GetLength();
		CommData.Push_Data(namelen);
		CommData.Push_Data((LPBYTE)(LPCSTR)vecConfig[i].strNodeName, namelen);
		CommData.Push_Data(vecConfig[i].wNodeID);
		auto count = (BYTE)vecConfig[i].vecAcqTypeID.size();
		CommData.Push_Data(count);
		CommData.Push_Data((LPBYTE)vecConfig[i].vecAcqTypeID.data(), vecConfig[i].vecAcqTypeID.size() * sizeof(WORD));
	}
	//插入帧尾
	CommData.Push_Tail();

	//组装结束，更新帧长度
	CommData.Update_FrameLen();

	return TRUE;
}

//E_315_PROTOCOL_0x51
BOOL CCSM315Protocol::DataSerialize(BYTE byProtocalCMD, bool bPush, 
	WORD wIdx, BYTE byFixOrNot, const std::vector<WORD>& vctAcqType,
	const std::vector<TIEDA_ACQ_VALUE>& vctData, const std::vector<BYTE>& vctStatus,
	const CTime& atime, C315CommData& CommData)
{
	//开始组装，清空数据
	CommData.Clear_Data();
	//插入帧头
	InitFrmHead12B(CommData, FRAME_TYPE_DATA, PROTOCAL_CODE);

	CommData.Push_Data(byProtocalCMD);
	CommData.Push_Data((BYTE)(bPush ? 0 : 1));
	CommData.Push_Data((WORD)(1));
	CommData.Push_Data((DWORD)atime.GetTime());
	CommData.Push_Data(wIdx);
	CommData.Push_Data(byFixOrNot);
	auto size = (BYTE)vctAcqType.size();
	CommData.Push_Data(size);
	for (int i = 0; i < size; i++)
	{
		WORD wAcqTypeID = vctAcqType[i];
		CommData.Push_Data(wAcqTypeID);
		CommData.Push_Data(vctStatus[i]);
		//switch ((AcqTypeCode)wAcqTypeID)
		//{
		//case AcqTypeCode::eAcqTypeCode_0x101:
		//case AcqTypeCode::eAcqTypeCode_0x102:
		//case AcqTypeCode::eAcqTypeCode_0x103:
		//	break;
		//case AcqTypeCode::eAcqTypeCode_0x104:
		//case AcqTypeCode::eAcqTypeCode_0x105:
		//	break;
		//default:
		//	break;
		//}
		CommData.Push_Data(&vctData[i], 3);
	}
	//插入帧尾
	CommData.Push_Tail();
	//组装结束，更新帧长度
	CommData.Update_FrameLen();

	return TRUE;

}

////E_315_PROTOCOL_0x57
//BOOL CCSM315Protocol::DataSerialize(BYTE byProtocalCMD, BYTE byFixOrNot, bool bPush, int no, WORD wEqpNO, int num,
//	const MapTimeIntItor& map00, const MapTimeIntItor& map01,
//	const MapTimeIntItor& map10, const MapTimeIntItor& map11,
//	const MapTimeIntItor& map20, const MapTimeIntItor& map21,
//	time_t time, C315CommData& CommData)
//{
//	//开始组装，清空数据
//	CommData.Clear_Data();
//	CommData.Reserve(4096);
//	//插入帧头
//	InitFrmHead12B(CommData, FRAME_TYPE_DATA, PROTOCAL_CODE);
//	DWORD atime = time;
//
//	CommData.Push_Data(byProtocalCMD);
//	CommData.Push_Data((BYTE)(bPush ? 0 : 1));
//	CommData.Push_Data((BYTE)no);
//	CommData.Push_Data(wEqpNO);
//	CommData.Push_Data(atime);
//	CommData.Push_Data((BYTE)3);
//
//	CommData.Push_Data((WORD)CurveTypeCode::eCurveTypeCode_0x1010);
//	CommData.Push_Data(byFixOrNot);
//	CommData.Push_Data((WORD)0);//偏移量
//	CommData.Push_Data((WORD)50);
//	DWORD n = 0;
//	for (auto i = map00; i != map01; i++) n++;
//	CommData.Push_Data(n);//数据点数
//	for (auto i = map00; i != map01; i++)
//	{
//		//CommData.Push_Data(&i->second, 3); //TODO
//		CommData.Push_Data(&TIEDA_ACQ_VALUE(i->second, TIEDA_VAL_STATE::TVS_MOVEING), 3);
//	}
//
//	CommData.Push_Data((WORD)CurveTypeCode::eCurveTypeCode_0x1020);
//	CommData.Push_Data(byFixOrNot);
//	CommData.Push_Data((WORD)0);//偏移量
//	CommData.Push_Data((WORD)50);
//	CommData.Push_Data(n);
//	for (auto i = map10; i != map11; i++)
//	{
//		//CommData.Push_Data(&i->second, 3);//TODO
//		CommData.Push_Data(&TIEDA_ACQ_VALUE(i->second, TIEDA_VAL_STATE::TVS_MOVEING), 3);
//	}
//
//	CommData.Push_Data((WORD)CurveTypeCode::eCurveTypeCode_0x1030);
//	CommData.Push_Data(byFixOrNot);
//	CommData.Push_Data((WORD)0);//偏移量
//	CommData.Push_Data((WORD)50);
//	CommData.Push_Data(n);
//	for (auto i = map20; i != map21; i++)
//	{
//		//CommData.Push_Data(&i->second, 3);//TODO
//		CommData.Push_Data(&TIEDA_ACQ_VALUE(i->second, TIEDA_VAL_STATE::TVS_MOVEING), 3);
//	}
//
//
//	//插入帧尾
//	CommData.Push_Tail();
//	//组装结束，更新帧长度
//	CommData.Update_FrameLen();
//
//	return TRUE;
//}
//
//
//BOOL CCSM315Protocol::DataSerialize(BYTE byProtocalCMD, bool bPush, int no,
//	WORD wIdx, int num, const std::vector<int>& vctData0,
//	const std::vector<int>& vctData1, const std::vector<int>& vctData2,
//	DWORD atime, C315CommData& CommData)
//{
//	//开始组装，清空数据
//	CommData.Clear_Data();
//	//插入帧头
//	InitFrmHead12B(CommData, FRAME_TYPE_DATA, PROTOCAL_CODE);
//
//	CommData.Push_Data(byProtocalCMD);
//	CommData.Push_Data((BYTE)(bPush ? 0 : 1));
//	CommData.Push_Data((BYTE)no);
//	CommData.Push_Data(wIdx);
//	CommData.Push_Data(atime);
//	CommData.Push_Data((BYTE)3);
//
//	CommData.Push_Data((WORD)AcqTypeCode::eAcqTypeCode_0x101);
//	CommData.Push_Data((BYTE)0);
//	CommData.Push_Data((WORD)0);
//	CommData.Push_Data((WORD)25);
//	CommData.Push_Data((DWORD)num);
//	for (int i = 0; i < num; i++)
//	{
//		CommData.Push_Data(&vctData0[i], 3);
//	}
//
//	CommData.Push_Data((WORD)AcqTypeCode::eAcqTypeCode_0x102);
//	CommData.Push_Data((BYTE)1);
//	CommData.Push_Data((WORD)0);
//	CommData.Push_Data((WORD)25);
//	CommData.Push_Data((DWORD)num);
//	for (int i = 0; i < num; i++)
//	{
//		CommData.Push_Data(&vctData1[i], 3);
//	}
//
//	CommData.Push_Data((WORD)AcqTypeCode::eAcqTypeCode_0x103);
//	CommData.Push_Data((BYTE)0xff);
//	CommData.Push_Data((WORD)0);
//	CommData.Push_Data((WORD)25);
//	CommData.Push_Data((DWORD)num);
//	for (int i = 0; i < num; i++)
//	{
//		CommData.Push_Data(&vctData2[i], 3);
//	}
//
//
//	//插入帧尾
//	CommData.Push_Tail();
//	//组装结束，更新帧长度
//	CommData.Update_FrameLen();
//
//	return TRUE;
//
//}

//E_315_PROTOCOL_0x51 实时数据查询返回
BOOL CCSM315Protocol::DataSerialize(BYTE byProtocalCMD, const std::vector<NodeRealData>& vecConfig, C315CommData& CommData)
{
	//开始组装，清空数据
	CommData.Clear_Data();
	//插入帧头
	InitFrmHead12B(CommData, FRAME_TYPE_DATA, PROTOCAL_CODE);

	CommData.Push_Data(byProtocalCMD);
	CommData.Push_Data((BYTE)(1));
	WORD size = (WORD)vecConfig.size();
	CommData.Push_Data(size);
	
	for (int i = 0; i < size; i++)
	{
		CommData.Push_Data(vecConfig[i].dwAcqTime);
		CommData.Push_Data(vecConfig[i].wNodeID);

		CommData.Push_Data(vecConfig[i].byFixInvert);

		BYTE acqsize = vecConfig[i].vecAcqTypeID.size();
		CommData.Push_Data(acqsize);
		for (BYTE j = 0; j < acqsize; j++)
		{
			WORD wAcqTypeID = vecConfig[i].vecAcqTypeID[j];
			CommData.Push_Data(wAcqTypeID);
			CommData.Push_Data(vecConfig[i].vecStatus[j]);
			switch ((AcqTypeCode)wAcqTypeID)
			{
			case AcqTypeCode::eAcqTypeCode_0x101:
			case AcqTypeCode::eAcqTypeCode_0x102:
			case AcqTypeCode::eAcqTypeCode_0x103:
				CommData.Push_Data(&TIEDA_ACQ_VALUE(vecConfig[i].vecAcqData[j], TIEDA_VAL_STATE::TVS_POLL), 3);
				break;
			case AcqTypeCode::eAcqTypeCode_0x104:
			case AcqTypeCode::eAcqTypeCode_0x105:
				CommData.Push_Data(&TIEDA_ACQ_VALUE(vecConfig[i].vecAcqData[j], TIEDA_VAL_STATE::TVS_POLL, 3), 3);
				break;
			default:
				break;
			}
		}
	}

	//插入帧尾
	CommData.Push_Tail();
	//组装结束，更新帧长度
	CommData.Update_FrameLen();

	return TRUE;

}

////first:makelong(牵引点, 采集码) second.first:采集时间 vector:采集数据列表 pair：偏移时间和采集值
//E_315_PROTOCOL_0x55
BOOL CCSM315Protocol::DataSerialize(BYTE byProtocalCMD, const std::map<DWORD, stHisStaticValue>& mapData, C315CommData& CommData)
{
	//开始组装，清空数据
	CommData.Clear_Data();
	CommData.Reserve(10240);//分配10K

	//插入帧头
	InitFrmHead12B(CommData, FRAME_TYPE_DATA, PROTOCAL_CODE);

	CommData.Push_Data(byProtocalCMD);
	WORD size = (WORD)mapData.size();
	CommData.Push_Data(size);

	for (auto& it : mapData)
	{
		WORD wNodeID = LOWORD(it.first);
		WORD wAcqTypeID = HIWORD(it.first);
		CommData.Push_Data(wNodeID);   //牵引点ID
		CommData.Push_Data(wAcqTypeID);   //采集信息类型

		//采集数据【n】  起始时间[4]+数据个数[2]+ {时间偏移量[2]+采集值[3]}
		CommData.Push_Data(it.second.dwStartTime);
		CommData.Push_Data((WORD)it.second.vctAcqData.size());

		for (auto &it1 : it.second.vctAcqData)
		{
			CommData.Push_Data(it1.first);
			switch ((AcqTypeCode)wAcqTypeID)
			{
			case AcqTypeCode::eAcqTypeCode_0x101:
			case AcqTypeCode::eAcqTypeCode_0x102:
			case AcqTypeCode::eAcqTypeCode_0x103:
				CommData.Push_Data(&TIEDA_ACQ_VALUE(it1.second, TIEDA_VAL_STATE::TVS_POLL), 3);
				break;
			case AcqTypeCode::eAcqTypeCode_0x104:
			case AcqTypeCode::eAcqTypeCode_0x105:
				CommData.Push_Data(&TIEDA_ACQ_VALUE(it1.second, TIEDA_VAL_STATE::TVS_POLL, 3), 3);
				break;
			default:
				break;
			}
			//CommData.Push_Data(&it1.second, 3);
		}
	}

	//插入帧尾
	CommData.Push_Tail();
	//组装结束，更新帧长度
	CommData.Update_FrameLen();

	return TRUE;

}

//E_315_PROTOCOL_0x57
BOOL CCSM315Protocol::DataSerialize(BYTE byProtocalCMD, BYTE byFixOrNot, bool bPush, int no, WORD wEqpNO, int num, 
	std::map<time_t, int>* mapData[], time_t tmStartSecond, time_t tmEndSecond, C315CommData& CommData)
{
	//开始组装，清空数据
	CommData.Clear_Data();
	CommData.Reserve(4096);
	//插入帧头
	InitFrmHead12B(CommData, FRAME_TYPE_DATA, PROTOCAL_CODE);
	DWORD atime = tmStartSecond;

	CommData.Push_Data(byProtocalCMD);
	CommData.Push_Data((BYTE)(bPush ? 0 : 1));
	CommData.Push_Data((BYTE)no);
	CommData.Push_Data(wEqpNO);
	CommData.Push_Data(atime);
	CommData.Push_Data((BYTE)3);

	CommData.Push_Data((WORD)CurveTypeCode::eCurveTypeCode_0x1010);
	CommData.Push_Data(byFixOrNot);
	CommData.Push_Data((WORD)0);//偏移量
	CommData.Push_Data((WORD)50);

	auto insert_pos = CommData.GetDataSize();
	DWORD n = 0;
	CommData.Push_Data(n);//数据点数
	{
		auto it = mapData[0]->find(tmStartSecond*1000);
		for (it; it != mapData[0]->end() && it->first / 1000 < tmEndSecond; it++)
		{
			CommData.Push_Data(&TIEDA_ACQ_VALUE(it->second, TIEDA_VAL_STATE::TVS_MOVEING), 3);
			++n;
		}
	}
	ASSERT(n % 50 == 0);
	CommData.Update_Data(insert_pos, &n, 4);

	CommData.Push_Data((WORD)CurveTypeCode::eCurveTypeCode_0x1020);
	CommData.Push_Data(byFixOrNot);
	CommData.Push_Data((WORD)0);//偏移量
	CommData.Push_Data((WORD)50);
	CommData.Push_Data(n);
	int n1 = 0;
	{
		auto it = mapData[1]->find(tmStartSecond * 1000);
		for (it; it != mapData[1]->end() && it->first / 1000 < tmEndSecond; it++)
		{
			CommData.Push_Data(&TIEDA_ACQ_VALUE(it->second, TIEDA_VAL_STATE::TVS_MOVEING), 3);
			++n1;
		}
	}

	CommData.Push_Data((WORD)CurveTypeCode::eCurveTypeCode_0x1030);
	CommData.Push_Data(byFixOrNot);
	CommData.Push_Data((WORD)0);//偏移量
	CommData.Push_Data((WORD)50);
	CommData.Push_Data(n);
	int n2 = 0;
	{
		auto it = mapData[2]->find(tmStartSecond * 1000);
		for (it; it != mapData[2]->end() && it->first / 1000 < tmEndSecond; it++)
		{
			CommData.Push_Data(&TIEDA_ACQ_VALUE(it->second, TIEDA_VAL_STATE::TVS_MOVEING), 3);
			++n2;
		}
	}
	ASSERT(n == n1 && n1 == n2);
	assert(n == n1 && n == n2);

	//插入帧尾
	CommData.Push_Tail();
	//组装结束，更新帧长度
	CommData.Update_FrameLen();

	return TRUE;
}