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

#include "stdafx.h"
#include "GeoMative.h"
#include "DialManageLoopTask.h"
#include "afxdialogex.h"
#include "Lock\AutoLock.h"
#include "FileOperTools.h"

// DialManageLoopTask 对话框
extern int g_iUILanguage;
extern CGeoMativeApp theApp;
extern CString Tm2LocalStr(time_t t);
extern float tcp_ntohf(float f);
extern CString Tm2GmtStr(time_t t);
extern int g_iTimeZone;
extern char* U2G(const char* utf8);
extern time_t Str2GmtTm(CString szTime);
#define MODULE_NAME "CDialManageLoopTask"
IMPLEMENT_DYNAMIC(CDialManageLoopTask, CNetRequestDialog)

CDialManageLoopTask::CDialManageLoopTask(CWnd* pParent /*=NULL*/)
	: CNetRequestDialog(CDialManageLoopTask::IDD, pParent)
{
	InitializeCriticalSection(&m_cs);
}

CDialManageLoopTask::~CDialManageLoopTask()
{
	DeleteCriticalSection(&m_cs);
}

void CDialManageLoopTask::DoDataExchange(CDataExchange* pDX)
{
	CNetRequestDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST_LOOP_TASK_LIST, m_LoopTaskList);
	DDX_Control(pDX, IDC_LIST_SUBTASK_LIST, m_subtaskList);
	DDX_Control(pDX, IDC_EDIT_LOOP_TASK_NAME, m_editLoopTaskName);
	DDX_Control(pDX, IDC_EDIT_PLC_ID, m_editPLCID);
	DDX_Control(pDX, IDC_EDIT_GD10_ID, m_editGDID);
	DDX_Control(pDX, IDC_EDIT_LOOP_TYPE, m_editLoopType);
	DDX_Control(pDX, IDC_EDIT_LOOP_COUNT, m_editLoopCount);
	DDX_Control(pDX, IDC_EDIT_TIMER_TYPE, m_editTimerType);
	DDX_Control(pDX, IDC_EDIT_START_TIME, m_editStartTime);
	DDX_Control(pDX, IDC_EDIT_END_TIME, m_editEndTime);
	DDX_Control(pDX, IDC_EDIT_EVERYDAY_START_TIME, m_editEverydayStartTime);
	DDX_Control(pDX, IDC_EDIT_TASK_INTERVAL, m_editTaskInterval);
}


BEGIN_MESSAGE_MAP(CDialManageLoopTask, CNetRequestDialog)
	ON_BN_CLICKED(ID_BTN_DELETE_LOOP_TASK, &CDialManageLoopTask::OnBnClickedBtnDeleteLoopTask)
	ON_BN_CLICKED(IDOK, &CDialManageLoopTask::OnBnClickedOk)
	ON_NOTIFY(NM_CLICK, IDC_LIST_LOOP_TASK_LIST, &CDialManageLoopTask::OnNMClickListLoopTaskList)
	//ON_MESSAGE(WM_GET_TASK_LIST_MSG, OnGetSubListMsg)
END_MESSAGE_MAP()

