#include "StdAfx.h"
#include "CameraControl_NetClient.h"
#include "CameraControl_Network.h"
#include "IOCPNetwork/NetClient.h"
#include "CHCameraControls/CameraBuffer.h"

#define MAX_FILE_FIND_TIME	10000

using namespace CHCameraControls_Network;

CCameraControl_NetClient::CCameraControl_NetClient(int nIndex, ICameraControl_NetClient2Parent* pICCNC2P) : CCameraControl(nIndex), m_pICCNC2P(pICCNC2P)
{
	m_pMessageProcessor = new CMessageProcessor(static_cast<IMessageProcessor2Parent*>(this));
	m_pNetClient = new CNetClient();
	m_nFrameProcessCount = 0;

	InitializeCriticalSection(&m_csFrameCaptured);
}

CCameraControl_NetClient::~CCameraControl_NetClient(void)
{
	if (m_pNetClient)
	{
		delete m_pNetClient;
		m_pNetClient = NULL;
	}

	if (m_pMessageProcessor)
	{
		delete m_pMessageProcessor;
		m_pMessageProcessor = NULL;
	}

	DeleteCriticalSection(&m_csFrameCaptured);
}

int CCameraControl_NetClient::Connect( const CCameraControlInfo& controlInfo )
{
	m_ControlInfo = controlInfo;

	CString strIP = controlInfo.GetConnectionPort();

	if (m_bConnected) return 0;

	m_nTotalIndex	  = controlInfo.GetIndex();
	m_nWidth		  = controlInfo.GetFrameWidth();
	m_nHeight		  = controlInfo.GetFrameHeight();
	m_nChannels		  = controlInfo.GetFrameChannels();
	m_nFrameCount	  = controlInfo.GetFrameCount();
	m_strCameraName	  = controlInfo.GetName();

	if (m_nFrameCount < 1) return -1;

	AllocateFrameBuffer(m_nWidth, m_nHeight, m_nChannels, m_nFrameCount, m_strCameraName);

	m_bConnected = TRUE;

	return InitNetwork(strIP);
}

BOOL CCameraControl_NetClient::InitNetwork( const CString& strIPAddress )
{
	if (m_pNetClient==NULL) return 0;

	CString strModuleIndex = strIPAddress.Right(1);
	int nModuleIndex = _ttoi(strModuleIndex);

	m_pNetClient->SetIN2P(static_cast<IIOCPNetwork2Parent*>(this));
	m_pNetClient->StartUp();
	m_pNetClient->InitNetwork(ClientMode, 4, NETPORT_NETWORK_CAMERA, strIPAddress);
	//m_pNetClient->InitNetwork(ClientMode, 4, NETPORT_NETWORK_CAMERA+nModuleIndex, _T("126.100.100.100"));		// lmk 170816 1pc 4module
	m_pNetClient->SetServerInfo(Socket_CameraServer, NETCODE_NETWORK_CAMERA, NETVER_NETWORK_CAMERA,1004);

	BOOL bResult = m_pNetClient->Connect(TRUE);

	if (m_pICCNC2P)
	{
		if (bResult)
		{
			m_pICCNC2P->ICCNC2P_DisplayMessage(m_nIndex, _T("[CameraControl_NetClient] [%d]Client Init Connect Cmd Success!"), m_nIndex);
		}
		else
		{
			m_pICCNC2P->ICCNC2P_DisplayMessage(m_nIndex, _T("[CameraControl_NetClient] [%d]Client Init Connect Cmd Fail!"), m_nIndex);
		}
	}

	return bResult;
}

