// SimulatorDlg.cpp: 实现文件
//

#include "stdafx.h"
#include "Simulator.h"
#include "SimulatorDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CSimulatorDlg 对话框
//#define JHD_DISCONNECTED	WM_USER + 1

typedef struct
{
	CSimulatorDlg* pThis;
	LPVOID pBuf;
	DWORD nLen;
}ThreadData, * PThreadData;

CSimulatorDlg::CSimulatorDlg(CWnd* pParent /*=nullptr*/)
	: CDialogEx(IDD_SIMULATOR_DIALOG, pParent)
{
	m_pDlgRecord = NULL;
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CSimulatorDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST_CLIENTS, m_lstClients);
	DDX_Control(pDX, IDC_LIST_EQP, m_lstEqps);
	DDX_Control(pDX, IDC_DATETIMEPICKER_START, m_dtBegin);
	DDX_Control(pDX, IDC_DATETIMEPICKER_END, m_dtEnd);

}

BEGIN_MESSAGE_MAP(CSimulatorDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	//ON_MESSAGE(JHD_DISCONNECTED, &CSimulatorDlg::OnJhdDisconnect)
	ON_BN_CLICKED(IDC_BUTTON_LISTEN, &CSimulatorDlg::OnBnClickedButtonListen)
	ON_BN_CLICKED(IDC_BUTTON_GAPCFG, &CSimulatorDlg::OnBnClickedButtonGapcfg)
	ON_BN_CLICKED(IDC_BUTTON_NEWVALUE, &CSimulatorDlg::OnBnClickedButtonNewvalue)
	ON_NOTIFY(LVN_ITEMCHANGED, IDC_LIST_CLIENTS, &CSimulatorDlg::OnLvnItemchangedListClients)
	ON_BN_CLICKED(IDC_CHECK_ALL_ALARM, &CSimulatorDlg::OnBnClickedCheckAllAlarm)
	ON_BN_CLICKED(IDC_BUTTON_ALARM, &CSimulatorDlg::OnBnClickedButtonAlarm)
	ON_BN_CLICKED(IDC_BUTTON_0x55, &CSimulatorDlg::OnBnClickedButton0x55)
	ON_BN_CLICKED(IDC_BUTTON_0x56, &CSimulatorDlg::OnBnClickedButton0x56)
	ON_BN_CLICKED(IDC_BUTTON_0x57, &CSimulatorDlg::OnBnClickedButton0x57)
	ON_BN_CLICKED(IDC_BUTTON_RECORD, &CSimulatorDlg::OnBnClickedButtonRecord)
	ON_BN_CLICKED(IDC_BUTTON_PARSE, &CSimulatorDlg::OnBnClickedButtonParse)
END_MESSAGE_MAP()


// CSimulatorDlg 消息处理程序

BOOL CSimulatorDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	// 设置此对话框的图标。  当应用程序主窗口不是对话框时，框架将自动
	//  执行此操作
	SetIcon(m_hIcon, TRUE);			// 设置大图标
	SetIcon(m_hIcon, FALSE);		// 设置小图标

	//ShowWindow(SW_MAXIMIZE);
	SetDlgItemInt(IDC_EDIT_PORT, 9000);
	//ShowWindow(SW_MINIMIZE);
	CenterWindow();

	m_pDlgRecord = new CDlgRecord();
	m_pDlgRecord->Create(CDlgRecord::IDD, this);
	m_pDlgRecord->ShowWindow(SW_SHOW);

	m_dtBegin.SetFormat(_T("yyyy/MM/dd HH:mm:ss"));
	m_dtEnd.SetFormat(_T("yyyy/MM/dd HH:mm:ss"));
	SYSTEMTIME st;
	GetLocalTime(&st);
	st.wHour = 0; st.wMinute = 0; st.wSecond = 0; st.wMilliseconds = 0;
	m_dtBegin.SetTime(st);
	st.wHour = 23; st.wMinute = 59; st.wSecond = 59; st.wMilliseconds = 0;
	m_dtEnd.SetTime(st);

	m_lstClients.SetExtendedStyle(m_lstClients.GetExtendedStyle() | LVS_EX_GRIDLINES | LVS_EX_FULLROWSELECT | LVS_EX_CHECKBOXES);
	m_lstClients.InsertColumn(0, _T("编号"), LVCFMT_LEFT, 50);
	m_lstClients.InsertColumn(1, _T("地址"), LVCFMT_LEFT, 120);
	m_lstClients.InsertColumn(2, _T("端口号"), LVCFMT_LEFT, 80);
	m_lstClients.InsertColumn(3, _T("连接时间"), LVCFMT_LEFT, 100);
	m_lstClients.InsertColumn(4, _T("接收次数"), LVCFMT_LEFT, 80);
	m_lstClients.InsertColumn(5, _T("发送次数"), LVCFMT_LEFT, 80);


	m_lstEqps.SetExtendedStyle(m_lstEqps.GetExtendedStyle() | LVS_EX_GRIDLINES | LVS_EX_FULLROWSELECT | LVS_EX_CHECKBOXES);
	m_lstEqps.InsertColumn(0, _T("牵引ID"), LVCFMT_LEFT, 50);
	m_lstEqps.InsertColumn(1, _T("名称"), LVCFMT_LEFT, 100);
	m_lstEqps.InsertColumn(2, _T("采集类型"), LVCFMT_LEFT, 200);

	OnInitSocket();


	// TODO: 在此添加额外的初始化代码
	//AllocConsole();//为当前的窗口程序申请一个Console窗口
	//freopen("CONOUT$", "a+", stdout);

	return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
}

