#include "StdAfx.h"
#include "WsiControl_Dit.h"
#include "IOCPNetwork/NetDefinition.h"
#include "IOCPNetwork/NetClient.h"

CWsiControl_Dit::CWsiControl_Dit(int nIndex) : CWsiControl(nIndex)
{
	m_pClientSocket		= new CNetClient();
}

CWsiControl_Dit::~CWsiControl_Dit(void)
{
	if (m_pClientSocket!=NULL)
	{
		delete m_pClientSocket;
	}
	m_pClientSocket		= NULL;	
}

int	CWsiControl_Dit::Connect(const CWsiControlInfo& controlInfo)
{
	m_nConnected = 0;
	m_Controlinfo = controlInfo;

	if (InitNetwork(m_Controlinfo.GetConnectionPort())!=1)
	{
		return 0;
	}

	return 1;
}

void CWsiControl_Dit::Disconnect()
{
	DeinitNetwork();

	m_nConnected = 0;
}

int CWsiControl_Dit::GetConnected() const
{
	if (m_pClientSocket==NULL) return 0;

	return m_nConnected;
}

BOOL CWsiControl_Dit::SendWsiAfmSafePosMove()
{
	
	if (m_pClientSocket == NULL) return FALSE;

	return m_pClientSocket->SendToServer(CW_WSI_AFM_SAFE_POS_MOVE, NET_RESULT_SUCCESS, m_nIndex);
}

int	CWsiControl_Dit::InitNetwork(const CString& strIPAddress)
{
	if (m_pClientSocket==NULL) return 0;

	m_pClientSocket->SetIN2P(static_cast<IIOCPNetwork2Parent*>(this));
	m_pClientSocket->StartUp();
	m_pClientSocket->InitNetwork(ClientMode, 1, NETPORT_WSI_SERVER_ALL, strIPAddress);
	m_pClientSocket->SetServerInfo(Socket_WSI_Server, NETCODE_WSI_SERVER_ALL, NETVER_WSI_SERVER_ALL);

	return m_pClientSocket->Connect(TRUE);
}

void CWsiControl_Dit::DeinitNetwork()
{
	if (m_pClientSocket==NULL) return;

	m_pClientSocket->DeinitNetwork();
	m_pClientSocket->CleanUp();
}

void CWsiControl_Dit::IOCPNet2P_Connected(int nType)
{
	if (nType!=Socket_WSI_Server) return;

	m_pClientSocket->SendToServer(CW_MODULE_INDEX, NET_RESULT_SUCCESS, m_nIndex);

	m_nConnected = 1;
}

void CWsiControl_Dit::IOCPNet2P_Disconnected(int nType, int nModuleNo)
{
	if (nType!=Socket_WSI_Server || nModuleNo!=m_nIndex) return;

	m_nConnected = 0;
}

BOOL CWsiControl_Dit::IOCPNet2P_Received(int nType, CNetPacket* pPacket, __int64 nContext)
{
	if (nType!=Socket_WSI_Server) return FALSE;

	if(!pPacket) return FALSE;

	switch(pPacket->GetPacketCode())
	{

	case WC_MODULE_INDEX:	
		NetProcess_WC_MODULE_INDEX(pPacket);
		break;

	case WC_MEASURE_READY:	
		NetProcess_WC_MEASURE_READY(pPacket);
		break;

	case WC_MEASURE_START:
		NetProcess_WC_MEASURE_START(pPacket);
		break;

	case WC_MEASURE_MOTION_END:
		NetProcess_WC_MEASURE_MOTION_END(pPacket);
		break;

	case WC_MEASURE_SCAN_END:
		NetProcess_WC_MEASURE_SCAN_END(pPacket);
		break;

	case WC_MEASURE_RESULT:
		NetProcess_WC_MEASURE_RESULT(pPacket);
		break;

	case WC_MEASURE_INFO:
		NetProcess_WC_MEASURE_INFO(pPacket);
		break;

	case WC_MEASURE_END:
		NetProcess_WC_MEASURE_END(pPacket);
		break;

	case WC_MEASURE_TIMEOVER:
		NetProcess_WC_MEASURE_TIMEOVER(pPacket);
		break;

	case WC_ALIVE_OCCUR:
		NetProcess_WC_ALIVE_OCCUR(pPacket);
		break;

	case WC_ALARM_OCCUR:
		NetProcess_WC_ALARM_OCCUR(pPacket);
		break;
	default:
		break;
	}

	return TRUE;
}