// CDialManageLoopTask 消息处理程序
BOOL CDialManageLoopTask::OnInitDialog()
{
	CNetRequestDialog::OnInitDialog();	

	CRect rcList;
	m_LoopTaskList.GetClientRect(&rcList);
	m_LoopTaskList.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP | LVS_EX_ONECLICKACTIVATE | LVS_EX_GRIDLINES);
	int width = rcList.right - rcList.left;
	int iColIndex = (int)VAL_ZERO;
	int iColumnNum = 5;
	if (LANG_ZHCN == g_iUILanguage)
	{
		m_LoopTaskList.InsertColumn(iColIndex++, _T("任务名称"), LVCFMT_LEFT, width / iColumnNum);
		m_LoopTaskList.InsertColumn(iColIndex++, _T("任务ID"), LVCFMT_LEFT, width / iColumnNum);
		m_LoopTaskList.InsertColumn(iColIndex++, _T("循环类型"), LVCFMT_LEFT, width / iColumnNum);
		m_LoopTaskList.InsertColumn(iColIndex++, _T("开始时间"), LVCFMT_LEFT, width / iColumnNum);
		m_LoopTaskList.InsertColumn(iColIndex++, _T("结束时间"), LVCFMT_LEFT, width / iColumnNum);

		SetWindowTextA(_T("定时任务管理"));
		m_strLoopTaskNumTips = _T("循环任务数:  ");
		m_strSubloopTaskNumTips = _T("子任务数:  ");
		GetDlgItem(IDC_STATIC_LOOP_NAME_DIS)->SetWindowText(_T("循环任务名："));
		GetDlgItem(IDC_STATIC_GD10_ID)->SetWindowText(_T("主机ID："));
		GetDlgItem(IDC_STATIC_LOOP_TYPE)->SetWindowText(_T("循环类型："));
		GetDlgItem(IDC_STATIC_LOOP_COUNT)->SetWindowText(_T("循环次数："));
		GetDlgItem(IDC_STATIC_LOOP_TIMER)->SetWindowText(_T("定时类型："));
		GetDlgItem(IDC_STATIC_LOOP_START_TIME)->SetWindowText(_T("开始时间："));		
		GetDlgItem(IDC_STATIC_LOOP_END_TIME)->SetWindowText(_T("结束时间："));
		GetDlgItem(IDC_STATIC_EVERY_TIME)->SetWindowText(_T("每天开始时间："));
		GetDlgItem(IDC_STATIC_SUB_TASK_SPACE)->SetWindowText(_T("任务间隔："));
		GetDlgItem(ID_BTN_DELETE_LOOP_TASK)->SetWindowTextA(_T("删除"));
		GetDlgItem(IDOK)->SetWindowTextA(_T("确定"));
	}
	else
	{
		m_strLoopTaskNumTips = _T("loop task number:  ");
		m_strSubloopTaskNumTips = _T("Number of subtasks:  ");

		m_LoopTaskList.InsertColumn(iColIndex++, _T("Task name"), LVCFMT_LEFT, width / iColumnNum);
		m_LoopTaskList.InsertColumn(iColIndex++, _T("Task ID"), LVCFMT_LEFT, width / iColumnNum);
		m_LoopTaskList.InsertColumn(iColIndex++, _T("Loop type"), LVCFMT_LEFT, width / iColumnNum);
		m_LoopTaskList.InsertColumn(iColIndex++, _T("Start time"), LVCFMT_LEFT, width / iColumnNum);
		m_LoopTaskList.InsertColumn(iColIndex++, _T("End time"), LVCFMT_LEFT, width / iColumnNum);
	}

	m_subtaskList.GetClientRect(&rcList);
	m_subtaskList.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP | LVS_EX_ONECLICKACTIVATE | LVS_EX_GRIDLINES);
	width = rcList.right - rcList.left;
	iColIndex = (int)VAL_ZERO;
	iColumnNum = 4;	
	if (LANG_ZHCN == g_iUILanguage)
	{
		m_subtaskList.InsertColumn(iColIndex++, _T("任务名称"), LVCFMT_LEFT, width / iColumnNum);
		m_subtaskList.InsertColumn(iColIndex++, _T("任务ID"), LVCFMT_LEFT, width / iColumnNum);
		m_subtaskList.InsertColumn(iColIndex++, _T("脚本名称"), LVCFMT_LEFT, width / iColumnNum);
		m_subtaskList.InsertColumn(iColIndex++, _T("总点数"), LVCFMT_LEFT, width / iColumnNum);
	}
	else
	{
		m_subtaskList.InsertColumn(iColIndex++, _T("task name"), LVCFMT_LEFT, width / iColumnNum);
		m_subtaskList.InsertColumn(iColIndex++, _T("task ID"), LVCFMT_LEFT, width / iColumnNum);
		m_subtaskList.InsertColumn(iColIndex++, _T("script name"), LVCFMT_LEFT, width / iColumnNum);
		m_subtaskList.InsertColumn(iColIndex++, _T("Total points"), LVCFMT_LEFT, width / iColumnNum);
	}
	GetDlgItem(IDC_STATIC_LOOP_TASK_NUMBER)->SetWindowTextA(m_strLoopTaskNumTips);
	GetDlgItem(IDC_STATIC_SUBTASK)->SetWindowTextA(m_strSubloopTaskNumTips);

	//初始化循环任务列表
	InitLoopTaskList();
	CString strTemp;
	strTemp.Format(_T("SN%u"), m_dwDeviceSN);
	m_editGDID.SetWindowTextA(strTemp);
	strTemp.Format(_T("PLC%u"), m_dwPLCID);
	m_editPLCID.SetWindowTextA(strTemp);
	return TRUE;  // return TRUE unless you set the focus to a control
	// 异常:  OCX 属性页应返回 FALSE
}