void CCameraControl_NetClient::DeinitNetwork()
{
	if (m_pNetClient==NULL) return;

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

int CCameraControl_NetClient::Grab()
{
	if (m_pNetClient==NULL) return 0;

	return m_pNetClient->SendToServer(CC2CS_COMMAND_CAMERA_GRAB, NET_RESULT_SUCCESS, m_nIndex);
}

int CCameraControl_NetClient::Snap()
{
	if (m_pNetClient==NULL) return 0;

	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return 0;

	pPacket->SetInt(0); // count(0 is default)
	pPacket->SetInt(-1); // wait(-1 is default)

	return m_pNetClient->SendToServer(CC2CS_COMMAND_CAMERA_SNAP, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

int CCameraControl_NetClient::Snap( int nCount )
{
	if (m_pNetClient==NULL) return 0;

	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return 0;

	pPacket->SetInt(nCount); // count(0 is default)
	pPacket->SetInt(-1); // wait(-1 is default)

	return m_pNetClient->SendToServer(CC2CS_COMMAND_CAMERA_SNAP, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

int CCameraControl_NetClient::Snap( int nCount, UINT nWaitTime )
{
	if (m_pNetClient==NULL) return 0;

	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return 0;

	pPacket->SetInt(nCount); // count(0 is default)
	pPacket->SetInt((int)nWaitTime); // wait(-1 is default)

	return m_pNetClient->SendToServer(CC2CS_COMMAND_CAMERA_SNAP, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

int CCameraControl_NetClient::Freeze()
{
	if (m_pNetClient==NULL) return 0;

	return m_pNetClient->SendToServer(CC2CS_COMMAND_CAMERA_FREEZE, NET_RESULT_SUCCESS, m_nIndex);
}

int CCameraControl_NetClient::Abort()
{
	if (m_pNetClient==NULL) return 0;

	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return 0;

	return m_pNetClient->SendToServer(CC2CS_COMMAND_CAMERA_ABORT, NET_RESULT_SUCCESS, m_nIndex);
}

int CCameraControl_NetClient::Disconnect()
{
	DeinitNetwork();

	return 0;
}

void CCameraControl_NetClient::SetTriggerMode( int nMode, int nCount/*=1*/ )
{
	m_nTriggerMode = nMode;

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

	pPacket->SetInt(nMode);

	m_pNetClient->SendToServer(CC2CS_COMMAND_CAMERA_TRIG_MODE, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

BOOL CHCameraControls_Network::CCameraControl_NetClient::SetTriggerProcess( int nPosUmX, int nPosUmY )
{
	return SendSoftwareTrigger(nPosUmX, nPosUmY);
}

BOOL CCameraControl_NetClient::SendSoftwareTrigger( int nPosUmX, int nPosUmY )
{
	CNetPacket *pPacket = m_pNetClient->GetPacket();
	if (pPacket==NULL) return FALSE;

	pPacket->SetInt(m_nIndex);
	pPacket->SetInt(nPosUmX);
	pPacket->SetInt(nPosUmY);

	return m_pNetClient->SendToServer(CC2CS_COMMAND_SOFTWARE_TRIGGER, NET_RESULT_SUCCESS, m_nIndex, pPacket);
}

void CCameraControl_NetClient::IOCPNet2P_Connected( int Type )
{
	BOOL bSend = FALSE;
	if (m_pNetClient)
	{
		bSend = m_pNetClient->SendToServer(CC2CS_CAMERA_INDEX, NET_RESULT_SUCCESS, m_nIndex);
	}

	CString strLog = _T("");
	if (m_pICCNC2P)
	{
		strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client is Connected!"), m_nTotalIndex, m_nIndex);
		m_pICCNC2P->ICCNC2P_DisplayMessage(m_nIndex, strLog);

		if (bSend)
		{
			strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client [CAMERA_INDEX] Message Send Success!"), m_nTotalIndex, m_nIndex);
		} 
		else
		{
			strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client [CAMERA_INDEX] Message Send Fail!"), m_nTotalIndex, m_nIndex);
		}
		m_pICCNC2P->ICCNC2P_DisplayMessage(m_nIndex, strLog);
	}
}

void CCameraControl_NetClient::IOCPNet2P_Disconnected( int Type, int nModuleNo /*= -1*/ )
{
	if (m_pICCNC2P)
	{
		CString strLog = _T("");
		strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client is Disconnected!"), m_nTotalIndex, m_nIndex);
		m_pICCNC2P->ICCNC2P_DisplayMessage(m_nIndex, strLog);

		m_pICCNC2P->ICCNC2P_CameraConnected(m_nTotalIndex, FALSE);
	}
}

BOOL CCameraControl_NetClient::IOCPNet2P_Received( int Type, CNetPacket* pPacket, int nContext /*= -1*/ )
{
	if (m_pMessageProcessor==NULL) return FALSE;

	if (pPacket==NULL)  return FALSE;		

	switch(Type)	
	{
	case Socket_CameraServer:
		{
			CNetPacket* pCopyPacket = new CNetPacket(pPacket); // copy
			m_pMessageProcessor->AddMessageProcessData(pPacket->GetPacketCode(),(WPARAM)pCopyPacket,(LPARAM)nContext);					
		}
		break;

	default:
		return FALSE;
		break;
	}

	return TRUE;
}

void CCameraControl_NetClient::IMP2P_ProcessMessageData( CMessageProcessData* pData )
{
	if (pData==NULL) return;

	CNetPacket *pPacket = (CNetPacket*)pData->m_wParam;
	int nContext = (int)pData->m_lParam;

	CString strLog = _T("");

	switch(pData->m_unMsg)
	{
	case CS2CC_ACK_CAMERA_INDEX:
		strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client [ACK_CAMERA_INDEX] Message Received!"), m_nTotalIndex, pPacket->GetModuleNo());
		Process_AckCameraIndex(pPacket->GetModuleNo(), nContext);
		break;

	case CS2CC_ACK_COMMAND_CAMERA_GRAB:
		strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client [ACK_COMMAND_CAMERA_GRAB] Message Received!"), m_nTotalIndex, pPacket->GetModuleNo());
		Process_AckCommandCameraGrab(pPacket->GetModuleNo());
		break;

	case CS2CC_ACK_COMMAND_CAMERA_SNAP:
		strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client [ACK_COMMAND_CAMERA_SNAP] Message Received!"), m_nTotalIndex, pPacket->GetModuleNo());
		Process_AckCommandCameraSnap(pPacket->GetModuleNo());
		break;

	case CS2CC_ACK_COMMAND_CAMERA_FREEZE:
		delete pPacket;
		return;
		strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client [ACK_COMMAND_CAMERA_FREEZE] Message Received!"), m_nTotalIndex, pPacket->GetModuleNo());
		Process_AckCommandCameraFreeze(pPacket->GetModuleNo());
		break;

	case CS2CC_ACK_COMMAND_CAMERA_ABORT:
		strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client [ACK_COMMAND_CAMERA_ABORT] Message Received!"), m_nTotalIndex, pPacket->GetModuleNo());
		Process_AckCommandCameraAbort(pPacket->GetModuleNo());
		break;

	case CC2CS_ACK_COMMAND_CAMERA_TRIG_MODE:
		strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client [ACK_COMMAND_CAMERA_TRIG_MODE] Message Received!"), m_nTotalIndex, pPacket->GetModuleNo());
		Process_AckCommandCameraTriggerMode(pPacket->GetModuleNo());
		m_nFrameProcessCount = m_nFrameReceiveCount = 0;
		break;

	case CC2CS_ACK_COMMAND_SOFTWARE_TRIGGER:
		strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client [ACK_COMMAND_SOFTWARE_TRIGGER] Message Received!"), m_nTotalIndex, pPacket->GetModuleNo());
		Process_AckCommandSoftwareTrigger(pPacket->GetModuleNo());
		break;

	case CS2CC_STATUS_CAMERA:
		strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client [STATUS_CAMERA] Message Received!"), m_nTotalIndex, pPacket->GetModuleNo());
		Process_StatusCamera(pPacket->GetModuleNo(), pPacket);
		break;

	case CS2CC_COMMAND_CAMERA_CAPTURED:
		strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client [%03d][COMMAND_CAMERA_CAPTURED] Message Received!"), m_nTotalIndex, pPacket->GetModuleNo(), pPacket->GetInt(1));
		Process_CommandCameraCaptured(pPacket->GetModuleNo(), pPacket);
		break;
	}

	if (m_pICCNC2P)
	{
		m_pICCNC2P->ICCNC2P_DisplayMessage(m_nIndex, strLog, pPacket->GetModuleNo());
	}

	delete pPacket;
}


void CCameraControl_NetClient::Process_AckCameraIndex(int nIndex, int nContext)
{
	if (m_pICCNC2P)
	{
		m_pICCNC2P->ICCNC2P_CameraConnected(m_nTotalIndex, TRUE);
	}
}

void CCameraControl_NetClient::Process_AckCommandCameraGrab(int nIndex)
{
	if (m_pICCNC2P)
	{
		m_pICCNC2P->ICCNC2P_AckCameraGrab(nIndex);
	}
}

void CCameraControl_NetClient::Process_AckCommandCameraSnap(int nIndex)
{
	if (m_pICCNC2P)
	{
		m_pICCNC2P->ICCNC2P_AckCameraSnap(nIndex, 0, 0);
	}
}

void CCameraControl_NetClient::Process_AckCommandCameraFreeze(int nIndex)
{
	if (m_pICCNC2P)
	{
		m_pICCNC2P->ICCNC2P_AckCameraFreeze(nIndex);
	}
}

void CCameraControl_NetClient::Process_AckCommandCameraAbort(int nIndex)
{
	if (m_pICCNC2P)
	{
		m_pICCNC2P->ICCNC2P_AckCameraAbort(nIndex);
	}
}

void CCameraControl_NetClient::Process_AckCommandCameraTriggerMode( int nIndex )
{
	if (m_pICCNC2P)
	{
		m_pICCNC2P->ICCNC2P_AckCameraTriggerMode(nIndex);
	}
}

void CCameraControl_NetClient::Process_AckCommandSoftwareTrigger( int nIndex )
{
	if (m_pICCNC2P)
	{
		m_pICCNC2P->ICCNC2P_AckSoftwareTrigger(nIndex);
	}

	//Process_CommandCameraCaptured(m_nIndex, 0, _T("D:\\ResultData\\1.bmp"));		// lmk test
}

void CCameraControl_NetClient::Process_StatusCamera( int nIndex, CNetPacket *pPacket )
{
	if (m_pNetClient==NULL || pPacket==NULL) return;
	m_pNetClient->SendToServer(CC2CS_ACK_STATUS_CAMERA, NET_RESULT_SUCCESS, m_nIndex);

	int nResult = pPacket->GetInt(0);

	// set grab status
	// enum CameraControlType	{ CameraControl_Stop=0, CameraControl_Live, CameraControl_Start };
	if (nResult==0)	m_bGrabbing = FALSE;
	else			m_bGrabbing = TRUE;

	// send camera status 2 parent
	if (m_pICCNC2P)
	{
		m_pICCNC2P->ICCNC2P_StatusCamera(nIndex, nResult);
	}
}
void CHCameraControls_Network::CCameraControl_NetClient::Process_CommandCameraCaptured( int nIndex, CNetPacket *pPacket )
{
	if (m_pICCNC2P==NULL || m_pNetClient==NULL || pPacket==NULL) return;
	m_pNetClient->SendToServer(CC2CS_ACK_COMMAND_CAMERA_CAPTURED, NET_RESULT_SUCCESS, m_nIndex);

	m_nFrameReceiveCount++;

	int nModuleIndex = pPacket->GetInt(0);
	int nPointNum = pPacket->GetInt(1);
	CString strFilePath = pPacket->GetString(0);
	CString strLog = _T("");

	if (strFilePath.IsEmpty())
	{
		strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client Frame Image Path Error! [%s]"), m_nTotalIndex, m_nIndex, strFilePath);
		m_pICCNC2P->ICCNC2P_DisplayMessage(m_nIndex, strLog);
	}

	// make path	D:\ResultData -> \\126.100.100.1\d\ResultData
	CString strServerLocalPath=_T(""), strFileName=_T("");

	int nFindIdx = strFilePath.Find(_T("\\d\\"));
	strServerLocalPath = strFilePath.Mid(nFindIdx, strFilePath.GetLength());
 	strServerLocalPath.Replace(_T("\\d\\"), _T("d:\\"));

	CFileFind fileFind;
	DWORD dwTick = GetTickCount();
	while (1)
	{
		if (fileFind.FindFile(strServerLocalPath)) break;

		if (GetTickCount()-dwTick>=MAX_FILE_FIND_TIME)
		{
			strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client Frame Image Find Fail! [%s]"), m_nTotalIndex, m_nIndex, strServerLocalPath);
			m_pICCNC2P->ICCNC2P_DisplayMessage(m_nIndex, strLog);
			break;
		}

		Sleep(50);
	}

	FrameCaptured(strServerLocalPath);
}

void CHCameraControls_Network::CCameraControl_NetClient::FrameCaptured( const CString& strFilePath )
{
	if (!m_pCameraFrameBuffer) return;

	CString strLog = _T("");
	if (m_curFrameImage.LoadImage(strFilePath)==FALSE)
	{
		if (m_pICCNC2P)
		{
			strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client Frame Image Load Fail! [%s]"), m_nTotalIndex, m_nIndex, strFilePath);
			m_pICCNC2P->ICCNC2P_DisplayMessage(m_nIndex, strLog);
		}
		return;
	}

	int nChannels = m_curFrameImage.GetChannels();
	
	//EnterCriticalSection(&m_csFrameCaptured);

	// set frame index
	m_nFrameIndex = (++m_nFrameIndex) % m_nFrameCount;
	int nScanIndex = m_nScanIndex % MAX_BUFFER_SCAN_COUNT;

	// get buffer ptr
	CCameraBufferInfo *pFrameBuffInfo = m_pCameraFrameBuffer->GetBufferInfo(nScanIndex);
	BYTE *pFrameBuffData = m_pCameraFrameBuffer->GetBufferData(nScanIndex, m_nFrameIndex);

	if (pFrameBuffData && pFrameBuffInfo)
	{
		memcpy(pFrameBuffData, m_curFrameImage.GetImageBuffer(), m_curFrameImage.GetImageSize());

		// set image info
		pFrameBuffInfo->sCameraIndex	= m_nIndex; // mch 20160823
		pFrameBuffInfo->sScanIndex		= m_nScanIndex;
		pFrameBuffInfo->nImageCount		= m_nFrameIndex + 1;

		m_pCameraFrameBuffer->UnlockMemory(nScanIndex);
	}

	//LeaveCriticalSection(&m_csFrameCaptured);

	if (m_pCC2P)
	{	
		m_pCC2P->ICC2P_FrameCaptured(m_nIndex, m_nFrameIndex, m_nFrameCount);
	}

	m_nFrameProcessCount++;

	strLog.Format(_T("[CameraControl_NetClient] [%d][%d]Client Frame ReceiveCnt[%d], ProcessCnt[%d]"), m_nTotalIndex, m_nIndex, m_nFrameReceiveCount, m_nFrameProcessCount);
	m_pICCNC2P->ICCNC2P_DisplayMessage(m_nIndex, strLog);
}