void CWsiControl_Dit::NetProcess_WC_MODULE_INDEX(CNetPacket* pPacket)
{
	if (m_pWC2P==NULL || pPacket==NULL) return;

	if (pPacket->GetResult()==NET_RESULT_SUCCESS)
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MODULE_INDEX Connected!"), m_nIndex);
	}
	else
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MODULE_INDEX Connection Fail!"), m_nIndex);
	}
	
	return;

	CString strGlassID = _T("");
	CString strRecipeID = _T("");
	int nType = WsiMode_None;
	if (m_pWC2P->IWC2P_GetCurrentStatus(m_nIndex, strGlassID, strRecipeID, nType)==WMT_MeasureReady)
	{
		SetWsiReady(strGlassID, strRecipeID, 0, nType);
	}
}

void CWsiControl_Dit::NetProcess_WC_MEASURE_READY(CNetPacket* pPacket)
{
	if (m_pWC2P==NULL || pPacket==NULL) return;

	if (pPacket->GetResult()==NET_RESULT_SUCCESS)
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_READY Success!"), m_nIndex);
	}
	else
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_READY Fail!"), m_nIndex);
	}

	m_pWC2P->IWC2P_RecvMeasureMessage(m_nIndex, WMT_MeasureReady, pPacket->GetResult());

	return;
}

void CWsiControl_Dit::NetProcess_WC_MEASURE_START(CNetPacket* pPacket)
{
	if (m_pWC2P==NULL || pPacket==NULL) return;

	if (pPacket->GetResult()==NET_RESULT_SUCCESS)
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_START Success!"), m_nIndex);
	}
	else
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_START Fail!"), m_nIndex);
	}

	return;

	int nMeasureCount = pPacket->GetInt(0);

	if (nMeasureCount!=m_nResultCount)
	{
		m_pWC2P->IWC2P_RecvMeasureMessage(m_nIndex, WMT_MeasureStart, 0);
	}

	m_pWC2P->IWC2P_RecvMeasureMessage(m_nIndex, WMT_MeasureStart, pPacket->GetResult());

}

void CWsiControl_Dit::NetProcess_WC_MEASURE_MOTION_END( CNetPacket* pPacket )
{
	if (m_pWC2P==NULL || pPacket==NULL) 
	{
		// send result
		m_pClientSocket->SendToServer(CW_MEASURE_MOTION_END, NET_RESULT_FAIL, m_nIndex);
		return;
	}

	if (pPacket->GetResult()==NET_RESULT_SUCCESS)
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_MOTION_END Success!"), m_nIndex);
	}
	else
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_MOTION_END Fail!"), m_nIndex);
	}

	m_pWC2P->IWC2P_RecvMeasureMessage(m_nIndex, WMT_MeasureMotionEnd, pPacket->GetResult());
}

void CWsiControl_Dit::NetProcess_WC_MEASURE_SCAN_END( CNetPacket* pPacket )
{
	if (m_pWC2P==NULL || pPacket==NULL) 
	{
		// send result
		m_pClientSocket->SendToServer(CW_MEASURE_SCAN_END, NET_RESULT_FAIL, m_nIndex);
		return;
	}

	if (pPacket->GetResult()==NET_RESULT_SUCCESS)
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_SCAN_END Success!"), m_nIndex);
	}
	else
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_SCAN_END Fail!"), m_nIndex);
	}

	int nModuleIdx = pPacket->GetInt(0);
	int nMeasureIdx = pPacket->GetInt(1);
	int nMeasurePosX = pPacket->GetInt(2);
	int nMeasurePosY = pPacket->GetInt(3);

	m_pWC2P->IWC2P_SetScanEnd(m_nIndex, nMeasureIdx, nMeasurePosX, nMeasurePosY);
}