void CSimulatorDlg::OnInitSocket()
{
	//tcp记录
	m_tcpServer_315.m_callBackTcpLog = [this](int nType, CString strIP, int nPort, const void* pData, int nDataSize, int nSendSize, int nError)
		{
			//错误日志，强制写入
			if (/*g_pProjectConf->m_bLogTcpIocpLog || */nError != 0)
			{
				std::string strbuf = "";
				char szTitle[100];
				switch (nType)
				{
				case 0:
					_snprintf(szTitle, 100, "(315TCP记录[%s:%d][包Size:%d, 发送:%d, 错误码:%d])", strIP.GetBuffer(), nPort, nDataSize, nSendSize, nError);

					//正确时，最多写入50字节
					if (nError == 0 && nDataSize > 50)
					{
						strbuf = CCSM315Protocol::GetStrFromData((BYTE*)pData, 50) + "...";
					}
					else
					{
						strbuf = CCSM315Protocol::GetStrFromData((BYTE*)pData, nDataSize);
					}

					break;
				case 1:
					_snprintf(szTitle, 100, "(315TCP记录[%s:%d][连接])", strIP.GetBuffer(), nPort);
					strbuf = std::string((char*)pData);
					break;
				case 2:
					_snprintf(szTitle, 100, "(315TCP记录[%s:%d][断开])", strIP.GetBuffer(), nPort);
					strbuf = std::string((char*)pData);
					break;
				case 3:
					_snprintf(szTitle, 100, "(315TCP记录[%s:%d][异常])", strIP.GetBuffer(), nPort);
					strbuf = std::string((char*)pData);
					break;
				}
				//m_lpManageFrame->writelog((BYTE*)strbuf.c_str(), strbuf.length(), FALSE, szTitle);

			}
		};

}
// 如果向对话框添加最小化按钮，则需要下面的代码
//  来绘制该图标。  对于使用文档/视图模型的 MFC 应用程序，
//  这将由框架自动完成。

void CSimulatorDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); // 用于绘制的设备上下文

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		// 使图标在工作区矩形中居中
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// 绘制图标
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

//当用户拖动最小化窗口时系统调用此函数取得光标
//显示。
HCURSOR CSimulatorDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

void CSimulatorDlg::ConnStatusChange(ClientInfo* pCltInfo, BOOL bIsConn)
{
	if (!bIsConn)
	{
		m_cs315CltList.Lock();

		delete m_map315CltInfo[pCltInfo];
		m_map315CltInfo.erase(pCltInfo);
		m_cs315CltList.Unlock();

		DeleteClient(pCltInfo);
	}
	else
	{
		m_cs315CltList.Lock();
		Clt315_Info* appLayer = new Clt315_Info();
		appLayer->pTcpClt = pCltInfo;
		pCltInfo->pAppLayerClt = appLayer;
		m_map315CltInfo[pCltInfo] = appLayer;
		m_cs315CltList.Unlock();
		InsertClient(pCltInfo);

		C315CommData CommData;
		GetGapConfig(CommData);
		m_tcpServer_315.SendData((const char*)CommData.GetData(), (int)CommData.GetDataSize(), pCltInfo->sock);
	}
}

