#include "StdAfx.h"
#include "CameraControl_NetServer.h"
#include "CameraControl_Network.h"
#include "IOCPNetwork/NetServer.h"

using namespace CHCameraControls_Network;

CCameraControl_NetServer::CCameraControl_NetServer(ICameraControl_NetServer2Parent* pICCNS2P) : m_pICCNS2P(pICCNS2P)
{
	m_pMessageProcessor = new CMessageProcessor(static_cast<IMessageProcessor2Parent*>(this));
	m_pNetServer = new CNetServer();
	InitNetwork();
}

CCameraControl_NetServer::~CCameraControl_NetServer(void)
{
	DeinitNetwork();

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

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

BOOL CCameraControl_NetServer::InitNetwork()
{
	if (m_pICCNS2P==NULL) return FALSE;

	if (m_pNetServer)
	{
		const int nClientCount = 1;
		m_pNetServer->SetIN2P(static_cast<IIOCPNetwork2Parent*>(this));
		m_pNetServer->SetClientInfo(Socket_CameraClient, nClientCount, NETCODE_NETWORK_CAMERA, NETVER_NETWORK_CAMERA, FALSE,1004);
		BOOL bResult = m_pNetServer->InitNetwork(ServerMode, nClientCount, NETPORT_NETWORK_CAMERA, _T(""), TRUE);

		//int nModuleIndex = m_pICCNS2P->ICCNS2P_GetModuleIndex();
		//BOOL bResult = m_pNetServer->InitNetwork(ServerMode, nClientCount, NETPORT_NETWORK_CAMERA+nModuleIndex, _T(""), TRUE);		// lmk 170816 module index

		if (bResult)
		{
			m_pICCNS2P->ICCNS2P_DisplayMessage(_T("[CameraControl_NetServer] Init NetServer Success!"));
		}
		else
		{
			m_pICCNS2P->ICCNS2P_DisplayMessage(_T("[CameraControl_NetServer] Init NetServer Fail!"));
		}

	}
	return FALSE;
}

void CCameraControl_NetServer::DeinitNetwork()
{
	if (m_pNetServer==NULL) return;

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

void CHCameraControls_Network::CCameraControl_NetServer::IOCPNet2P_Connected( int Type )
{
	if (m_pICCNS2P)
	{
		m_pICCNS2P->ICCNS2P_DisplayMessage(_T("[CameraControl_NetServer] [%d]TypeClient is Connected!"), Type);
		m_pICCNS2P->ICCNS2P_CameraConnect(-1,TRUE);
	}
}

void CHCameraControls_Network::CCameraControl_NetServer::IOCPNet2P_Disconnected( int Type, int nModuleNo /*= -1*/ )
{
	if (m_pICCNS2P)
	{
		m_pICCNS2P->ICCNS2P_DisplayMessage(_T("[CameraControl_NetServer] [%d]Client is Disconnected!"), nModuleNo);
		m_pICCNS2P->ICCNS2P_CameraConnect(nModuleNo,FALSE);
	}
}

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

	if (pPacket==NULL)  return FALSE;		

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

	default:
		return FALSE;
		break;
	}

	return TRUE;
}

void CHCameraControls_Network::CCameraControl_NetServer::Process_CammandCameraCaptured(int nIndex, CString strPath, int nPointNum)
{
	CNetPacket *pPacket = m_pNetServer->GetPacket();
	if (pPacket==NULL) return;

	pPacket->SetInt(nIndex);
	pPacket->SetInt(nPointNum);
	pPacket->SetString(strPath);
	m_pNetServer->SendToClient(nIndex, CS2CC_COMMAND_CAMERA_CAPTURED, NET_RESULT_SUCCESS, pPacket);

	m_pICCNS2P->ICCNS2P_DisplayMessage(_T("[CameraControl_NetServer] Camera Captured! [point : %d]!"),pPacket->GetInt(1));

	return;
}

void CHCameraControls_Network::CCameraControl_NetServer::Process_CammandCameraSoftwareTrigger(int nIndex, int nUmPosX, int nUmPosY)
{
	if (m_pNetServer==NULL) return;

	m_pNetServer->SendToClient(nIndex, CC2CS_ACK_COMMAND_SOFTWARE_TRIGGER, NET_RESULT_SUCCESS);

	if (m_pICCNS2P)
	{
		m_pICCNS2P->ICCNS2P_CameraSoftwareTrigger(nIndex,nUmPosX,nUmPosY);
	}
}