void CWsiControl_Dit::NetProcess_WC_MEASURE_RESULT(CNetPacket* pPacket)
{
	if (m_pWC2P==NULL || pPacket==NULL) 
	{
		// send result
		m_pClientSocket->SendToServer(CW_MEASURE_RESULT, NET_RESULT_FAIL, m_nIndex);
		return;
	}

	if (pPacket->GetResult()==NET_RESULT_SUCCESS)
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_RESULT Success!"), m_nIndex);
	}
	else
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_RESULT Fail!"), m_nIndex);
	}


		// 하기 내용은 Wsi Reflow 에서 넘어오는 정보로 확인 된 내용입니다. 참고 바랍니다. - 181129 송준범J
	/*
	pPacket->GetInt(0)			= Index
	pPacket->GetInt(1)			= Wsi 측정 결과
	pPacket->GetInt(2)			= A존 판정 결과 (1 성공 0 실패)
	pPacket->GetInt(3)          = B존 판정 결과
	pPacket->GetInt(4)          = C존 판정 결과
	pPacket->GetInt(5)          = Review에서 보내줬던 PointIndex
	pPacket->GetDouble(0)       = 댐에서 Monomo까지의 거리
	*/

	//sjb Test WsiReflow 결과 패킷 확인
// 	int nIndex = pPacket->GetInt(0);
// 	int nCode = pPacket->GetInt(1);
// 	int nA존판정 = pPacket->GetInt(2);
// 	int nb존판정 = pPacket->GetInt(3);
// 	int nc존판정 = pPacket->GetInt(4);
// 	int nPointIndex2 = pPacket->GetInt(5);
// 	double dTest = pPacket->GetDouble(0); // 댐에서 Monomo까지 거리
// 	g_pLog->DisplayMessage(_T("[SJB Test Log] Index : %d, Result : %d, A : %d, B: %d, C: %d, Point:  %d  Monomo:  %f"),
// 		nIndex,nCode,nA존판정,nb존판정,nc존판정,nPointIndex2,dTest);



	// make measure result
	SWsiResult measureResult;

	switch(m_pWC2P->IWC2P_GetWsiType())
	{
	case WsiMeasureType_Normal:
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("WsiMeasureType_Normal"));

		measureResult.nResultIndex = pPacket->GetInt(0);
		measureResult.nResultCode = pPacket->GetInt(1);
		measureResult.nGlassType = pPacket->GetInt(2);
