// TaskProgressDlg.cpp : implementation file
//

#include "stdafx.h"
#include "GeoMative.h"
#include "DownloadDataProgressDlg.h"
#include "Lock\AutoLock.h"
#include "FileOperTools.h"

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

extern int g_iUILanguage;
extern CGeoMativeApp theApp;
extern float tcp_ntohf(float f);
/////////////////////////////////////////////////////////////////////////////
// CDownloadDataProgressDlg dialog

CDownloadDataProgressDlg::CDownloadDataProgressDlg(std::vector<STTaskListItem> *pvtDownloadTaskItem, CTaskDataOper*  pTaskOper, CWnd* pParent)
: CDialog(CDownloadDataProgressDlg::IDD, pParent)
{
	m_pvtDownloadTaskItem = pvtDownloadTaskItem;
	m_pTaskOper = pTaskOper;
	m_bRecvOrSend = 0;
	//InitializeCriticalSection(&m_cs);
}

CDownloadDataProgressDlg::CDownloadDataProgressDlg(STRemTaskArg* stTaskArg, CTaskDataOper*  pTaskOper, CWnd* pParent) : CDialog(CDownloadDataProgressDlg::IDD, pParent)
{
	m_stTaskArg = stTaskArg;
	m_pTaskOper = pTaskOper;
	m_pParent   = pParent;
	m_bRecvOrSend = 1;
	//InitializeCriticalSection(&m_cs);
}

CDownloadDataProgressDlg::~CDownloadDataProgressDlg()
{
	//DeleteCriticalSection(&m_cs);
}

BEGIN_MESSAGE_MAP(CDownloadDataProgressDlg, CDialog)
	//{{AFX_MSG_MAP(CDownloadDataProgressDlg)

	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CDownloadDataProgressDlg message handlers