void CDialManageLoopTask::OnBnClickedBtnDeleteLoopTask()
{
	// TODO:  在此添加控件通知处理程序代码
	/*while (m_LoopTaskList.GetNextItem(-1, LVNI_ALL | LVNI_SELECTED) != -1)
	{
		int nItem = m_LoopTaskList.GetNextItem(-1, LVNI_ALL | LVNI_SELECTED);
		m_LoopTaskList.DeleteItem(nItem);
	}*/

	CString szListStr,strLog;
	char ucTaskID[MAX_NAME_LEN] = { 0 };
	char chStr[200];
	int iLen = 0;

	POSITION pos = m_LoopTaskList.GetFirstSelectedItemPosition();
	if (pos == NULL)
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("请先选中需要删除的任务"));
		else
			MessageBoxEx(NULL, _T("Please select the task to be deleted first!"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		
		return;
	}
	//theApp.m_NetWorkOper.SetSuspendForThread(true);
	for (int i = 0; i < m_LoopTaskList.GetItemCount(); i++)
	{
		if (m_LoopTaskList.GetItemState(i, LVNI_ALL | LVNI_SELECTED) == LVIS_SELECTED)
		{			
			szListStr = m_LoopTaskList.GetItemText(i, 1);
			m_vtDelLoopTask.push_back(szListStr);
			strncpy(ucTaskID, szListStr, MAX_NAME_LEN* sizeof(BYTE));
			strLog.Format(_T("[%s][%d]:delete loop task request, taskid=%s"), MODULE_NAME, __LINE__, szListStr);
			CFileOperTools::GetInstance()->WriteComLog(strLog);
			PostNetRequest(EN_CANCEL_LOOP_TASK_TRUST, this->m_hWnd, (char*)ucTaskID, MAX_NAME_LEN);
		}
	}

// 	while (pos)
// 	{
// 		m_iCurItemIndex = m_LoopTaskList.GetNextSelectedItem(pos);
// 		szListStr.Empty();
// 		szListStr = m_LoopTaskList.GetItemText(m_iCurItemIndex, 1);
// 		strncpy(ucTaskID, szListStr, MAX_NAME_LEN* sizeof(BYTE));
// 		PostNetRequest(EN_CANCEL_LOOP_TASK_TRUST, this->m_hWnd, (char*)ucTaskID, MAX_NAME_LEN);
// 	}
	//theApp.m_NetWorkOper.SetSuspendForThread(false);

	//清除界面数据
	m_subtaskList.DeleteAllItems();
	SetDlgItemText(IDC_EDIT_LOOP_TASK_NAME, _T(""));
	SetDlgItemText(IDC_EDIT_LOOP_TYPE, _T(""));
	SetDlgItemText(IDC_EDIT_START_TIME, _T(""));
	SetDlgItemText(IDC_EDIT_END_TIME, _T(""));
	SetDlgItemText(IDC_EDIT_LOOP_COUNT, _T(""));
}


void CDialManageLoopTask::OnBnClickedOk()
{
	// TODO:  在此添加控件通知处理程序代码
	CNetRequestDialog::OnOK();
}

void CDialManageLoopTask::OnNMClickListLoopTaskList(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMITEMACTIVATE pNMItemActivate = reinterpret_cast<LPNMITEMACTIVATE>(pNMHDR);
	// TODO:  在此添加控件通知处理程序代码
	if (-1 != pNMItemActivate->iItem)
	{
		SetDlgItemText(IDC_EDIT_LOOP_TASK_NAME, m_LoopTaskList.GetItemText(pNMItemActivate->iItem, 0).GetBuffer());
		SetDlgItemText(IDC_EDIT_TIMER_TYPE, m_LoopTaskList.GetItemText(pNMItemActivate->iItem, 2).GetBuffer());
		SetDlgItemText(IDC_EDIT_START_TIME, m_LoopTaskList.GetItemText(pNMItemActivate->iItem, 3).GetBuffer());
		SetDlgItemText(IDC_EDIT_END_TIME, m_LoopTaskList.GetItemText(pNMItemActivate->iItem, 4).GetBuffer());
		//SetDlgItemText(IDC_EDIT_LOOP_COUNT, m_LoopTaskList.GetItemText(pNMItemActivate->iItem, 5).GetBuffer());

		//更新循环子任务列表
		CString strLoopTaskID = m_LoopTaskList.GetItemText(pNMItemActivate->iItem, 1);

		//AfxBeginThread(GetSubTaskThread, this);

		char   szTaskID[MAX_NAME_LEN] = { 0 };
		strcpy(szTaskID, strLoopTaskID.GetBuffer());
		PostNetRequest(EN_REQ_DOWNLOAD_LOOP_SUB_TABLE, this->m_hWnd, szTaskID, sizeof(szTaskID), 4096);
		CString strLog;
		strLog.Format(_T("[%s][%d]: get loop task args and sub table list request,taskid=%s"), MODULE_NAME, __LINE__, szTaskID);
		CFileOperTools::GetInstance()->WriteComLog(strLog);
	}
	
	*pResult = 0;
}