void CSimulatorDlg::InsertClient(const ClientInfo* pCltInfo)
{
	UINT uItem = m_lstClients.GetItemCount();
	m_lstClients.InsertItem(uItem, std::to_string(uItem + 1).c_str());
	SYSTEMTIME st;
	GetLocalTime(&st);
	CString strTime;
	strTime.Format("%02d:%02d:%02d.%03d", st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
	//m_lstRecord.SetItemText(uItem, 1, strTime);
	m_lstClients.SetItemText(uItem, 1, pCltInfo->strIP);
	m_lstClients.SetItemText(uItem, 2, std::to_string(pCltInfo->iPort).c_str());
	//m_lstRecord.SetItemText(uItem, 2, std::to_string(nPort).c_str());

	m_lstClients.SetItemText(uItem, 3, strTime);
	m_lstClients.SetItemText(uItem, 4, "0");
	m_lstClients.SetItemText(uItem, 5, "0");
	m_lstClients.SetItemData(uItem, pCltInfo->sock);
}

void CSimulatorDlg::UpdateClient(const ClientInfo* pCltInfo)
{
	for (int i = 0; i < m_lstClients.GetItemCount(); i++)
	{
		if (m_lstClients.GetItemText(i, 1) == pCltInfo->strIP && m_lstClients.GetItemText(i, 2) == to_string(pCltInfo->iPort).c_str())
		{
			m_lstClients.SetItemText(i, 4, std::to_string(pCltInfo->iRecvCount).c_str());
			m_lstClients.SetItemText(i, 5, std::to_string(pCltInfo->iSendSucCount).c_str());

			break;
		}
	}
}

void CSimulatorDlg::DeleteClient(const ClientInfo* pCltInfo)
{
	for (int i = 0; i < m_lstClients.GetItemCount(); i++)
	{
		if (m_lstClients.GetItemText(i, 1) == pCltInfo->strIP && m_lstClients.GetItemText(i, 2) == to_string(pCltInfo->iPort).c_str())
		{
			m_lstClients.DeleteItem(i);
			break;
		}
	}
}


void CSimulatorDlg::OnRecvData_TCPServer(BYTE* pData, int iLen, ClientInfo* pCltInfo)
{
	EQP_COMM_ADDR addr;
	addr.strIP = pCltInfo->strIP;
	addr.id = "";

	//从通信层客户端信息获得应用层客户端信息
	Clt315_Info* cltALInfo = m_map315CltInfo[pCltInfo];

	PktAssembleBuff* pab = &cltALInfo->pktAssembleBuff;
	pab->PushStream(pData, iLen);
	while (pab->PopPkt())
	{
		PKT_DATA* ppd = new PKT_DATA(pab->pkt, pab->iPktLen);
		ppd->addr = addr;
		ppd->proto = pab->m_protocolType;

		//if (NULL != m_pMonitorView) {
		//	m_pMonitorView->StatisOnRecv(ppd->m_DataBuf, ppd->m_iDataBufLen, pCltInfo->strIP);
		//}

		OnRecvPkt(ppd, cltALInfo);
	}
}


//心跳和道岔信号0x22直接处理,其余放入异步队列线程中
void CSimulatorDlg::OnRecvPkt(PKT_DATA* ppd, Clt315_Info* pCltInfo)
{
	PKT_DATA* pData = ppd;
	PBYTE pBuf = (PBYTE)pData->m_DataBuf;
	int ipos = 7;
	BYTE frmtype = *(BYTE*)(pBuf + ipos);
	ipos += 1;
	DWORD frmlen = *(DWORD*)(pBuf + ipos);
	ipos += 4;
	if (frmtype == FRAME_TYPE_HEARTBEAT)//心跳
	{
		//WI_CALLBACK callBkPara;
		//ZeroMemory(&callBkPara, sizeof(callBkPara));
		//callBkPara.wiCallBack.dwLen = sizeof(callBkPara);
		//callBkPara.wiCallBack.dwVersion = 0x01000000;
		//DWORD ltm = *(DWORD*)(pBuf + ipos);
		//ipos += 4;
		//callBkPara.wiCallBack.dwOperationType = 4;
		//callBkPara.wiCallBack.sDataTime = timeOpt::Time_tToSystemTime(ltm);;
		//callBkPara.wiCallBack.dwUser = 0;
		//callBkPara.wiCallBack.CltInfo = pCltInfo->pTcpClt;
		////log
		//if (g_pProjectConf->m_bEnableDetailLog)
		//{
		//	CString strLog;
		//	strLog.Format("收到心跳时间:%04d-%02d-%02d %02d:%02d:%02d TimeSyncLimit:%d", callBkPara.wiCallBack.sDataTime.wYear, callBkPara.wiCallBack.sDataTime.wMonth, callBkPara.wiCallBack.sDataTime.wDay,
		//		callBkPara.wiCallBack.sDataTime.wHour, callBkPara.wiCallBack.sDataTime.wMinute, callBkPara.wiCallBack.sDataTime.wSecond, g_pProjectConf->m_iTimeSyncLimit);
		//	m_lpManageFrame->writelog((LPBYTE)(LPCSTR)strLog, strLog.GetLength(), TRUE, "(心跳5min)", pCltInfo->pTcpClt);
		//}

		//CmdCallBack(&callBkPara);

		m_pDlgRecord->InsertData(pCltInfo->pTcpClt->strIP, pCltInfo->pTcpClt->iPort, pBuf, pData->m_iDataBufLen);

		delete pData;
		return;
	}
	//else if (frmtype == FRAME_TYPE_DATA)//道岔信号直接处理
	//{
	//	BYTE cmd = *(BYTE*)(pBuf + 5 + 1 + 1 + 1 + 4);
	//	//if (cmd == 0x22)
	//	//{
	//	//	try
	//	//	{
	//	//		DealRequestPkt(pBuf, pData->m_iDataBufLen, pCltInfo->pTcpClt);
	//	//	}
	//	//	catch (CException* e)
	//	//	{
	//	//		//g_pLogForRun->LogStaticAcq(fmt::format("[315]捕获到DealRequestPkt异常{}{}", __FUNCTION__, __LINE__).c_str());
	//	//	}
	//	//	delete pData;
	//	//	return;
	//	//}
	//}
	//else
	//{
	//	return;
	//}

	pCltInfo->AysnPktQueue.Push(pData);
}


DWORD WINAPI CSimulatorDlg::Thread_DealRecv(LPVOID pParam)
{
	CSimulatorDlg* pThis = (CSimulatorDlg*)(pParam);
	return pThis->DealRecv();
}

DWORD CSimulatorDlg::DealRecv()
{
	while (m_bWIFRunning)
	{
		Sleep(1);

		//DWORD hr;
		//hr = WaitForSingleObject(m_hRecvSema1, 50);//等待处理数据的信号量

		//取出一包处理
		PKT_DATA* pData = NULL;
		ClientInfo* pClt = NULL;
		m_cs315CltList.Lock();
		std::map<ClientInfo*, Clt315_Info*>::iterator i = m_map315CltInfo.begin();
		for (; i != m_map315CltInfo.end(); i++)
		{
			pData = i->second->AysnPktQueue.Pop();
			if (pData)
			{
				pClt = i->second->pTcpClt;
				break;
			}
		}
		m_cs315CltList.Unlock();

		if (pData == NULL)
		{
			continue;
		}

		PBYTE pBuf = (PBYTE)pData->m_DataBuf;
		int ipos = 0;
		ipos += 7;
		BYTE frmType = *(BYTE*)(pBuf + ipos);
		ipos += 1;
		if (frmType == 0x0f)//心跳帧
		{
			int len = *(DWORD*)(pBuf + ipos);
			ipos += 4;
			long ltm = *(long*)(pBuf + ipos);
			ipos += 4;
		}

		try
		{
			DealRequestPkt(pBuf, pData->m_iDataBufLen, pClt);
		}
		catch (CException* e)
		{
		//	g_pLogForRun->LogStaticAcq(fmt::format("[315]捕获到DealRequestPkt异常{}{}", __FUNCTION__, __LINE__).c_str());
		}

		delete pData;
	}

	return 0;
}

BOOL CSimulatorDlg::DealRequestPkt(PBYTE pBuf, int nBufLen, ClientInfo* pClt)
{
	int ipos = 7;

	BYTE frmtype = *(BYTE*)(pBuf + ipos);
	ipos += 1;

	DWORD frmlen = *(DWORD*)(pBuf + ipos);
	ipos += 4;

	BYTE cmdCode = *(BYTE*)(pBuf + ipos);
	E_315_PROTOCOL_TYPE eProtocolType = (E_315_PROTOCOL_TYPE)cmdCode;
	ipos += 1;
	m_pDlgRecord->InsertData(pClt->strIP, pClt->iPort, pBuf, nBufLen);

	if (eProtocolType == E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x50)
	{
		m_lstEqps.DeleteAllItems();
		string key = (LPCSTR)pClt->strIP;
		key += ":" + to_string(pClt->iPort);
		m_strClientIP = pClt->strIP;
		m_uPort = pClt->iPort;

		SetWindowText("当前站点:" + m_strClientIP);
		m_mapNodes[key].clear();
		WORD size = *(WORD*)(pBuf + ipos); ipos += 2;
		//string strMsg = "[0x50配置]个数:" + to_string(size) + "\r\n";
		for (WORD i = 0; i < size; i++)
		{
			stNodeItem it;
			BYTE len = *(BYTE*)(pBuf + ipos); ipos += 1;
			CString strText((char*)pBuf + ipos, len); ipos += len;
			//strMsg += "名称:";
			//strMsg += (LPCSTR)strText;
			it.wNodeID = *(WORD*)(pBuf + ipos); ipos += 2;
			//strMsg += ", ID:" + to_string(id);
			UINT uItem = m_lstEqps.GetItemCount();
			m_lstEqps.InsertItem(uItem, to_string(it.wNodeID).c_str());
			m_lstEqps.SetItemText(uItem, 1, strText);
			BYTE cnt = *(BYTE*)(pBuf + ipos); ipos += 1;
			ZeroMemory(it.szName, sizeof(it.szName));
			CopyMemory(it.szName, (LPCSTR)strText, min(strText.GetLength(), sizeof(it.szName)));
			strText = "";
			for (BYTE j = 0; j < cnt; j++)
			{
				WORD acqtype = *(WORD*)(pBuf + ipos); ipos += 2;
				it.vctAcqID.push_back(acqtype);
				strText.AppendFormat("%s,", CCSM315ProtocolEx::GetAcqTypeDesc(acqtype).c_str());
			}
			m_lstEqps.SetItemText(uItem, 2, strText);
			m_lstEqps.SetItemData(uItem, it.wNodeID);
			m_mapNodes[key][it.wNodeID] = it;
		}
	}
	//自动回复
	else if (eProtocolType == E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x51)
	{
		BYTE byPush = *(BYTE*)(pBuf + ipos);
		ipos += 1;

		if (byPush == 0)
		{
			C315CommData CommData;

			//开始组装，清空数据
			CommData.Clear_Data();
			//插入帧头
			CCSM315ProtocolEx::InitFrmHead12B(CommData, FRAME_TYPE_DATA, 0x02);

			CommData.Push_Data((BYTE)E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x52);

			CommData.Push_Data(*(WORD*)(pBuf + ipos));
			//插入帧尾
			CommData.Push_Tail();
			//组装结束，更新帧长度
			CommData.Update_FrameLen();

			m_tcpServer_315.SendData((const char*)CommData.GetData(), (int)CommData.GetDataSize(), pClt->sock);

		}
	}
	//自动回复
	else if (eProtocolType == E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x53)
	{
		BYTE byPush = *(BYTE*)(pBuf + ipos);
		ipos += 1;

		if (byPush == 0)
		{
			C315CommData CommData;

			//开始组装，清空数据
			CommData.Clear_Data();
			//插入帧头
			CCSM315ProtocolEx::InitFrmHead12B(CommData, FRAME_TYPE_DATA, 0x02);

			CommData.Push_Data((BYTE)E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x54);

			CommData.Push_Data(*(BYTE*)(pBuf + ipos));
			//插入帧尾
			CommData.Push_Tail();
			//组装结束，更新帧长度
			CommData.Update_FrameLen();
			m_tcpServer_315.SendData((const char*)CommData.GetData(), (int)CommData.GetDataSize(), pClt->sock);
		}
	}
	//自动回复
	else if (eProtocolType == E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x57)
	{
		BYTE byPush = *(BYTE*)(pBuf + ipos);
		ipos += 1;

		if (byPush == 0)
		{
			C315CommData CommData;

			//开始组装，清空数据
			CommData.Clear_Data();
			//插入帧头
			CCSM315ProtocolEx::InitFrmHead12B(CommData, FRAME_TYPE_DATA, 0x02);

			CommData.Push_Data((BYTE)E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x58);

			BYTE no = *(BYTE*)(pBuf + ipos); ipos += 1;
			WORD wNodeID = *(WORD*)(pBuf + ipos); ipos += 2;
			CommData.Push_Data(wNodeID);
			CommData.Push_Data(no);
			//插入帧尾
			CommData.Push_Tail();
			//组装结束，更新帧长度
			CommData.Update_FrameLen();
			m_tcpServer_315.SendData((const char*)CommData.GetData(), (int)CommData.GetDataSize(), pClt->sock);
		}
	}
	return TRUE;
	//switch (eProtocolType)
	//{
	//case E_315_PROTOCOL_TYPE::ACTIVE_KEEP:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x23:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x26:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x27:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x29:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x32:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x2A:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x2E:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x2F:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x22:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x25:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x24:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x30:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x31:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x50:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x51:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x52:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x53:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x54:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x55:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x56:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x57:
	//	break;
	//case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x58:
	//	break;
	//default:
	//	break;
	//}
}
//
//
//LRESULT CSimulatorDlg::OnJhdDisconnect(WPARAM wParam, LPARAM)
//{
//	if (m_bJHDConnected)
//	{
//		WriteLog("断开jhd服务器");
//
//		m_jhdSock.Disconnect(wParam);
//
//		WriteLog("sock:", wParam);
//
//		m_bJHDConnected = false;
//	}
//
//	return 0;
//}
//
//
//
//DWORD CSimulatorDlg::HeartbeatThreadProc(LPVOID lpParam)
//{
//	CSimulatorDlg* pThis = (CSimulatorDlg*)(lpParam);
//	return pThis->HeartbeatThread();
//}
//
//int CSimulatorDlg::HeartbeatThread()
//{
//	SendHeartbeat();
//
//	DWORD dwTick = GetTickCount();
//
//	while (m_bJHDConnected)
//	{
//		Sleep(50);
//
//		if (!m_bJHDConnected)
//			break;
//
//		if (GetTickCount() - dwTick < 5000)
//			continue;
//
//		//发心跳
//		SendHeartbeat();
//
//		dwTick = GetTickCount();
//
//	}
//
//	return 0;
//}

int CSimulatorDlg::SendHeartbeat()
{
	BYTE pBuf[100];
	int ipos = 0;
	BYTE head[12];
	CCSM315Protocol::InitFrmHead12B(head, 0x0f, 0x2);
	memcpy(pBuf + ipos, head, 12);
	ipos += 12;

	long ltm = (long)time(NULL);
	*(long*)(pBuf + ipos) = ltm;
	ipos += 4;

	*(BYTE*)(pBuf + ipos) = 0xff;
	ipos += 1;
	*(BYTE*)(pBuf + ipos) = 0xff;
	ipos += 1;
	*(BYTE*)(pBuf + ipos) = 0xff;
	ipos += 1;

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

	//计算帧长度
	DWORD frmlen = ipos - 16;

	*(DWORD*)(pBuf + 8) = frmlen;

	//SendJHDData(INVALID_SOCKET, pBuf, ipos, false);

	return 0;
}

void CSimulatorDlg::GetGapConfig(C315CommData& CommData)
{
	//开始组装，清空数据
	CommData.Clear_Data();
	//插入帧头
	CCSM315ProtocolEx::InitFrmHead12B(CommData, FRAME_TYPE_DATA, 0x02);

	CommData.Push_Data((BYTE)E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x50);

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

//DWORD CSimulatorDlg::SendJHDDataProc(LPVOID lpParam)
//{
//	PThreadData pData = (PThreadData)lpParam;
//	CSimulatorDlg* pThis = pData->pThis;
//
//	pThis->SendJHDData(pData->pBuf, pData->nLen);
//
//	delete pData;
//
//	return 0;
//}
//
//int CSimulatorDlg::SendJHDData(SOCKET sock, LPVOID pBuf, DWORD nLen, bool bDelete/* = true*/)
//{
//	//m_dlgDataView.AddSendData(pBuf, nLen);
//
//	if (m_bJHDConnected)
//	{
//		if (sock == INVALID_SOCKET)
//		{
//			for (auto& it : m_mapClients)
//			{
//				int rst = m_jhdSock.Send(it.second.sock, (char*)pBuf, nLen);
//				if (rst == SOCKET_ERROR)
//				{
//					if (m_bJHDConnected)
//						SendMessage(JHD_DISCONNECTED, it.second.sock, 0);
//				}
//			}
//		} 
//		else
//		{
//			int rst = m_jhdSock.Send(sock, (char*)pBuf, nLen);
//			if (rst == SOCKET_ERROR)
//			{
//				if (m_bJHDConnected)
//					SendMessage(JHD_DISCONNECTED, sock, 0);
//			}
//		}
//
//	}
//
//	if (bDelete && pBuf)
//		delete[] pBuf;
//
//	return 0;
//}
//
//int CSimulatorDlg::DealJHDData(LPVOID lpParam)
//{
//	StFrame* pData = (StFrame*)lpParam;
//
////#ifdef _DEBUG
////	OutputDebugString(Parse315Protocol::ToString(*pData, 1).c_str());
////#endif
//
//	switch (pData->ftype)
//	{
//	case FRAME_TYPE_HEARTBEAT:
//	{
//		break;
//	}
//	case FRAME_TYPE_DATA:
//	{
//		StDataBasic* basic = (StDataBasic*)pData->lpdata;
//		auto protol = (E_315_PROTOCOL_TYPE)basic->cmdid;
//		switch (protol)
//		{
//		case E_315_PROTOCOL_TYPE::ACTIVE_KEEP:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x23:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x26:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x27:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x29:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x32:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x2A:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x2E:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x2F:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x22:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x25:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x24:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x30:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x31:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x50:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x51:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x52:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x53:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x54:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x55:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x56:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x57:
//			break;
//		case E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x58:
//			break;
//		default:
//			break;
//		}
//	}
//	}
//	return 0;
//}
//
//int CSimulatorDlg::DealJHDRawData(LPVOID lpBuf, int len)
//{
//	StFrame data;
//	ZeroMemory(&data, sizeof(StFrame));
//
//	if (CCSM315ProtocolEx::Parse(data, lpBuf, len))
//	{
//		DealJHDData(&data);
//	}
//	else
//	{
//		delete[] lpBuf;
//		return -1;
//	}
//
//	////单独遇到  0x23命令 解析一下
//	//BYTE cmd = Parse315Protocol::GetCommandId(data);
//	//if (cmd == CMD_CODE_GAPCFG)
//	//{
//	//	SetListCtrl(data.lpdata);
//	//	m_dlgWholeTime.SetListCtrl(data.lpdata);
//	//	m_dlgCombination.SetListCtrl(data.lpdata);
//	//}
//	////0x27命令 回复 （简化处理，原始数据直接发送回去，实际回复命令不含图像/视频内容）
//	//else if (cmd == CMD_CODE_ALARM_AND_IMG && m_isReply0x27 == TRUE)
//	//{
//	//	LPVOID buf = new BYTE[len];
//	//	memcpy(buf, lpBuf, len);
//	//	SendJHDData(buf, len);
//	//}
//
//	//m_dlgDataView.AddRecvData(data, lpBuf, len);
//
//	//Parse315Protocol::Release(data, 1);//JHD上送的必须注意释放内存
//	delete[] lpBuf;
//
//	return 0;
//}
//
//DWORD CSimulatorDlg::DealJHDDataProc(LPVOID lpParam)
//{
//	PThreadData pData = (PThreadData)lpParam;
//	CSimulatorDlg* pThis = pData->pThis;
//	pThis->DealJHDRawData(pData->pBuf, pData->nLen);
//	delete pData;
//
//	return 0;
//}
//
//DWORD CSimulatorDlg::RecvThreadProc(LPVOID lpParam)
//{
//	CSimulatorDlg* pThis = (CSimulatorDlg*)(lpParam);
//	return pThis->RecvThread();
//}
//
//int CSimulatorDlg::RecvThread()
//{
//	int nMaxSize = 1 * 1024 * 1024;
//	LPBYTE lpBuf = new BYTE[2 * nMaxSize];
//	int nLastPos = 0;
//	int nPacksCnt = 0;		//分包数量
//	//bool bOverFlow = false;
//
//	while (m_bJHDConnected)
//	{
//		//int hr = m_jhdSock.WaitRcvEvent(100);
//
//		//if (hr > 0)
//		{
//			if (!m_bJHDConnected)
//			{
//				break;
//			}
//
//			unsigned long len;
//			//hr = ioctlsocket(m_jhdSock.m_sock, FIONREAD, &len);
//			//if (hr == SOCKET_ERROR || len == 0)
//			//{
//			//	if (m_bJHDConnected)
//			//	{
//			//		SendMessage(JHD_DISCONNECTED, 0, 0);
//			//		WriteLog("jhd RecvThread 失败!");
//			//	}
//			//	break;
//			//}
//
//			////收到数据
//			//if (len > (unsigned long)nMaxSize)
//			//{
//			//	len = (unsigned long)nMaxSize;
//			//	bOverFlow = true;
//			//}
//			//else
//			//{
//			//	bOverFlow = false;
//			//}
//
//			LPBYTE pos = (LPBYTE)lpBuf + nLastPos;
//			ZeroMemory(pos, len);
//
//			int rst = m_jhdSock.Recv((char*)pos, len);
//			if (rst == SOCKET_ERROR)
//			{
//				if (m_bJHDConnected)
//				{
//					SendMessage(JHD_DISCONNECTED, 0, 0);
//					WriteLog("jhd RecvThread 失败3!");
//				}
//				break;
//			}
//
//#ifdef _DEBUG
//			if (len > 0)
//			{
//				CString str;
//				str.Format(_T("接收数据，原位置:%d, 长度 %d\n"), nLastPos, len);
//				//OutputDebugString(str);
//				if (len > 10000)
//				{
//					TRACE(str);
//				}
//			}
//#else
//			if (len > 0)
//			{
//				CString str;
//				str.Format(_T("接收数据，原位置:%d, 长度 %d\n"), nLastPos, len);
//				//OutputDebugString(str);
//				if (len > 3000)
//				{
//					printf(str);
//				}
//			}
//#endif
//
//			pos = lpBuf;
//			int bufsize = (int)len + nLastPos;
//			int datalen = 0;
//
//			while (CCSM315Protocol::GetFrameData(pos, bufsize, datalen))
//			{
//				LPVOID lpBuf = new BYTE[datalen];
//				memcpy_s(lpBuf, datalen, pos, datalen);
//
//				PThreadData pthdata = new ThreadData;
//				ZeroMemory(pthdata, sizeof(ThreadData));
//
//				pthdata->pThis = this;
//				pthdata->pBuf = lpBuf;
//				pthdata->nLen = datalen;
//
//				QueueUserWorkItem(CSimulatorDlg::DealJHDDataProc, pthdata, WT_EXECUTEDEFAULT);
//
//				pos = (LPBYTE)pos + datalen;
//				bufsize -= datalen;
//				datalen = 0;
//
//				nPacksCnt = 0;
//			}
//			++nPacksCnt;
//
//			if (bufsize > 0 && bufsize < nMaxSize && nPacksCnt < 20)
//			{
//				memmove_s(lpBuf, bufsize, pos, bufsize);
//				nLastPos = bufsize;
//
//				if (!bOverFlow)
//					Sleep(100);
//			}
//			else
//			{
//#ifdef _DEBUG
//				if (bufsize != 0)
//				{
//					CString str;
//					str.Format(_T("清空错误数据，数据长度 %d，失败次数 %d：	%s"), bufsize, nPacksCnt, BufToString(pos, bufsize).c_str());
//					OutputDebugString(str);
//				}
//#else
//				if (bufsize != 0)
//				{
//					CString str;
//					str.Format(_T("清空错误数据，数据长度 %d，失败次数 %d"), bufsize, nPacksCnt);
//					printf(str);
//				}
//
//#endif
//				nLastPos = 0;
//				nPacksCnt = 0;
//			}
//		}
//	}
//
//	delete[] lpBuf;
//	return 0;
//}
//
//
//DWORD CSimulatorDlg::ListenThreadProc9999(LPVOID lpParam)
//{
//	CSimulatorDlg* pThis = (CSimulatorDlg*)(lpParam);
//	return pThis->ListenThread9999();
//}
//
//int  CSimulatorDlg::ListenThread9999()
//{
//	BOOL bRet = m_jhdSock.Init();
//	WriteLog("网络初始化:", bRet);
//	bRet = m_jhdSock.Listen(GetDlgItemInt(IDC_EDIT_PORT), 1);
//	QueueUserWorkItem(CSimulatorDlg::HeartbeatThreadProc, this, WT_EXECUTEDEFAULT);
//	QueueUserWorkItem(CSimulatorDlg::RecvThreadProc, this, WT_EXECUTEDEFAULT);
//
//	while (m_bJHDListenThread)
//	{
//		CString strTip = "jhd连接数量:0";
//
//		SetDlgItemText(IDC_STATIC_SERVER, strTip);
//
//		stClientItem it;
//		WriteLog("开始监听:", bRet);
//		it.sock = m_jhdSock.Accept(it.from);
//		GetDlgItem(IDC_STATIC_STATUS)->SetWindowText(_T("JHD连接连接成功"));
//		char ip[INET_ADDRSTRLEN];
//		u_short port;
//		CTCPSocket::Convert(it.from, ip, port);
//		strTip.Format("JHD连接连接成功[%s:%d]", ip, port);
//		WriteLog((LPCSTR)strTip);
//		m_bJHDConnected = true;
//
//		GetDlgItem(IDC_STATIC_STATUS)->SetWindowText(_T("连接JHD服务器成功"));
//
//		//启动后先获取配置信息
//		OnBnClickedButtonGapcfg();
//		strTip = "jhd连接数量:1";
//
//		SetDlgItemText(IDC_STATIC_SERVER, strTip);
//
//		//while (m_bJHDConnected)
//		//{
//		//	//int hr = m_jhdSock.WaitRcvEvent(100);
//		//	//if (hr == SOCKET_ERROR)
//		//	//{
//		//	//	m_bJHDConnected = false;
//		//	//	GetDlgItem(IDC_STATIC_STATUS)->SetWindowText(_T("JHD连接断开1"));
//		//	//	std::cout << "JHD连接断开1" << std::endl;
//		//	//	m_jhdSock.Disconnect();
//		//	//}
//		//	//else if (hr > 0)
//		//	//{
//		//	//	unsigned long len;
//		//	//	hr = ioctlsocket(m_jhdSock.m_sock, FIONREAD, &len);
//		//	//	if (hr == SOCKET_ERROR || len == 0)
//		//	//	{
//		//	//		m_bJHDConnected = false;
//		//	//		m_jhdSock.Disconnect();
//		//	//		GetDlgItem(IDC_STATIC_STATUS)->SetWindowText(_T("JHD连接断开2"));
//		//	//		std::cout << "JHD连接断开2" << std::endl;
//		//	//	}
//		//	//}
//		//	//else
//		//	{
//		//		Sleep(1000);
//		//	}
//		//}
//	}
//
//	return 0;
//}

void CSimulatorDlg::OnBnClickedButtonListen()
{
	m_strClientIP = "";
	CString strText;
	GetDlgItemText(IDC_BUTTON_LISTEN, strText);
	if (strText == "监听")
	{
		//m_bJHDListenThread = true;
		//QueueUserWorkItem(CSimulatorDlg::ListenThreadProc9999, this, WT_EXECUTEDEFAULT);
		int iPort = GetDlgItemInt(IDC_EDIT_PORT);
		m_tcpServer_315.iAutoClearDeadConnectionTime = 60;
		if (!m_tcpServer_315.StartServer(this, iPort))
		{
			if (m_tcpServer_315.m_lastError == 10048)//通常每个套接字地址(协议/网络地址/端口)只允许使用一次
			{
				CString strData;
				strData.Format("[错误]端口%d 被占用,服务启动失败.", iPort);
				AfxMessageBox((LPCSTR)strData);
			}
		}
		else
		{
			GetDlgItem(IDC_BUTTON_LISTEN)->SetWindowText(_T("断开"));
			GetDlgItem(IDC_EDIT_PORT)->EnableWindow(FALSE);
			//m_hRecvSema1 = CreateSemaphore(NULL, 0, m_picFrmNum + m_packFrmNum, NULL);
			m_bWIFRunning = true;
			m_hRcvThread = CreateThread(NULL, 0, Thread_DealRecv, (LPVOID)this, 0, NULL);//通过异步队列异步处理上位机请求
			m_hYWAndStatus = CreateThread(NULL, 0, Thread_SendStatusByInterval, (LPVOID)this, 0, NULL);//周期发送油位及缺口采集设备状态信息
		}
	}
	else
	{
		GetDlgItem(IDC_BUTTON_LISTEN)->SetWindowText(_T("监听"));
		GetDlgItem(IDC_EDIT_PORT)->EnableWindow(TRUE);
		//m_bJHDListenThread = false;
		//SendMessage(JHD_DISCONNECTED, 0, 0);
		m_bWIFRunning = false;
		if (m_tcpServer_315.m_bStarted)
		{
			m_tcpServer_315.StopServer();
		}
		//closesocket(m_jhdSock.m_sockServer);
	}
}

DWORD WINAPI CSimulatorDlg::Thread_SendStatusByInterval(LPVOID pParam)
{
	CSimulatorDlg* pThis = (CSimulatorDlg*)(pParam);
	return pThis->SendStatusByInterval();
}

DWORD CSimulatorDlg::SendStatusByInterval()
{
	SYSTEMTIME stLastHeartbeatTime = { 0 };

	//CLinkNode* pnode = NULL;

	while (m_bWIFRunning)
	{
		//if (m_enableHeartBeat)
		{
			auto heartDif = CCSM315ProtocolEx::CalcTimePassSecond(&stLastHeartbeatTime);

			if (heartDif >= 5)
			{
				SendHeartbeat();
			}
		}
	}

	return 0;
}
void CSimulatorDlg::SendClients(const C315CommData& CommData)
{
	for (int i = 0; i < m_lstClients.GetItemCount(); i++)
	{
		if (m_lstClients.GetCheck(i))
		{
			SOCKET s = (SOCKET)m_lstClients.GetItemData(i);
			m_tcpServer_315.SendData((const char*)CommData.GetData(), (int)CommData.GetDataSize(), s);
		}
	}
}

void CSimulatorDlg::SendClients(const C315CommData& CommData, const CString& strClientIP, UINT uPort)
{
	CString strPort;
	strPort.Format("%u", uPort);
	for (int i = 0; i < m_lstClients.GetItemCount(); i++)
	{
		if (m_lstClients.GetItemText(i, 1) == strClientIP && m_lstClients.GetItemText(i, 2) == strPort)
		{
			SOCKET s = (SOCKET)m_lstClients.GetItemData(i);
			m_tcpServer_315.SendData((const char*)CommData.GetData(), (int)CommData.GetDataSize(), s);
			break;
		}
	}
}


void CSimulatorDlg::OnBnClickedButtonGapcfg()
{
	C315CommData CommData;

	GetGapConfig(CommData);

	SendClients(CommData);
}

void CSimulatorDlg::OnBnClickedButtonNewvalue()
{
	C315CommData CommData;

	//开始组装，清空数据
	CommData.Clear_Data();
	//插入帧头
	CCSM315ProtocolEx::InitFrmHead12B(CommData, FRAME_TYPE_DATA, 0x02);

	CommData.Push_Data((BYTE)E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x51);

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

	SendClients(CommData);
}


void CSimulatorDlg::OnLvnItemchangedListClients(NMHDR* pNMHDR, LRESULT* pResult)
{
	LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
	int nItem = pNMLV->iItem;
	int nSubItem = pNMLV->iSubItem;
	if (nItem != -1 && nSubItem != -1)
	{
		m_strClientIP = m_lstClients.GetItemText(nItem, 1);
		m_uPort = atoi(m_lstClients.GetItemText(nItem, 2));
		CString str = m_strClientIP + ":" + m_lstClients.GetItemText(nItem, 2);
		SetWindowText("当前站点:" + m_strClientIP);

		m_lstEqps.DeleteAllItems();
		auto p = m_mapNodes.find((LPCSTR)str);
		if (p != m_mapNodes.end())
		{
			for (auto &it : p->second)
			{
				UINT uItem = m_lstEqps.GetItemCount();
				m_lstEqps.InsertItem(uItem, to_string(it.second.wNodeID).c_str());
				m_lstEqps.SetItemText(uItem, 1, it.second.szName);
				CString strText;
				for (auto it1 : it.second.vctAcqID)
				{
					//strText.AppendFormat("0x%02x,", it1);
					strText.AppendFormat("%s,", CCSM315ProtocolEx::GetAcqTypeDesc(it1).c_str());
				}
				m_lstEqps.SetItemText(uItem, 2, strText);
				m_lstEqps.SetItemData(uItem, it.second.wNodeID);
			}
		}
	}
	*pResult = 0;
}


void CSimulatorDlg::OnBnClickedCheckAllAlarm()
{
	if (IsDlgButtonChecked(IDC_CHECK_ALL_ALARM) == BST_CHECKED)
		GetDlgItem(IDC_EDIT_ALARMID)->EnableWindow(FALSE);
	else
		GetDlgItem(IDC_EDIT_ALARMID)->EnableWindow(TRUE);
}


void CSimulatorDlg::OnBnClickedButtonAlarm()
{
	WORD uAlarmID = GetDlgItemInt(IDC_EDIT_ALARMID);
	if (uAlarmID == 0) uAlarmID = 0xFFFF;
	CTime tmBegin;
	m_dtBegin.GetTime(tmBegin);

	CTime tmEnd;
	m_dtEnd.GetTime(tmEnd);

	if (IsDlgButtonChecked(IDC_CHECK_ALL_ALARM) == BST_CHECKED)
	{
		C315CommData CommData;
	
		//开始组装，清空数据
		CommData.Clear_Data();
		//插入帧头
		CCSM315ProtocolEx::InitFrmHead12B(CommData, FRAME_TYPE_DATA, 0x02);
	
		CommData.Push_Data((BYTE)E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x53);
	
		CommData.Push_Data((DWORD)tmBegin.GetTime());
		CommData.Push_Data((DWORD)tmEnd.GetTime());
		CommData.Push_Data((WORD)0xFFFF);
		CommData.Push_Data(uAlarmID);
		//插入帧尾
		CommData.Push_Tail();
		//组装结束，更新帧长度
		CommData.Update_FrameLen();
	
		SendClients(CommData);
	} 
	else if (!m_strClientIP.IsEmpty())
	{
		for (int i = 0; i < m_lstEqps.GetItemCount(); i++)
		{
			if (m_lstEqps.GetCheck(i))
			{
				WORD s = (WORD)m_lstEqps.GetItemData(i);
				//m_tcpServer_315.SendData((const char*)CommData.GetData(), (int)CommData.GetDataSize(), s);
				C315CommData CommData;

				//开始组装，清空数据
				CommData.Clear_Data();
				//插入帧头
				CCSM315ProtocolEx::InitFrmHead12B(CommData, FRAME_TYPE_DATA, 0x02);

				CommData.Push_Data((BYTE)E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x53);

				CommData.Push_Data((DWORD)tmBegin.GetTime());
				CommData.Push_Data((DWORD)tmEnd.GetTime());
				CommData.Push_Data(s);
				CommData.Push_Data(uAlarmID);
				//插入帧尾
				CommData.Push_Tail();
				//组装结束，更新帧长度
				CommData.Update_FrameLen();

				SendClients(CommData, m_strClientIP, m_uPort);
			}
		}
	}
}


void CSimulatorDlg::OnBnClickedButton0x55()
{
	WORD cnt = 0;
	CString strKey;
	strKey.Format("%s:%u", (LPCSTR)m_strClientIP, m_uPort);
	auto pStation = m_mapNodes.find((LPCSTR)strKey);
	if (pStation == m_mapNodes.end()) 
	{
		AfxMessageBox("站点不存在!");
		return;
	}


	C315CommData CommData;
	//开始组装，清空数据
	CommData.Clear_Data();
	//插入帧头
	CCSM315ProtocolEx::InitFrmHead12B(CommData, FRAME_TYPE_DATA, 0x02);

	CommData.Push_Data((BYTE)E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x55);
	CTime tmBegin;
	m_dtBegin.GetTime(tmBegin);
	CTime tmEnd;
	m_dtEnd.GetTime(tmEnd);

	CommData.Push_Data((DWORD)tmBegin.GetTime());
	CommData.Push_Data((DWORD)tmEnd.GetTime());
	int nCountIdx = CommData.GetDataSize();//数目定位使用
	CommData.Push_Data(cnt);

	bool bAllEqps = IsDlgButtonChecked(IDC_CHECK_ALL_EQP) == BST_CHECKED;

	for (int i = 0; i < m_lstEqps.GetItemCount(); i++)
	{
		if (bAllEqps || m_lstEqps.GetCheck(i))
		{
			WORD wNodeID = (WORD)m_lstEqps.GetItemData(i);
			auto pNode = pStation->second.find(wNodeID);
			if (pNode != pStation->second.end())
			{
				cnt += pNode->second.vctAcqID.size();
				for (auto &it : pNode->second.vctAcqID)
				{
					CommData.Push_Data(wNodeID);
					CommData.Push_Data(it);
				}
			}
		}
	}
	if (cnt == 0)
	{
		AfxMessageBox("没有勾选设备, 或者设备没有采集点!");
		return;
	}
	//更新数目
	CommData.Update_Data(nCountIdx, &cnt, sizeof(cnt));

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

	SendClients(CommData, m_strClientIP, m_uPort);
}


void CSimulatorDlg::OnBnClickedButton0x56()
{
	WORD cnt = 0;
	CString strKey;
	strKey.Format("%s:%u", (LPCSTR)m_strClientIP, m_uPort);
	auto pStation = m_mapNodes.find((LPCSTR)strKey);
	if (pStation == m_mapNodes.end())
	{
		AfxMessageBox("站点不存在!");
		return;
	}


	C315CommData CommData;
	//开始组装，清空数据
	CommData.Clear_Data();
	//插入帧头
	CCSM315ProtocolEx::InitFrmHead12B(CommData, FRAME_TYPE_DATA, 0x02);

	CommData.Push_Data((BYTE)E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x56);
	CTime tmBegin;
	m_dtBegin.GetTime(tmBegin);
	CTime tmEnd;
	m_dtEnd.GetTime(tmEnd);

	CommData.Push_Data((DWORD)tmBegin.GetTime());
	CommData.Push_Data((DWORD)tmEnd.GetTime());
	int nCountIdx = CommData.GetDataSize();//数目定位使用
	CommData.Push_Data(cnt);

	bool bAllEqps = IsDlgButtonChecked(IDC_CHECK_ALL_EQP) == BST_CHECKED;
	for (int i = 0; i < m_lstEqps.GetItemCount(); i++)
	{
		if (bAllEqps || m_lstEqps.GetCheck(i))
		{
			cnt++;
			WORD wNodeID = (WORD)m_lstEqps.GetItemData(i);
			CommData.Push_Data(wNodeID);
		}
	}
	if (cnt == 0)
	{
		AfxMessageBox("没有勾选设备!");
		return;
	}
	//更新数目
	CommData.Update_Data(nCountIdx, &cnt, sizeof(cnt));

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

	SendClients(CommData, m_strClientIP, m_uPort);
}


void CSimulatorDlg::OnBnClickedButton0x57()
{
	CString strKey;
	strKey.Format("%s:%u", (LPCSTR)m_strClientIP, m_uPort);
	auto pStation = m_mapNodes.find((LPCSTR)strKey);
	if (pStation == m_mapNodes.end())
	{
		AfxMessageBox("站点不存在!");
		return;
	}

	CTime tmBegin;
	m_dtBegin.GetTime(tmBegin);


	bool bAllEqps = IsDlgButtonChecked(IDC_CHECK_ALL_EQP) == BST_CHECKED;

	for (int i = 0; i < m_lstEqps.GetItemCount(); i++)
	{
		if (bAllEqps || m_lstEqps.GetCheck(i))
		{
			C315CommData CommData;
			//开始组装，清空数据
			CommData.Clear_Data();
			//插入帧头
			CCSM315ProtocolEx::InitFrmHead12B(CommData, FRAME_TYPE_DATA, 0x02);

			CommData.Push_Data((BYTE)E_315_PROTOCOL_TYPE::E_315_PROTOCOL_0x57);
			WORD wNodeID = (WORD)m_lstEqps.GetItemData(i);
			CommData.Push_Data(wNodeID);

			CommData.Push_Data((DWORD)tmBegin.GetTime());

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

			SendClients(CommData, m_strClientIP, m_uPort);
		}
	}
}


void CSimulatorDlg::OnBnClickedButtonRecord()
{
	m_pDlgRecord->ShowWindow(SW_SHOW);
}

#include "DlgParse.h"
void CSimulatorDlg::OnBnClickedButtonParse()
{
	CDlgParse *dlg = new CDlgParse();
	dlg->Create(IDD_DIALOG_PARSE, this);
	dlg->ShowWindow(SW_SHOW);
}