// 		measureResult.nResultType = pPacket->GetInt(2); 
		
		switch (measureResult.nGlassType)
		{
	
		case 0://TFE
			measureResult.bObjectType = pPacket->GetInt(3);
			measureResult.bBigSizeDefect = pPacket->GetInt(4);
			measureResult.fHeight = pPacket->GetDouble(0);
			measureResult.fWidthX = pPacket->GetDouble(1);
			measureResult.fWidthY = pPacket->GetDouble(2);
			measureResult.fAratio = pPacket->GetDouble(3);
			break;
		case 1: //MN
			measureResult.nDecisionZoneA = pPacket->GetInt(3);
			measureResult.nDecisionZoneB = pPacket->GetInt(4);
			measureResult.nDecisionZoneC = pPacket->GetInt(5);
			measureResult.nDecisionZoneD = pPacket->GetInt(6);
			measureResult.nDecisionZoneE = pPacket->GetInt(7);
			measureResult.nDecisionZoneF = pPacket->GetInt(8);
			measureResult.nPointIndex = pPacket->GetInt(9);
			measureResult.nDecisionZoneSlotB = pPacket->GetInt(10);
			measureResult.dDistFromRef = pPacket->GetDouble(0);
			break;
		case 2: //QD
			measureResult.nJugementR = pPacket->GetInt(3); //0 = no judge 1=OK  2=혼색 3=덜참
			measureResult.nJugementG = pPacket->GetInt(4);//0 = no judge 1=OK  2=혼색 3=덜참
			measureResult.nJugementB = pPacket->GetInt(5);//0 = no judge 1=OK  2=혼색 3=덜참
			measureResult.dRZoneHeight = pPacket->GetDouble(0);
			measureResult.dGZoneHeight = pPacket->GetDouble(1);
			measureResult.dBZoneHeight = pPacket->GetDouble(2);
			measureResult.dDefectHeight = pPacket->GetDouble(3);
			measureResult.nDefectType = pPacket->GetInt(6);
			measureResult.nMultiShot = pPacket->GetInt(7);
			measureResult.nCurrentShotNumber = pPacket->GetInt(8);
			break;
		case 3: //BANK
			measureResult.dRZoneHeight = pPacket->GetDouble(0);
			measureResult.dGZoneHeight = pPacket->GetDouble(1);
			measureResult.dBZoneHeight = pPacket->GetDouble(2);
			measureResult.dDefectHeight = pPacket->GetDouble(3);
			measureResult.nDefectType = pPacket->GetInt(3);
			measureResult.nMultiShot = pPacket->GetInt(4);
			measureResult.nCurrentShotNumber = pPacket->GetInt(5);
			break;
		case 4: //CS
			measureResult.dCSHeight = pPacket->GetDouble(0);
			measureResult.dDefectHeight = pPacket->GetDouble(1);
			measureResult.nDefectType = pPacket->GetInt(3);
			measureResult.nMultiShot = pPacket->GetInt(4);
			break;
		}


		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("WSI Type %d") ,pPacket->GetInt(5));
		//
		if (measureResult.bBigSizeDefect == TRUE)
		{
			//measureResult.bBigSizeDefect = TRUE;
			m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("WSI_BIGSIZE_DEFECT"));
		}
		else
		{
			//measureResult.bBigSizeDefect = FALSE;
		}
			
			// is measure success?
	//	if (measureResult.nResultCode==1) // success
	//	{
	//			for (int i=0; i<MAX_WSI_RESULT_COUNT; i++)
	//			{
	//				measureResult.pResultData[i] = pPacket->GetDouble(i);
	//			}
	//	}
		
		}
		break;

	case WsiMeasureType_Monomer:
		{
			m_pWC2P->IWC2P_DisplayMessage(m_nIndex,_T("WsiMeasureType_Monomer"));
			measureResult.nResultIndex	= pPacket->GetInt(0);
			measureResult.nResultCode	= pPacket->GetInt(1);
			measureResult.dDamDistance	= pPacket->GetDouble(0);

			if (measureResult.nResultCode==1) // success
			{
				for (int nResultCount=0; nResultCount<WsiReflow_Result_Info_Count; nResultCount++)
				{
					measureResult.pReflowResultData[nResultCount] = pPacket->GetInt(nResultCount+2);
					m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] Mn Data[%d] %d"),nResultCount,measureResult.pReflowResultData[nResultCount]);
				}				
			}
		}
		break;

	case WsiMeasureType_User:
		{
		measureResult.nResultIndex	= pPacket->GetInt(0);
			measureResult.nResultCode	= pPacket->GetInt(1);
			measureResult.nResultType	= pPacket->GetInt(2);

			// is measure success?
			if (measureResult.nResultCode==1) // success
			{
				for (int i=0; i<MAX_WSI_RESULT_COUNT; i++)
				{
					measureResult.pResultData[i] = pPacket->GetDouble(i);
				}
			}
		}
		break;
	case WsiMeasureType_MultiShot :
		{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("WsiMeasureType_User"));
		measureResult.nResultIndex = pPacket->GetInt(0);
		measureResult.nResultCode = pPacket->GetInt(1);
		//measureResult.nResultType	= pPacket->GetInt(2);

		//임시
		measureResult.nDefectType = pPacket->GetInt(2);
		measureResult.nMultiShot = pPacket->GetInt(3);
		measureResult.nCurrentShotNumber = pPacket->GetInt(4);
		//

		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("nMultiShot : %d nCurrentShotNumber : %d"), measureResult.nMultiShot, measureResult.nCurrentShotNumber);

	    }
		break;
	case WsiMeasureType_VLSI:
		{
			m_pWC2P->IWC2P_DisplayMessage(m_nIndex,_T("WsiMeasureType_VLSI"));
			measureResult.nResultIndex	= pPacket->GetInt(0);
			measureResult.nResultCode	= pPacket->GetInt(1);
			measureResult.nGlassType = pPacket->GetInt(2);
			measureResult.nWsiState	= pPacket->GetInt(3);
			measureResult.dAccuracy = pPacket->GetDouble(0);
			measureResult.dRepeatability = pPacket->GetDouble(1);
			m_pWC2P->IWC2P_DisplayMessage(m_nIndex,_T("VLSI state %d ACC %f RTB %f"),measureResult.nWsiState,measureResult.dAccuracy ,measureResult.dRepeatability);
		}
		break;

	default:
		{
			break;
		}
	}

	// push back result
	m_vecWsiResult.push_back(measureResult);

	// send parent
	int nLastIndex = int(m_vecWsiResult.size())-1;
	m_pWC2P->IWC2P_SetMeasureResult(m_nIndex, m_vecWsiResult.at(nLastIndex));

	// send result
	int nPointIndex = measureResult.nResultIndex;

	// get defect info
	short sLoc=0, sOptic=0, sGray=0;
	CString strCellID = _T("");
	if (m_pWC2P->IWC2P_GetMeasureInfo(m_nIndex, nPointIndex, sLoc, sOptic, sGray, strCellID)==FALSE)
	{
		// send result
		m_pClientSocket->SendToServer(CW_MEASURE_RESULT, NET_RESULT_FAIL, m_nIndex);
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] %02dPoint Get Measure Info Fail!"), m_nIndex, nPointIndex);
		return;
	}

	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
	if (pSendPacket==NULL)
	{
		m_pClientSocket->SendToServer(CW_MEASURE_RESULT, NET_RESULT_FAIL, m_nIndex);
		return;
	}

	// set send packet
	pSendPacket->SetInt(nPointIndex);
	pSendPacket->SetShort(sLoc);
	pSendPacket->SetShort(sOptic);
	pSendPacket->SetShort(sGray);
	pSendPacket->SetString(strCellID);

	m_pClientSocket->SendToServer(CW_MEASURE_RESULT, NET_RESULT_SUCCESS, m_nIndex, pSendPacket);

	m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_RESULT Ack!"), m_nIndex);
	m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] %02dPoint %d %d %d %s!"), nPointIndex, sLoc, sOptic, sGray, strCellID);

	return;
}