BOOL CDownloadDataProgressDlg::OnInitDialog()
{
	CDialog::OnInitDialog();
	
	// TODO: Add extra initialization here
	if (LANG_ZHCN == g_iUILanguage)
	{
		if (0 == m_bRecvOrSend)//下载数据
		{
			GetDlgItem(IDC_STATIC_SHOW_TIP)->SetWindowText(_T(" 正在下载数据, 请等待并且不要操作程序....."));
		}
		else
		{
			GetDlgItem(IDC_STATIC_SHOW_TIP)->SetWindowText(_T(" 正在上传文件, 请等待并且不要操作程序....."));
		}
	}
		
	if (0 == m_bRecvOrSend)//下载数据
	{
		AfxBeginThread(DownloadThread, this);
	}
	else
	{
		AfxBeginThread(UploadThread, this);
	}
	
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

#define MAX_DOWNLOAD_POINT_NUM		(50)
#define CALL_PROCESS_POINS_NUM		(5)
void CDownloadDataProgressDlg::ShowProcessPercent(int iCurPos, int iTotalSize)
{
	int iStep = (iCurPos + 1) / (iTotalSize * CALL_PROCESS_POINS_NUM * 1.0) * 100;
	CString strTemp;
	strTemp.Format("%d", iStep);
	if (iStep > 100)
	{
		iStep = 100;
	}
	strTemp += "%";
	GetDlgItem(IDC_TASK_PERCENT)->SetWindowTextA(strTemp);
	Sleep(500);
}

//增加勾选单个任务下载进度
UINT CDownloadDataProgressDlg::DownloadThread(LPVOID pParam)
{
	CDownloadDataProgressDlg* pThis = (CDownloadDataProgressDlg*)pParam;
	if (NULL == pThis)
	{
		pThis->SendMessage(WM_CLOSE, 0, 0);
		return 0;
	}

	int iTaskCount = pThis->m_pvtDownloadTaskItem->size();
	if (iTaskCount <= 0)
	{
		pThis->SendMessage(WM_CLOSE, 0, 0);
		return 0;
	}

	int iRet = 0;
	int iStep = 0;
	int iPosIndex = 0;
	CString strTemp;
	STTaskListItem *pstTaskInfo = NULL;
	STRemTaskTable *pstTaskTable = NULL;
	STRemTaskArg stTaskArg;
	DWORD dwTdID;
	char *pRg = NULL,*pElecInfo = NULL;
	BOOL bTaskExistFlg,bElecInfoExist;
	DWORD dwTotalElec;
	STQueryTaskBasicInfo stTaskBasicInfo;
	char *pData = NULL;
	int i = 1;
	UINT32 uiStartPoint = 1;
	UINT32 uiEndPoint;
	int iSendCount;
	UINT32 iTotalPoint;
	STTaskDataRes *ptTaskData = NULL;
	STMeasuDataResBasic stMeasuBasicData;
	STTaskDataRes stTaskDataRes;
	int j;

	CString szDevSN;
	szDevSN.Format(_T("SN%u"), pThis->m_dwDeviceSN);

	for (int iTaskIndex = 0; iTaskIndex < pThis->m_pvtDownloadTaskItem->size(); iTaskIndex++)
	{
		iRet = 0;
		do
		{
			pstTaskInfo = &pThis->m_pvtDownloadTaskItem->at(iTaskIndex);//只勾选一个,分开处理
			pstTaskTable = (STRemTaskTable *)pstTaskInfo;
			memset(&stTaskArg, 0, sizeof(STRemTaskArg));
			if (!pThis->m_pTaskOper->QueryOnLineTdAttrFromSev(*pstTaskTable, &stTaskArg))//任务参数获取
			{
				break;
			}
			pThis->ShowProcessPercent(iPosIndex++, iTaskCount);

			//如果是未测试完成的任务，直接不下载RG值
			pRg = NULL;
			if (pstTaskInfo->byTestStatus == EN_TASK_STATE_FINISH && stTaskArg.ucTestGRFlag)
			{
				pRg = (char*)malloc(14044); //支持1000个电极//pRg = (char*)malloc(sizeof(char) * 2700);
				if (!pThis->m_pTaskOper->QueryOnLineTdRgFromSev(stTaskArg, pRg))//接地电阻获取
				{
					if (NULL != pRg)
					{
						free(pRg);
						pRg = NULL;
					}
					//return false;
				}
			}

			//判断任务是否存在
			dwTdID = 0;
			bTaskExistFlg = theApp.m_pTdManager->OnlineCheckTdExist(pstTaskTable->ucTaskID, szDevSN, &dwTdID);
			dwTotalElec = stTaskArg.uiEndElec - stTaskArg.uiStartElec + 1;
			if (!bTaskExistFlg)
			{
				// 				std::vector<CString> vtTaskID;
				// 				vtTaskID.push_back(stTaskArg.ucTaskID);
				// 				pThis->m_pTaskOper->DeleteTaskArray(vtTaskID);
				theApp.m_pTdManager->OnlineSevTDListSynToDB(&stTaskArg, szDevSN);		//更新任务参数信息	
				if (NULL != pRg && EN_TASK_YES_SYN == pstTaskInfo->eSynStatus)
				{
					char* pData = NULL;
					for (int i = 0; i < dwTotalElec; i++)
					{
						pData = (&pRg[MAX_NAME_LEN+ sizeof(UINT32) + i*sizeof(STMeasuSigGRResult)]);
						pThis->m_pTaskOper->UpdateGrData(dwTdID, pData, stTaskArg.stMeasuArg.ucSptType, 1);
					}
				}
			}
			else
			{
				dwTdID = theApp.m_pTdManager->OnLineImportTdHeadToDB(&stTaskArg, szDevSN);//新建任务并插入任务参数信息
				if (NULL != pRg)
				{
					pThis->m_pTaskOper->InsertGrData(dwTdID, dwTotalElec, &pRg[MAX_NAME_LEN + sizeof(UINT32)], stTaskArg.stMeasuArg.ucSptType);
				}
			}
			if (NULL != pRg)
			{
				free(pRg);
			}
			pThis->ShowProcessPercent(iPosIndex++, iTaskCount);

			pThis->m_pTaskOper->QueryTdBasicInfo(dwTdID, &stTaskBasicInfo);
			pThis->ShowProcessPercent(iPosIndex++, iTaskCount);

			//下载电极坐标信息
			//目前只有新增的跨孔装置和跨孔AM装置需要上传电极坐标信息
			if (AR_CROSS_HOLE_GEOMATIVE == stTaskArg.stMeasuArg.ucArrayType
				|| AR_CROSS_HOLE_GEOMATIVE_AM == stTaskArg.stMeasuArg.ucArrayType)
			{
				bElecInfoExist = theApp.m_pTdManager->OnlineCheckElecInfoExist(stTaskBasicInfo.ucTaskID, _T(""));
				if (bElecInfoExist)//不存在
				{
					//请求云端电极坐标信息
					pElecInfo = (char*)malloc(sizeof(char) * 20080);//允许一次传1000根电极的信息
					if (pThis->m_pTaskOper->QueryOnLineElecInfoFromSev(stTaskArg, pElecInfo))//电极坐标信息获取
					{
						if (NULL != pElecInfo)
						{
							float* pfMaxWellDepth = (float*)(&pElecInfo[MAX_NAME_LEN * 2]);
							UINT32* pTotalElec = (UINT32*)(&pElecInfo[MAX_NAME_LEN * 2 + sizeof(float)]);
							UINT32 uiRecElenNum = ntohl(*pTotalElec);
							dwTdID = pThis->m_pTaskOper->InsertCoordinatesData(stTaskArg.ucTaskID, uiRecElenNum, &pElecInfo[MAX_NAME_LEN * 2 + sizeof(UINT32)+sizeof(float)], *pfMaxWellDepth);//新建任务并插入任务参数信息
						}
						//return false;
					}

					if (pElecInfo != NULL)
					{
						free(pElecInfo);
						pElecInfo = NULL;

					}
				}				
			}
			pThis->ShowProcessPercent(iPosIndex++, iTaskCount);

			pData = (char*)malloc(sizeof(char) * 4095);

			uiStartPoint = 1;
			for (i = 1; i < stTaskArg.uiTotalNum + 1; i++)
			{
				if (i%MAX_DOWNLOAD_POINT_NUM == 0)
				{
					uiEndPoint = i;
				}
				else if (i == stTaskArg.uiTotalNum)
				{
					uiEndPoint = stTaskArg.uiTotalNum; // -uiStartPoint + 1;
				}
				else
				{
					continue;
				}

				for (iSendCount = 0; iSendCount < 3; iSendCount++) //失败重新下载三次
				{
					if (pThis->m_pTaskOper->QueryOnLineTdDataFromSev(stTaskArg, uiStartPoint, uiEndPoint, pData))
					{
						break;
					}
					Sleep(200);
				}
				if (iSendCount>=3)//下载三次失败退出下载
				{					
					if (LANG_ZHCN == g_iUILanguage)
						iRet = AfxMessageBox(_T("是否终止下载?"),MB_YESNO);
					else
						iRet = MessageBoxEx(NULL, _T("Whether to terminate download?"), STRING_MESSAGEBOXEX_TITLE, MB_YESNO, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
					if (IDYES == iRet)
					{
						pThis->SendMessage(WM_CLOSE, 0, 0); 
						return 1;
					}

					if (NULL != pData)
					{
						free(pData);
						pData = NULL;
					}
					break;
					//return false;
				}

				iTotalPoint = uiEndPoint - uiStartPoint + 1;
				for (j = 0; j < iTotalPoint; j++)
				{
					if (!bTaskExistFlg)//if (FALSE)
					{
						ptTaskData = (STTaskDataRes *)(pData + MAX_NAME_LEN * sizeof(BYTE) + sizeof(UINT32) + j*sizeof(STTaskDataRes));
						stMeasuBasicData.iID = ntohl(ptTaskData->dwID);
						stMeasuBasicData.fV = tcp_ntohf(ptTaskData->fV);
						stMeasuBasicData.fI = tcp_ntohf(ptTaskData->fI);
						stMeasuBasicData.fR0 = tcp_ntohf(ptTaskData->fR0);
						stMeasuBasicData.fSP = tcp_ntohf(ptTaskData->fSP);
						stMeasuBasicData.fK = tcp_ntohf(ptTaskData->fK);
						stMeasuBasicData.ucAlram = ptTaskData->ucAlram;
						stMeasuBasicData.ucStack = ptTaskData->ucStack;
						stMeasuBasicData.fR0_LC = tcp_ntohf(ptTaskData->fR0_LC);
						int iAttachLen = (1 == stTaskArg.stMeasuArg.ucTestType) ? sizeof(STMeasuDataResAttachIP) : 0;
						pThis->m_pTaskOper->UpdateTdBasicData(stTaskArg.stMeasuArg.ucSptType, stTaskArg.stMeasuArg.ucTestType, \
							stTaskBasicInfo.iTdChannelID, stMeasuBasicData.iID, &stMeasuBasicData, ptTaskData + 1 + (j + 1)*sizeof(STMeasuDataResBasic) + j*iAttachLen);
					}
					else
					{
						ptTaskData = (STTaskDataRes *)(pData + MAX_NAME_LEN * sizeof(BYTE) + sizeof(UINT32) + j*sizeof(STTaskDataRes));
						stTaskDataRes.dwID = ntohl(ptTaskData->dwID);
						stTaskDataRes.fA = tcp_ntohf(ptTaskData->fA);
						stTaskDataRes.fB = tcp_ntohf(ptTaskData->fB);
						stTaskDataRes.fM = tcp_ntohf(ptTaskData->fM);
						stTaskDataRes.fN = tcp_ntohf(ptTaskData->fN);
						stTaskDataRes.fK = tcp_ntohf(ptTaskData->fK);
						stTaskDataRes.fV = tcp_ntohf(ptTaskData->fV);
						stTaskDataRes.fI = tcp_ntohf(ptTaskData->fI);
						stTaskDataRes.fR0 = tcp_ntohf(ptTaskData->fR0);
						stTaskDataRes.fSP = tcp_ntohf(ptTaskData->fSP);
						stTaskDataRes.fK = tcp_ntohf(ptTaskData->fK);
						stTaskDataRes.ucAlram = ptTaskData->ucAlram;
						stTaskDataRes.ucStack = ptTaskData->ucStack;
						stTaskDataRes.fR0_LC = tcp_ntohf(ptTaskData->fR0_LC);
						pThis->m_pTaskOper->OnlineDownloadRes2DData(stTaskArg.stMeasuArg.ucSptType, &stTaskDataRes, stTaskBasicInfo.iTdChannelID);
					}
				}
				uiStartPoint = i + 1;
			}
			if (NULL != pData)
			{
				free(pData);
			}
			iRet = 1;
			pThis->ShowProcessPercent(iPosIndex++, iTaskCount);
		} while (FALSE);

		if (iRet == 0)
		{
			if (!theApp.m_NetWorkOper.GetLinkStatus())
			{
				if (g_iUILanguage == LANG_ZHCN)
					AfxMessageBox(_T("请查看网络是否断开"));
				else
					MessageBoxEx(NULL, _T("Check to see if the network is disconnected"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
				pThis->SendMessage(WM_CLOSE, 0, 0);
				return 0;
			}	
			else
			{
				if (g_iUILanguage == LANG_ZHCN)
					AfxMessageBox(_T("下载任务失败"));
				else
					MessageBoxEx(NULL, _T("Download task failed"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
			}
		}
	}
	
	if (g_iUILanguage == LANG_ZHCN)
		AfxMessageBox(_T("下载数据完成"));
	else
		MessageBoxEx(NULL, _T("Download data complete"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));

	pThis->SendMessage(WM_CLOSE, 0, 0);
	return 0;
}

UINT CDownloadDataProgressDlg::UploadThread(LPVOID pParam)
{
	CDownloadDataProgressDlg* pThis = (CDownloadDataProgressDlg*)pParam;
	if (pThis == NULL)
	{
		pThis->SendMessage(WM_CLOSE, 0, 0);
		return 0;
	}

	//Sleep(1000);
	DWORD dwTdID = atoi(pThis->m_stTaskArg->ucTaskID);
	//int iRet = pThis->m_pTaskOper->OnlineUploadRes2DTask(iTaskId);
	
	int iRet = 0;
	CString strLog = _T("");
	STQueryTaskBasicInfo stQueryTdInfo;	
	do 
	{
		memset(stQueryTdInfo.szTaskName, 0, sizeof(stQueryTdInfo.szTaskName));
		memset(stQueryTdInfo.ucTaskID, 0, sizeof(stQueryTdInfo.ucTaskID));
		iRet = pThis->m_pTaskOper->QueryTdBasicInfo(dwTdID, &stQueryTdInfo);
		if (iRet == FALSE)
		{
			strLog.Format(_T("[%s][%d]Query task information failed. taskid = %d"), dwTdID);
			CFileOperTools::GetInstance()->WriteComLog(strLog);
			if (LANG_ZHCN == g_iUILanguage)
				AfxMessageBox(_T("查询任务信息失败"));
			else
				MessageBoxEx(NULL, _T("Query task information failed"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
			break;
		}
		pThis->GetDlgItem(IDC_TASK_PERCENT)->SetWindowTextA(_T("20%"));
		Sleep(500);

		iRet = pThis->m_pTaskOper->OnlineUploadRes2DArg(dwTdID, stQueryTdInfo);
		if (iRet == FALSE)//upload  parameter
		{
			break;
		}
		pThis->GetDlgItem(IDC_TASK_PERCENT)->SetWindowTextA(_T("40%"));
		Sleep(500);

		iRet = pThis->m_pTaskOper->OnlineUploadRes2DRg(dwTdID, stQueryTdInfo);
		if (FALSE == iRet)//upload  Rg
		{
			break;;
		}
		pThis->GetDlgItem(IDC_TASK_PERCENT)->SetWindowTextA(_T("60%"));
		Sleep(500);

		//目前只有新增的跨孔装置和跨孔AM装置需要上传电极坐标信息
		if (AR_CROSS_HOLE_GEOMATIVE == stQueryTdInfo.iAR
			|| AR_CROSS_HOLE_GEOMATIVE_AM == stQueryTdInfo.iAR)
		{
			iRet = pThis->m_pTaskOper->UploadElecCoordinatesInfo(dwTdID, stQueryTdInfo);
			if (FALSE == iRet)//upload  
			{
				break;;
			}
			pThis->GetDlgItem(IDC_TASK_PERCENT)->SetWindowTextA(_T("70%"));
			Sleep(500);
		}		

		iRet = pThis->m_pTaskOper->OnlineUploadRes2DData(dwTdID, stQueryTdInfo);
		if (FALSE == iRet)//upload  point data
		{
			break;;
		}
		pThis->GetDlgItem(IDC_TASK_PERCENT)->SetWindowTextA(_T("80%"));
		Sleep(500);

		int i = (int)VAL_ZERO;
		HTREEITEM hChild;
		CString szName_Status;
		_CommandPtr pCmdIns = NULL;
		pCmdIns.CreateInstance(_uuidof(Command));
		pCmdIns->ActiveConnection = theApp.m_pConnection;
		theApp.m_pConnection->BeginTrans();
		CString strSql;
		strSql.Empty();
		strSql.Format(_T("update td set TdStatus = %d  where TDCN = '%s'"), EN_TASK_YES_SYN, stQueryTdInfo.ucTaskID);
		pCmdIns->CommandText = strSql.AllocSysString();
		pCmdIns->Execute(NULL, NULL, adCmdText);
		theApp.m_pConnection->CommitTrans();
		pThis->GetDlgItem(IDC_TASK_PERCENT)->SetWindowTextA(_T("100%"));
		Sleep(500);

	} while (FALSE);
		
	if (IDOK != iRet)
	{
		if (!pThis->m_pTaskOper->DeleteTask(dwTdID))
		{
			if (LANG_ZHCN == g_iUILanguage)
				AfxMessageBox(_T("删除任务失败"));
			else
				MessageBoxEx(NULL, _T("Delete task failed"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		}
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("任务创建并上传到服务端失败"));
		else
			MessageBoxEx(NULL, _T("The task creation and upload to the server failed"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
	}
	else
	{
		//taskItem.ucTaskStats = EN_TASK_YES_SYN;//暂时默认未上传
	}
	pThis->m_pParent->SendMessage(WM_MSG_UPDATE_TASK_LIST, (WPARAM)0, 0);

	pThis->SendMessage(WM_CLOSE, 0, 0);
	return 0;
}