void CDialManageLoopTask::InitLoopTaskList()
{
	///////////////////////////////////////////////////////同步任务列表////////////////////////////////////////////////
	char chSendStr[210] = { 0 };
	UINT32 uiDevID = m_dwDeviceSN;
	time_t tm;
	m_uiTotalEndTime = (int)time(&tm);
	m_uiTotalEndTime += 3600 * 8;
	m_uiTotalStartTime = m_uiTotalEndTime - 30 * 24 * 3600;

	//按天加载
	UINT32 uiStartTime,uiEndTime;
	uiStartTime = m_uiTotalStartTime;
	uiEndTime = m_uiTotalStartTime + NUMBER_DAYS_LOAD_LOOP_LIST*24 * 3600;
	uiDevID = htonl(uiDevID);
	uiStartTime = htonl(uiStartTime);
	uiEndTime = htonl(uiEndTime);
	memcpy(chSendStr, &uiDevID, sizeof(UINT32));
	memcpy(&chSendStr[sizeof(UINT32)], &uiStartTime, sizeof(UINT32));
	memcpy(&chSendStr[2 * sizeof(UINT32)], &uiEndTime, sizeof(UINT32));
	PostNetRequest(EN_REQ_DOWNLOAD_LOOP_TABLE, this->m_hWnd, chSendStr, 3 * sizeof(UINT32), 1500);
}