void CWsiControl_Dit::NetProcess_WC_MEASURE_INFO(CNetPacket* pPacket)
{
	if (m_pWC2P==NULL || pPacket==NULL) 
	{
		// send result
		m_pClientSocket->SendToServer(CW_MEASURE_INFO, NET_RESULT_FAIL, m_nIndex);
		return;
	}

	if (pPacket->GetResult()==NET_RESULT_SUCCESS)
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_INFO Success!"), m_nIndex);
	}
	else
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_INFO Fail!"), m_nIndex);
	}

	int nPointIndex = pPacket->GetInt(0);
	CString strImageFilename = pPacket->GetString(0);
	CString strImageFilename2 = pPacket->GetString(1);

	if (m_pWC2P->IWC2P_SetMeasureInfo(m_nIndex, nPointIndex, strImageFilename, strImageFilename2)==FALSE)
	{
		m_pClientSocket->SendToServer(CW_MEASURE_INFO, NET_RESULT_FAIL, m_nIndex);
		return;
	}

	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
	if (pSendPacket)
	{
		pSendPacket->SetInt(nPointIndex);
		pSendPacket->SetString(strImageFilename);

		m_pClientSocket->SendToServer(CW_MEASURE_INFO, NET_RESULT_SUCCESS, m_nIndex, pSendPacket);
	}

	m_pClientSocket->SendToServer(CW_MEASURE_INFO, NET_RESULT_SUCCESS, m_nIndex);

	return;	
}