int CCameraControl_NetServer::Send_StatusCamera( int nIndex, int nStatus )
{
	CNetPacket *pPacket = m_pNetServer->GetPacket();
	if (pPacket==NULL) return 0;

	pPacket->SetInt(nStatus);
	m_pNetServer->SendToClient(nIndex, CS2CC_STATUS_CAMERA, NET_RESULT_SUCCESS, pPacket);

	return 1;
}

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

	if (m_pICCNS2P==NULL) return;

	CNetPacket *pPacket = (CNetPacket*)pData->m_wParam;
	int nContext = (int)pData->m_lParam;
	
	CString strLog = _T("");

	switch(pData->m_unMsg)
	{
	case CC2CS_CAMERA_INDEX: 
		strLog.Format(_T("[CameraControl_NetServer] [%d]Client [CAMERA_INDEX] Message Received!"), pPacket->GetModuleNo());
		Process_CameraIndex(pPacket->GetModuleNo(), nContext);
		break;

	case CC2CS_COMMAND_CAMERA_GRAB: 
		strLog.Format(_T("[CameraControl_NetServer] [%d]Client [CAMERA_GRAB] Message Received!"), pPacket->GetModuleNo());
		Process_CommandCameraGrab(pPacket->GetModuleNo());
		break;

	case CC2CS_COMMAND_CAMERA_SNAP: 
		strLog.Format(_T("[CameraControl_NetServer] [%d]Client [CAMERA_SNAP] Message Received!"), pPacket->GetModuleNo());
		Process_CommandCameraSnap(pPacket->GetModuleNo(), pPacket->GetInt(0), pPacket->GetInt(1));
		break;

	case CC2CS_COMMAND_CAMERA_FREEZE: 
		strLog.Format(_T("[CameraControl_NetServer] [%d]Client [CAMERA_FREEZE] Message Received!"), pPacket->GetModuleNo());
		Process_CommandCameraFreeze(pPacket->GetModuleNo());
		break;

	case CC2CS_COMMAND_CAMERA_ABORT:
		strLog.Format(_T("[CameraControl_NetServer] [%d]Client [CAMERA_ABORT] Message Received!"), pPacket->GetModuleNo());
		Process_CommandCameraAbort(pPacket->GetModuleNo());
		break;

	case CC2CS_COMMAND_CAMERA_TRIG_MODE:
		strLog.Format(_T("[CameraControl_NetServer] [%d]Client [CAMERA_TRIG_MODE] Message Received! Mode[%d]"), pPacket->GetModuleNo(), pPacket->GetInt(0));
		Process_CammandCameraTrigMode(pPacket->GetModuleNo(), pPacket->GetInt(0));
		break;

	case CC2CS_COMMAND_SOFTWARE_TRIGGER:
		strLog.Format(_T("[CameraControl_NetServer] [%d]Client [SOFTWARE_TRIGGER] Message Received! Mode[%d]"), pPacket->GetModuleNo(), pPacket->GetInt(0));
		Process_CammandCameraSoftwareTrigger(pPacket->GetModuleNo(), pPacket->GetInt(1),pPacket->GetInt(2));
		break;

	case CC2CS_ACK_COMMAND_CAMERA_CAPTURED:
		strLog.Format(_T("[CameraControl_NetServer] [%d]Client [CAMERA_CAPTURED_ACK] Message Received! Mode[%d]"), pPacket->GetModuleNo(), pPacket->GetInt(0));
		break;

	case CC2CS_ACK_STATUS_CAMERA:
		strLog.Format(_T("[CameraControl_NetServer] [%d]Client [STATUS_CAMERA_ACK] Message Received! Mode[%d]"), pPacket->GetModuleNo(), pPacket->GetInt(0));
		break;
	}

	if (m_pICCNS2P)
	{
		m_pICCNS2P->ICCNS2P_DisplayMessage(strLog);
	}

	delete pPacket;
}