void CDialManageLoopTask::PreNetResponse(WPARAM wParam, LPARAM lParam)
{
	LPRESPONSEPACKET pResponsePacket = (LPRESPONSEPACKET)lParam;
	if (pResponsePacket == NULL)
	{
		return;
	}
	switch (pResponsePacket->clsPacketBase.ucCmd)
	{
	case EN_CANCEL_LOOP_TASK_TRUST://删除循环任务响应
	{
		if ((1 > pResponsePacket->wDataLen) || (EN_RECV_SUCCESS != pResponsePacket->pData[0]))
		{
			//theApp.m_NetWorkOper.SetSuspendForThread(false);
			return;
		}
		else
		{
			CString strLog;
			for (int i = 0; i < m_LoopTaskList.GetItemCount(); i++)
			{
				if (m_LoopTaskList.GetItemState(i, LVNI_ALL | LVNI_SELECTED) == LVIS_SELECTED)
				{
					CString strTaskID = m_LoopTaskList.GetItemText(i, 1);
					// 						if (strTaskID.CompareNoCase(m_vtDelItemIndex.at(0)) == 0)
					// 						{
					m_LoopTaskList.DeleteItem(i);
					m_vtDelLoopTask.pop_back();//只用于记录删除的个数，实际弹出的taskID不用管
					//}
					if (m_vtDelLoopTask.size() <= 0)
					{
						if (g_iUILanguage == LANG_ZHCN)
							AfxMessageBox(_T("取消循环任务完成"));
						else
							MessageBoxEx(NULL, _T("Cancel loop task finished."), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
					}
					strLog.Format(_T("[%s][%d]:Loop task List delete select Item response, taskid=%s"), MODULE_NAME, __LINE__, strTaskID);
					CFileOperTools::GetInstance()->WriteComLog(strLog);
					break;
					/*szListStr =
					m_vtDelItemIndex.push_back(szListStr);
					strncpy(ucTaskID, szListStr, MAX_NAME_LEN* sizeof(BYTE));
					strLog.Format(_T("[%s][%d] delete loop taskid=%s"), MODULE_NAME, __LINE__, szListStr);
					CFileOperTools::GetInstance()->WriteComLog();
					PostNetRequest(EN_CANCEL_LOOP_TASK_TRUST, this->m_hWnd, (char*)ucTaskID, MAX_NAME_LEN);*/
				}
			}
			// 				for (int i = 0; i < m_LoopTaskList.GetItemCount(); i++)
			// 				{
			// 					m_LoopTaskList.DeleteItem(m_iCurItemIndex);
			// 				}				

			//theApp.m_NetWorkOper.SetSuspendForThread(false);

			//清除界面数据
			m_subtaskList.DeleteAllItems();
			SetDlgItemText(IDC_EDIT_LOOP_TASK_NAME, _T(""));
			SetDlgItemText(IDC_EDIT_LOOP_TYPE, _T(""));
			SetDlgItemText(IDC_EDIT_START_TIME, _T(""));
			SetDlgItemText(IDC_EDIT_END_TIME, _T(""));
			SetDlgItemText(IDC_EDIT_LOOP_COUNT, _T(""));
		}
	}
	break;
	case EN_REQ_DOWNLOAD_LOOP_SUB_TABLE:
	{
		GetSubLoopListResponse(wParam, lParam);
	}
	break;
	case EN_REQ_DOWNLOAD_TASK_ARG:
	{
		UINT32 *uiRevData  = (UINT32*)(pResponsePacket->pData);
		UINT32 uiRevDataNum = ntohl(uiRevData[0]);
		if ((uiRevDataNum < 1) || (pResponsePacket->wDataLen < (sizeof(UINT32) + uiRevDataNum * sizeof(STRemTaskArg))))
		{
			//theApp.m_NetWorkOper.SetSuspendForThread(false);
			return;
		}
		//pThis->SendMessage(WM_GET_TASK_LIST_MSG, (WPARAM)chMsgSyn, iLen);

		CString str;
		/*if ((uiRevDataNum < 1) || (iLen < (sizeof(UINT32) + uiRevDataNum * sizeof(STRemTaskArg))))
		{
		theApp.m_NetWorkOper.SetSuspendForThread(false);
		return 0;
		}*/
		/*if (0 == m_stLoopTaskInfo.ucContrlType)
		{
		m_editLoopType.SetWindowTextA((LPCTSTR)(_bstr_t)_T("次数循环"));
		}
		else
		{
		m_editLoopType.SetWindowTextA((LPCTSTR)(_bstr_t)_T("定时循环"));
		}
		int iStartMin = m_stLoopTaskInfo.uiStartMin - 60 * g_iTimeZone;
		if (iStartMin < 0)
		{
		iStartMin += 24 * 60;  //格林威治时间是前一天了
		}
		if (iStartMin > 24 * 60)
		{
		iStartMin -= 24 * 60;  //格林威治时间是后一天了
		}
		str.Empty(); str.Format(_T("%2d:%2d:00"), iStartMin /60, iStartMin % 60);
		m_editEverydayStartTime.SetWindowTextA(str);
		str.Empty(); str.Format(_T("%2d:%2d:00"), m_stLoopTaskInfo.uiTaskSpace/60, m_stLoopTaskInfo.uiTaskSpace%60);
		m_editTaskInterval.SetWindowTextA(str);
		*/

		STRemTaskArg * ptTaskArg = (STRemTaskArg *)((char *)pResponsePacket->pData + sizeof(UINT32));
		int iIndex = (int)VAL_ZERO;

		//m_subtaskList.DeleteAllItems();  
		int iExtNum = m_subtaskList.GetItemCount();//已存在的行数
		str.Empty(); 
		str.Format("%s%u", m_strSubloopTaskNumTips, iExtNum + uiRevDataNum);
		GetDlgItem(IDC_STATIC_SUBTASK)->SetWindowTextA(str);
		for (iIndex = 0; iIndex < uiRevDataNum; iIndex++)
		{
			m_subtaskList.InsertItem(iIndex + iExtNum, _T(""));
			m_subtaskList.SetItemText(iIndex + iExtNum, 0, U2G(ptTaskArg[iIndex].ucTDName));
			m_subtaskList.SetItemText(iIndex + iExtNum, 1, ptTaskArg[iIndex].ucTaskID);
			m_subtaskList.SetItemText(iIndex + iExtNum, 2, U2G(ptTaskArg[iIndex].ucSciptName));
			str.Empty(); str.Format("%u", ntohl(ptTaskArg[iIndex].uiTotalNum));
			m_subtaskList.SetItemText(iIndex + iExtNum, 3, str);
		}
	}
	break;
	case EN_REQ_DOWNLOAD_LOOP_TABLE:
	{
		GetLoopListResponse(wParam, lParam);
	}
	break;
	default:
		break;
	}
}
void CDialManageLoopTask::GetSubLoopListResponse(WPARAM wParam, LPARAM lParam)
{
	CString strLog;
	LPRESPONSEPACKET pResponsePacket = (LPRESPONSEPACKET)lParam;
	if (NULL == pResponsePacket || pResponsePacket->clsPacketBase.ucCmd != EN_REQ_DOWNLOAD_LOOP_SUB_TABLE)
	{
		strLog.Format(_T("[%s][%d]: NULL == pResponsePacket || pResponsePacket->clsPacketBase.ucCmd != EN_REQ_DOWNLOAD_LOOP_SUB_TABLE"), MODULE_NAME, __LINE__);
		CFileOperTools::GetInstance()->WriteComLog(strLog);
		return;
	}
	
	CString strTaskID;
	CStringArray szArrayID;
	STLoopTaskInfo stLoopTaskInfo;
	STLoopTaskInfo *pstLoopTaskInfo = &stLoopTaskInfo;
	char *pcTaskID = NULL;
	int uiSubTaskNum = 0;
	pstLoopTaskInfo = (STLoopTaskInfo *)pResponsePacket->pData;
	uiSubTaskNum = ntohl(pstLoopTaskInfo->uiSubTaskNum);
	if (pResponsePacket->wDataLen < (sizeof(STLoopTaskInfo) + uiSubTaskNum*sizeof(pstLoopTaskInfo->ucTaskID)))
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("查看循环任务信息失败,数据长度错误"));
		else
			MessageBoxEx(NULL, _T("Failed to view loop task information, data length error."), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));

		strLog.Format(_T("[%s][%d]: pResponsePacket->wDataLen=%d < (sizeof(STLoopTaskInfo) + uiSubTaskNum*sizeof(pstLoopTaskInfo->ucTaskID))=%d"), MODULE_NAME, __LINE__, strLog, pResponsePacket->wDataLen, sizeof(STLoopTaskInfo) + uiSubTaskNum*sizeof(pstLoopTaskInfo->ucTaskID));
		CFileOperTools::GetInstance()->WriteComLog(strLog);
		//theApp.m_NetWorkOper.SetSuspendForThread(false);
		return;
	}
	// 		char   szTaskID[MAX_NAME_LEN] = { 0 };
	// 		if (0 != memcmp(szTaskID, pstLoopTaskInfo->ucTaskID, sizeof(pstLoopTaskInfo->ucTaskID)))
	// 		{
	// 			AfxMessageBox(_T("Synchronization loop sub task table to failed. Receiv loop task name is error."));
	// 			//theApp.m_NetWorkOper.SetSuspendForThread(false);
	// 			return;
	// 		}

	//memcpy(&pThis->m_stLoopTaskInfo, &pstLoopTaskInfo, sizeof(STLoopTaskInfo));//拷贝给显示框用
	//显示未显示的循环任务详细信息	
	CString strEverydayStartTime;
	CString strTaskInterval;
	CString strLoopNum;
	if (0 == pstLoopTaskInfo->ucContrlType)
	{
		if (LANG_ZHCN == g_iUILanguage)
			m_editLoopType.SetWindowTextA((LPCTSTR)(_bstr_t)_T("次数循环"));
		else
			m_editLoopType.SetWindowTextA((LPCTSTR)(_bstr_t)_T("Number of cycles"));
	}
	else
	{
		if (LANG_ZHCN == g_iUILanguage)
			m_editLoopType.SetWindowTextA((LPCTSTR)(_bstr_t)_T("定时循环"));
		else
			m_editLoopType.SetWindowTextA((LPCTSTR)(_bstr_t)_T("Timer of cycles"));
	}
	int iStartMin = ntohl(pstLoopTaskInfo->uiStartMin) + 60 * g_iTimeZone;
	if (iStartMin < 0)
	{
		iStartMin += 24 * 60;  //格林威治时间是前一天了
	}
	if (iStartMin > 24 * 60)
	{
		iStartMin -= 24 * 60;  //格林威治时间是后一天了
	}
	strEverydayStartTime.Format(_T("%2d:%2d:00"), iStartMin / 60, iStartMin % 60);
	m_editEverydayStartTime.SetWindowTextA(strEverydayStartTime);

	strTaskInterval.Format(_T("%2d:%2d:%2d"), ntohl(pstLoopTaskInfo->uiTaskSpace) / 60 / 60 % 60, ntohl(pstLoopTaskInfo->uiTaskSpace) / 60 % 60, ntohl(pstLoopTaskInfo->uiTaskSpace) % 60);
	m_editTaskInterval.SetWindowTextA(strTaskInterval);

	strLoopNum.Format(_T("%d/%d"),ntohs(pstLoopTaskInfo->uiRemainLoopNum), ntohs(pstLoopTaskInfo->uiLoopNum));
	m_editLoopCount.SetWindowTextA(strLoopNum);

	//取子任务名字
	pcTaskID = (char*)&pResponsePacket->pData[sizeof(STLoopTaskInfo)];
	for (int j = 0; j < uiSubTaskNum; j++)
	{
		strTaskID.Empty();
		char *pcTemTaskID = (char*)&pcTaskID[sizeof(char)* MAX_NAME_LEN * j];
		char ucTaskId[40] = { 0 };
		strncpy(ucTaskId, pcTemTaskID, sizeof(char)* MAX_NAME_LEN);
		//memcpy(&strTaskID, pcTaskID, sizeof(char) * 40);
		strTaskID += ucTaskId;
		szArrayID.Add(strTaskID);
	}
	//写入数据库
	strLog.Format(_T("[%s][%d]: get loop task args and sub table list response,pstLoopTaskInfo->ucContrlType=%d,strEverydayStartTime=%s,strTaskInterval=%s,strLoopNum=%s"), MODULE_NAME, __LINE__, pstLoopTaskInfo->ucContrlType, strEverydayStartTime, strTaskInterval, strLoopNum);
	CFileOperTools::GetInstance()->WriteComLog(strLog);


	//查询子任务信息
	//int iListIndex = m_SevTdList.GetItemCount();
	GetDlgItem(IDC_STATIC_SUBTASK)->SetWindowTextA(m_strSubloopTaskNumTips);
	m_subtaskList.DeleteAllItems();
	UINT32 uiGetTaskNum = 5;//5个任务获取一次，减少交互
	UINT32 uiSubNum = htonl(uiGetTaskNum);
	UINT32 *uiRevData = NULL;
	STRemTaskArg * ptTaskArg = NULL;
	char chMsgSyn[2048] = { 0 };
	//char   szTaskID[MAX_NAME_LEN] = { 0 };
	memset(chMsgSyn, 0, sizeof(chMsgSyn));
	int iStartNum = 0;
	for (int j = 0; j < uiSubTaskNum; j++)
	{
		strncpy(&chMsgSyn[4 + (j-iStartNum)*MAX_NAME_LEN], szArrayID.GetAt(j), MAX_NAME_LEN*sizeof(BYTE));
		if (j != 0 && ((j + 1) % uiGetTaskNum == 0))
		{
			uiSubNum = uiGetTaskNum;
		}
		else if (j + 1 == uiSubTaskNum)
		{
			uiSubNum = uiSubTaskNum - iStartNum;
		}
		else
		{
			continue;
		}
		int iSendLen = sizeof(UINT32) + sizeof(BYTE)*MAX_NAME_LEN*uiSubNum;
		uiSubNum = htonl(uiSubNum);
		memcpy(chMsgSyn, &uiSubNum, sizeof(UINT32));
		iStartNum = j + 1;

		PostNetRequest(EN_REQ_DOWNLOAD_TASK_ARG, this->m_hWnd, chMsgSyn, iSendLen);
		memset(chMsgSyn, 0, sizeof(chMsgSyn));
	}
}