void CWsiControl_Dit::NetProcess_WC_MEASURE_END(CNetPacket* pPacket)
{
	if (m_pWC2P==NULL || pPacket==NULL) return;

	if (pPacket->GetResult()==NET_RESULT_SUCCESS)
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_END Success!"), m_nIndex);
	}
	else
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_END Fail!"), m_nIndex);
	}

	/*
	CTime time = CTime::GetCurrentTime();
	FILE *fp = NULL;
	CString strFilename = _T("");
	strFilename.Format(_T("D:\\ResultData\\WsiResult_%04d%02d%02d_%02d%02d%02d.csv")
		, time.GetYear(), time.GetMonth(), time.GetDay(), time.GetHour(), time.GetMinute(), time.GetSecond());
	_tfopen_s(&fp, strFilename, _T("w"));
	if (fp)
	{
		// save result csv file
		for (int nIdx=0; nIdx<int(m_vecWsiResult.size()); nIdx++)
		{
			_ftprintf_s(fp, _T("%d, %d, %d, %d, %.3lf, %.3lf, \n"), nIdx
				, m_vecWsiResult[nIdx].nResultIndex, m_vecWsiResult[nIdx].nResultType, m_vecWsiResult[nIdx].nResultCode
				, m_vecWsiResult[nIdx].pResultData[0], m_vecWsiResult[nIdx].pResultData[1]);
		}
		fclose(fp);
	}
	*/

	m_pWC2P->IWC2P_RecvMeasureMessage(m_nIndex, WMT_MeasureEnd, pPacket->GetResult());

	return;
}

void CWsiControl_Dit::NetProcess_WC_MEASURE_TIMEOVER(CNetPacket* pPacket)
{
	if (m_pWC2P==NULL || pPacket==NULL) return;

	if (pPacket->GetResult()==NET_RESULT_SUCCESS)
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_TIMEOVER Success!"), m_nIndex);
	}
	else
	{
		m_pWC2P->IWC2P_DisplayMessage(m_nIndex, _T("[WsiControl] [%02d] MEASURE_TIMEOVER Fail!"), m_nIndex);
	}

	return;

	m_pWC2P->IWC2P_RecvMeasureMessage(m_nIndex, WMT_MeasureTimeout, pPacket->GetResult());
}