void CCameraControl_NetServer::Process_CameraIndex(int nIndex, int nContext)
{
	if (m_pNetServer==NULL) return;

	CNetJoiner* pJoiner = NULL;
 	int nClientCount= m_pNetServer->GetClientCount();
	for (int i = 0; i < nClientCount; i++)
	{
		pJoiner = m_pNetServer->GetJoinerArray(i);
		if (pJoiner && reinterpret_cast<int>(pJoiner->GetSocketContext()) == nContext)
		{
			pJoiner->SetModuleNo(nIndex, FALSE);					
			m_pNetServer->SendToClient(nIndex, CS2CC_ACK_CAMERA_INDEX, NET_RESULT_SUCCESS);
			if(m_pICCNS2P)	m_pICCNS2P->ICCNS2P_CameraConnect(nIndex,TRUE);
			return;
		}				
	}

	m_pNetServer->SendToClient(nIndex, CS2CC_ACK_CAMERA_INDEX, NET_RESULT_FAIL);
}

void CCameraControl_NetServer::Process_CommandCameraGrab(int nIndex)
{
	if (m_pNetServer==NULL) return;

	m_pNetServer->SendToClient(nIndex, CS2CC_ACK_COMMAND_CAMERA_GRAB, NET_RESULT_SUCCESS);

	if (m_pICCNS2P)
	{
		int nStatus = m_pICCNS2P->ICCNS2P_CameraGrab(nIndex);
		Send_StatusCamera(nIndex, nStatus);
	}

	//m_pNetServer->SendToClient(nIndex, CS2CC_ACK_COMMAND_CAMERA_GRAB, NET_RESULT_FAIL);
}

void CCameraControl_NetServer::Process_CommandCameraSnap(int nIndex, int nCount, int nWaitTime)
{
	if (m_pNetServer==NULL) return;

	m_pNetServer->SendToClient(nIndex, CS2CC_ACK_COMMAND_CAMERA_SNAP, NET_RESULT_SUCCESS);

	if (m_pICCNS2P)
	{
		int nStatus = m_pICCNS2P->ICCNS2P_CameraSnap(nIndex, nCount, (UINT)nWaitTime);
		Send_StatusCamera(nIndex, nStatus);
	}

	//m_pNetServer->SendToClient(nIndex, CS2CC_ACK_COMMAND_CAMERA_SNAP, NET_RESULT_FAIL);
}

void CCameraControl_NetServer::Process_CommandCameraFreeze(int nIndex)
{
	if (m_pNetServer==NULL) return;

	m_pNetServer->SendToClient(nIndex, CS2CC_ACK_COMMAND_CAMERA_FREEZE, NET_RESULT_SUCCESS);

	if (m_pICCNS2P)
	{
		int nStatus = m_pICCNS2P->ICCNS2P_CameraFreeze(nIndex);
		Send_StatusCamera(nIndex, nStatus);
	}

	//m_pNetServer->SendToClient(nIndex, CS2CC_ACK_COMMAND_CAMERA_FREEZE, NET_RESULT_FAIL);
}

void CCameraControl_NetServer::Process_CommandCameraAbort(int nIndex)
{
	if (m_pNetServer==NULL) return;

	m_pNetServer->SendToClient(nIndex, CS2CC_ACK_COMMAND_CAMERA_ABORT, NET_RESULT_SUCCESS);

	if (m_pICCNS2P)
	{
		int nStatus = m_pICCNS2P->ICCNS2P_CameraAbort(nIndex);
		Send_StatusCamera(nIndex, nStatus);
	}

	//m_pNetServer->SendToClient(nIndex, CS2CC_ACK_COMMAND_CAMERA_ABORT, NET_RESULT_FAIL);
}

void CCameraControl_NetServer::Process_CammandCameraTrigMode( int nIndex, int nMode )
{
	if (m_pNetServer==NULL) return;

	m_pNetServer->SendToClient(nIndex, CC2CS_ACK_COMMAND_CAMERA_TRIG_MODE, NET_RESULT_SUCCESS);

	if (m_pICCNS2P)
	{
		int nStatus = m_pICCNS2P->ICCNS2P_CameraTrigMode(nIndex, nMode);
	}
}