void CDialManageLoopTask::GetLoopListResponse(WPARAM wParam, LPARAM lParam)
{
	LPRESPONSEPACKET pResponsePacket = (LPRESPONSEPACKET)lParam;
	if (pResponsePacket == NULL || pResponsePacket->clsPacketBase.ucCmd != EN_REQ_DOWNLOAD_LOOP_TABLE)
	{
		return;
	}
	STLoopTaskTable *pstLoopTask = NULL;
	STLoopTaskTable stLoopTask;
	CString strTaskID;
	UINT32 uiLoopTaskNum = 0;
	memcpy(&uiLoopTaskNum, pResponsePacket->pData, sizeof(uiLoopTaskNum));
	uiLoopTaskNum = ntohl(uiLoopTaskNum);
	for (int i = 0; i < uiLoopTaskNum; i++)
	{
		pstLoopTask = (STLoopTaskTable*)&pResponsePacket->pData[sizeof(uiLoopTaskNum) + i*sizeof(STLoopTaskTable)];
		strTaskID.Empty();
		strTaskID += pstLoopTask->ucTaskID;
		if (strTaskID.FindOneOf("LOOP") == -1)
		{
			continue;
		}
		memcpy(stLoopTask.ucTaskID, pstLoopTask->ucTaskID, MAX_NAME_LEN);
		memcpy(stLoopTask.ucTaskName, pstLoopTask->ucTaskName, MAX_NAME_LEN);
		stLoopTask.uiStartTime = ntohl(pstLoopTask->uiStartTime);
		stLoopTask.uiEndTime = ntohl(pstLoopTask->uiEndTime);
		stLoopTask.ucLoopType = pstLoopTask->ucLoopType;
		m_mapSaveLoopList[pstLoopTask->ucTaskName] = stLoopTask;
	}

	char chSendStr[210] = { 0 };
	UINT32 uiDevID = m_dwDeviceSN;
	CTime clsStart(m_uiTotalStartTime);
	CTime clsStop(m_uiTotalEndTime);
	CTimeSpan timeSpan1 = clsStop - clsStart;
	int iDay = timeSpan1.GetDays();
	if (iDay > 1)
	{
		CTimeSpan ts(NUMBER_DAYS_LOAD_LOOP_LIST, 0, 0, 0); // 加5天
		clsStart = clsStart + ts;
		CString date = clsStart.Format("%Y-%m-%d %H:%M:%S ");
		m_uiTotalStartTime = Str2GmtTm(date);
		
		time_t uiStartTime, uiEndTime;
		uiStartTime = m_uiTotalStartTime;
		uiEndTime = m_uiTotalStartTime + NUMBER_DAYS_LOAD_LOOP_LIST * 24 * 3600 + 3600;//3600预留一小时,客户端与服务器偏差时间
		CString strLog;
		strLog.Format(_T("zm:CDialManageLoopTask::GetLoopListResponse request start time：%s,end time=%s\n"), Tm2LocalStr(uiStartTime), Tm2LocalStr(uiEndTime));
		CFileOperTools::GetInstance()->WriteComLog(strLog);
		uiDevID = htonl(uiDevID);
		uiStartTime = htonl(uiStartTime);
		uiEndTime = htonl(uiEndTime);
		memcpy(chSendStr, &uiDevID, sizeof(UINT32));
		memcpy(&chSendStr[sizeof(UINT32)], &uiStartTime, sizeof(UINT32));
		memcpy(&chSendStr[2 * sizeof(UINT32)], &uiEndTime, sizeof(UINT32));
		PostNetRequest(EN_REQ_DOWNLOAD_LOOP_TABLE, this->m_hWnd, chSendStr, 3 * sizeof(UINT32), 4096);
	}
	else
	{
		//显示循环列表
		ShowLoopList();
	}
}