BOOL CWsiControl_Dit::SetWsiReady( const CString& strGlassID, const CString& strRecipeID, int nMagIndex, int nType/*=WsiMode_None*/,int nAfmHome/*=1*/ )
{
	if (GetConnected()!=1) return FALSE;

	CNetPacket *pPacket = m_pClientSocket->GetPacket();
	if (pPacket==NULL) return FALSE;

	pPacket->SetString((CString)strGlassID);
	pPacket->SetString((CString)strRecipeID);
	pPacket->SetInt(nMagIndex);
	pPacket->SetInt(nType);
	pPacket->SetInt(nAfmHome);
	ClearResult();

	return m_pClientSocket->SendToServer(CW_MEASURE_READY, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

BOOL CWsiControl_Dit::SetWsiStart(int nPointCount, const VectorInteger& vecUMOriginX, const VectorInteger& vecUMOriginY, int nUserWsiType)
{
	if (GetConnected()!=1) return FALSE;

	CNetPacket *pPacket = m_pClientSocket->GetPacket();
	if (pPacket==NULL) return FALSE;

	//pPacket->SetInt(m_nIndex);

	nPointCount = min(nPointCount, int(vecUMOriginX.size()));
	pPacket->SetInt(nPointCount);
	pPacket->SetInt(nUserWsiType);

	for (int nIdx=0; nIdx<nPointCount; nIdx++)
	{
		if (nIdx>=int(vecUMOriginX.size()) || nIdx>=int(vecUMOriginY.size())) continue;

		pPacket->SetInt(nIdx);
		pPacket->SetInt(vecUMOriginX.at(nIdx));
		pPacket->SetInt(vecUMOriginY.at(nIdx));
	}

	// set measure count
	m_nResultCount = nPointCount;


	/*
	[Multi Shot]
	-nMeasurementIndex (n+0)
		-nMeasurePoint (n+1)
		-nMeasureShotNumber(n+2)
		-nUMOriginX (n+3)
		-nUMOriginY (n+4)
	*/
	return m_pClientSocket->SendToServer(CW_MEASURE_START, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

BOOL CWsiControl_Dit::SetWsiStart_CPJT(int nPointCount, const VectorInteger& vecUMOriginX, const VectorInteger& vecUMOriginY, int nUserWsiType, const VectorInteger& nModelIndex)
{
	if (GetConnected() != 1) return FALSE;

	CNetPacket *pPacket = m_pClientSocket->GetPacket();
	if (pPacket == NULL) return FALSE;

	//pPacket->SetInt(m_nIndex);

	nPointCount = min(nPointCount, int(vecUMOriginX.size()));
	pPacket->SetInt(nPointCount);
	pPacket->SetInt(nUserWsiType);

	for (int nIdx = 0; nIdx < nPointCount; nIdx++)
	{
		if (nIdx >= int(vecUMOriginX.size()) || nIdx >= int(vecUMOriginY.size())) continue;

		pPacket->SetInt(nIdx);
		pPacket->SetInt(nModelIndex.at(nIdx));
		pPacket->SetInt(vecUMOriginX.at(nIdx));
		pPacket->SetInt(vecUMOriginY.at(nIdx));
	}

	// set measure count
	m_nResultCount = nPointCount;


	/*
	[Multi Shot]
	-nMeasurementIndex (n+0)
		-nMeasurePoint (n+1)
		-nMeasureShotNumber(n+2)
		-nUMOriginX (n+3)
		-nUMOriginY (n+4)
	*/
	return m_pClientSocket->SendToServer(CW_MEASURE_START, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

BOOL CWsiControl_Dit::SetWsiMotionEnd( int nResultIndex, int nUMOriginX, int nUMOriginY )
{
	if (GetConnected()!=1) return FALSE;

	CNetPacket *pPacket = m_pClientSocket->GetPacket();
	if (pPacket==NULL) return FALSE;

	m_nResultIndex = nResultIndex;

	pPacket->SetInt(m_nIndex);
	pPacket->SetInt(m_nResultIndex);
	pPacket->SetInt(nUMOriginX);
	pPacket->SetInt(nUMOriginY);

	return m_pClientSocket->SendToServer(CW_MEASURE_MOTION_END, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

BOOL CWsiControl_Dit::SetWsiEnd()
{
	if (GetConnected()!=1) return FALSE;

	return m_pClientSocket->SendToServer(CW_MEASURE_END, NET_RESULT_SUCCESS, m_nIndex);
}

BOOL CWsiControl_Dit::SetWsiTimeOver()
{
	if (GetConnected()!=1) return FALSE;

	return m_pClientSocket->SendToServer(CW_MEASURE_TIMEOVER, NET_RESULT_SUCCESS, m_nIndex);
}

BOOL CWsiControl_Dit::SetSystemTime(SYSTEMTIME stCurrentTime)
{
	if (GetConnected()!=1) return FALSE;

	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
	if (pSendPacket)
	{
		pSendPacket->SetInt(stCurrentTime.wYear);		// Year
		pSendPacket->SetInt(stCurrentTime.wMonth);		// Month
		pSendPacket->SetInt(stCurrentTime.wDay);			// Day
		pSendPacket->SetInt(stCurrentTime.wHour);		// Hour
		pSendPacket->SetInt(stCurrentTime.wMinute);		// Minute
		pSendPacket->SetInt(stCurrentTime.wSecond);		// Second
		//wDayOfWeek, wMilliseconds 는 Local 정보 이용

		return m_pClientSocket->SendToServer(CF_SYSTEMTIME_CHANGE, NET_RESULT_SUCCESS, m_nIndex, pSendPacket);
	}
	else
		return FALSE;
}

BOOL CWsiControl_Dit::SetWsiReflowStart( int nPointCount, const VectorInteger& vectorPointIndex, const VectorInteger& vecUMOriginX, const VectorInteger& vecUMOriginY, int nWsiType/*=1*/ )
{
	if (GetConnected()!=1) return FALSE;

	CNetPacket *pPacket = m_pClientSocket->GetPacket();
	if (pPacket==NULL) return FALSE;
	
	m_nResultCount = nPointCount;
	int nMeasureCount = (int)vecUMOriginX.size();

	// SetWsiReflowCount
	pPacket->SetInt(nMeasureCount);	
	pPacket->SetInt(0);//0715최형목 Reflow 는 6개 보내줘야되는데 5개만 보내줘서 추가 
	// set measure position
	for (int i=0; i<nMeasureCount; i++)
	{
		pPacket->SetInt(i);										// Defect Index
		pPacket->SetInt(vectorPointIndex[i]);					// PointIndex
		pPacket->SetInt(vecUMOriginX.at(i));
		pPacket->SetInt(vecUMOriginY.at(i));
	}	

	return m_pClientSocket->SendToServer(CW_MEASURE_START, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}


void CWsiControl_Dit::NetProcess_WC_ALARM_OCCUR( CNetPacket* pPacket )
{
	if (pPacket==NULL) return ;

	int index = pPacket->GetInt(0);
	CString strMsg=pPacket->GetString(0);

	m_pWC2P->IWC2P_SetWSIErrorCheck(index,strMsg);
}

void CWsiControl_Dit::NetProcess_WC_ALIVE_OCCUR( CNetPacket* pPacket )
{
	m_pWC2P->IWC2P_SetWSIAliveCheck();
}
BOOL CWsiControl_Dit::SetMultiShotWsiReady( const CString& strGlassID, const CString& strRecipeID, int nMagIndex, int nType/*=WsiMode_None*/,int nAfmHome/*=1*/,int nMultiShotFlag,int nShotCount,double dMargin)
{
	if (GetConnected()!=1) return FALSE;

	CNetPacket *pPacket = m_pClientSocket->GetPacket();
	if (pPacket==NULL) return FALSE;

	pPacket->SetString((CString)strGlassID);
	pPacket->SetString((CString)strRecipeID);
	pPacket->SetInt(nMagIndex);
	pPacket->SetInt(nType); //매뉴얼 모드 혹은 오토 모드
	pPacket->SetInt(nAfmHome);//WSI AF Home 여부
	pPacket->SetInt(nMultiShotFlag);
	pPacket->SetInt(nShotCount);
	pPacket->SetDouble(dMargin);
	ClearResult();

	return m_pClientSocket->SendToServer(CW_MEASURE_READY, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

BOOL CWsiControl_Dit::SetMultiShotWsiStart(int nPointCount, const VectorInteger& vecUMOriginX, const VectorInteger& vecUMOriginY, int nUserWsiType,int nMeasurePoint,int nMeasureShotNumber)
{
	if (GetConnected()!=1) return FALSE;

	int nTempMeasureShotNumber = 0;
	int nTempMeasurePoint = 0;

	CNetPacket *pPacket = m_pClientSocket->GetPacket();
	if (pPacket==NULL) return FALSE;

	//pPacket->SetInt(m_nIndex);

	nPointCount = min(nPointCount, int(vecUMOriginX.size()));
	pPacket->SetInt(nPointCount);
	pPacket->SetInt(nUserWsiType);

	for (int nIdx=0; nIdx<nPointCount; nIdx++)
	{

		if(nTempMeasureShotNumber == 4)
		{
			nTempMeasureShotNumber=0;
		}
		if (nIdx>=int(vecUMOriginX.size()) || nIdx>=int(vecUMOriginY.size())) continue;
		
		pPacket->SetInt(nIdx);
		pPacket->SetInt(nTempMeasurePoint);
		pPacket->SetInt(nTempMeasureShotNumber);
		pPacket->SetInt(vecUMOriginX.at(nIdx));
		pPacket->SetInt(vecUMOriginY.at(nIdx));

		nTempMeasureShotNumber += 1;
		if(nTempMeasureShotNumber == 4)
		{
			nTempMeasurePoint +=1;
		}
	}

	// set measure count
	m_nResultCount = nPointCount;


	/*
	[Multi Shot]
	-nMeasurementIndex (n+0)
		-nMeasurePoint (n+1)
		-nMeasureShotNumber(n+2)
		-nUMOriginX (n+3)
		-nUMOriginY (n+4)
	*/
	return m_pClientSocket->SendToServer(CW_MEASURE_START, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}