void CDialManageLoopTask::ShowLoopList()
{
	int iItemCount = m_mapSaveLoopList.size();
	if (iItemCount <= 0)
		return;

	CString strTemp;
	UINT32 uiLoopTaskNum = 0;
	strTemp.Format(_T("%s%d"), m_strLoopTaskNumTips, iItemCount);
	GetDlgItem(IDC_STATIC_LOOP_TASK_NUMBER)->SetWindowTextA(strTemp);
	
	std::map<CString, STLoopTaskTable>::iterator iter = m_mapSaveLoopList.begin();
	for (int i = 0; iter != m_mapSaveLoopList.end(); iter++,i++)
	{
		m_LoopTaskList.InsertItem(i, _T(""));
		m_LoopTaskList.SetItemText(i, 0, U2G(iter->second.ucTaskName));
		m_LoopTaskList.SetItemText(i, 1, iter->second.ucTaskID);
		if (0 == iter->second.ucLoopType)
		{
			if (LANG_ZHCN == g_iUILanguage)
				m_LoopTaskList.SetItemText(i, 2, _T("次数循环"));
			else
				m_LoopTaskList.SetItemText(i, 2, _T("Number of cycles"));

		}
		else
		{
			if (LANG_ZHCN == g_iUILanguage)
				m_LoopTaskList.SetItemText(i, 2, _T("定时循环"));
			else
				m_LoopTaskList.SetItemText(i, 2, _T("Timer of cycles"));
		}
		strTemp = Tm2LocalStr(iter->second.uiStartTime);
		m_LoopTaskList.SetItemText(i, 3, (LPCTSTR)(_bstr_t)strTemp);
		strTemp = Tm2LocalStr(iter->second.uiEndTime);
		m_LoopTaskList.SetItemText(i, 4, (LPCTSTR)(_bstr_t)strTemp);
	}
}