#include "StdAfx.h"
#include "CHAfmControls/AFMControl_Dit.h"
#include "IOCPNetwork/NetDefinition.h"
#include "IOCPNetwork/NetClient.h"
#include "IOCPNetwork/NetPacket.h"

enum SEND_BIT_TYPE { SB_SERVO_ON=0, SB_ALARM, SB_IN_MOTION, SB_IN_POS, SB_HOME, SB_LIMIT_PLUS, SB_LIMIT_MINUS, SB_AF_ENABLE };
enum RECV_BIT_TYPE { RB_ZOOM_INDEX=0, RB_JOG_SPEED, RB_NONE_2, RB_REF_POS, RB_HOME, RB_JOG_COMMAND, RB_NONE_4, RB_AF_ENABLE};

CAfmControl_Dit::CAfmControl_Dit(int nIndex) : CAfmControl(nIndex)
{
	m_pClientSocket = new CNetClient();
	m_lastAliveTime = 0;
	m_bSetTime = FALSE;
}

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

int	CAfmControl_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, 4, NETPORT_AFM_SERVER_ALL, strIPAddress);
	m_pClientSocket->SetServerInfo(Socket_AFM_Server, NETCODE_AFM_SERVER_ALL, NETVER_AFM_SERVER_ALL);

	//m_pClientSocket->InitNetwork(ClientMode, 4, NETPORT_AFM_SERVER_ALL, strIPAddress);
	//m_pClientSocket->SetServerInfo(Socket_AFM_Server, 7104, 1004);

	return m_pClientSocket->Connect(TRUE);
}

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

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

void CAfmControl_Dit::IOCPNet2P_Connected(int nType)
{
	if (nType!=Socket_AFM_Server) return;
	
	if (m_pAFC2P)
	{
		m_pAFC2P->IAFC2P_DisplayMessage(m_nIndex, _T("AFM_Control_DIT NetConnected! => %d Client"), m_nIndex);
	}

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

	m_bConnected = TRUE;
}

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

	if (m_pAFC2P)
	{
		m_pAFC2P->IAFC2P_DisplayMessage(m_nIndex, _T("AFM_Control_DIT NetDisconnected! => %d Client"), m_nIndex);
	}

	m_bConnected = FALSE;
}

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

	if(!pPacket) return FALSE;

	switch(pPacket->GetPacketCode())
	{
	case FC_MODULE_INDEX:	
		NetProcess_FC_MODULE_INDEX(pPacket);
		break;

	case FC_SEND_RECIPE:
		NetProcess_FC_SEND_RECIPE(pPacket);
		break;

	case FC_RECV_RECIPE:
		NetProcess_FC_RECV_RECIPE(pPacket);
		break;

	case FC_RECIPE_COMP:
		NetProcess_FC_RECIPE_COMP(pPacket);
		break;

	case FC_RECIPE_COUNT:
		NetProcess_FC_RECIPE_COUNT(pPacket);
		break;

	case FC_RECIPE_INFO:
		NetProcess_FC_RECIPE_INFO(pPacket);
		break;

	case FC_SEND_BIT:
		NetProcess_FC_SEND_BIT(pPacket);
		break;

	case FC_RECV_BIT:
		NetProcess_FC_RECV_BIT(pPacket);
		break;

	case FC_RECV_ALIVE:
		NetProcess_FC_RECV_ALIVE(pPacket);
		break;

	default:
		break;
	}

	return TRUE;
}

void CAfmControl_Dit::NetProcess_FC_MODULE_INDEX(CNetPacket* pPacket)
{
	// AFM »óŽÅÈ£ ¿äû ¸Þ¼¼Áö Àü¼ÛÇÔ.
// 	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
// 	if (pSendPacket)
// 	{
// 		pSendPacket->SetInt(m_nIndex);
// 		m_pClientSocket->SendToServer(CF_SEND_SIGNAL, NET_RESULT_SUCCESS, m_nIndex, pSendPacket);
// 	}
}

void CAfmControl_Dit::NetProcess_FC_SEND_SIGNAL(CNetPacket* pPacket)
{
	// ƯÁ¤ ¸ðµâÀÇ ÇöÀç»óÅ ½ÅÈ£ ¿äû °á°ú
	int nModuleIndex = pPacket->GetInt(0);		// AFM ¸ðµâÀÇ ¹øÈ£		
	int nModuleStatus = pPacket->GetInt(1);		// ÇöÀç »óÅ ½ÅÈ£

	// ÇöÀç ¸ðµâÀÇ ½ÅÈ£À̸é...
	if (m_nIndex == nModuleIndex)
	{
		if (m_pAFC2P && m_nStatus!=nModuleStatus)
		{
			m_pAFC2P->IAFC2P_CurrentStatus(m_nIndex, nModuleStatus);
		}
		m_nStatus = nModuleStatus;
	}

	//g_pLog->DisplayMessage(_T("NetProcess_FC_SEND_SIGNAL %d %d"), nModuleIndex, nModuleStatus);

// 	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
// 	if (pSendPacket)
// 	{
// 		pSendPacket->SetInt(m_nIndex);
// 		pSendPacket->SetInt(64);
// 		m_pClientSocket->SendToServer(CF_RECV_SIGNAL, NET_RESULT_SUCCESS, 0, pSendPacket);
// 	}
}

void CAfmControl_Dit::NetProcess_FC_RECV_SIGNAL(CNetPacket* pPacket)
{
	// ƯÁ¤ ¸ðµâÀÇ »óź¯°æ ½ÅÈ£ Àü¼Û °á°ú	
	int nModuleIndex = pPacket->GetInt(0);		// AFM ¸ðµâÀÇ ¹øÈ£		

	//g_pLog->DisplayMessage(_T("NetProcess_FC_RECV_SIGNAL %d"), nModuleIndex);

// 	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
// 	if (pSendPacket)
// 	{
// 		pSendPacket->SetInt(m_nIndex);
// 		m_pClientSocket->SendToServer(CF_SEND_RECIPE, NET_RESULT_SUCCESS, 0, pSendPacket);
// 	}
}

void CAfmControl_Dit::NetProcess_FC_SEND_RECIPE(CNetPacket* pPacket)
{
	// ƯÁ¤ ¸ðµâÀÇ ÇöÀç ·¹½ÃÇÇ Á¤º¸ ¿äû °á°ú 
	int nModuleIndex		= pPacket->GetInt(0);		// AFM ¸ðµâÀÇ ¹øÈ£		
	int nRecipeIndex		= pPacket->GetInt(1);		// ·¹½ÃÇÇ ¹øÈ£	
	int nZoomCount			= pPacket->GetInt(2);		// ÁÜ °¹¼ö
	int nZoomIndex			= pPacket->GetInt(3);		// ÁÜ ¹øÈ£
	CString strRecipeName	= pPacket->GetString(0);	// ·¹½ÃÇÇ À̸§

// 	if (m_pAFC2P)
// 	{
// 		m_pAFC2P->AFC2P_DisplayMessage(_T("NetProcess_FC_SEND_RECIPE %d %d %d %d %s"), nModuleIndex, nZoomIndex, strRecipeName);
// 	}

// 	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
// 	if (pSendPacket)
// 	{
// 		pSendPacket->SetInt(m_nIndex);
// 		pSendPacket->SetInt(1);
// 
// 		CString strValue = _T("RECIPE_01");
// 		pSendPacket->SetString(strValue);
// 
// 		m_pClientSocket->SendToServer(CF_RECV_RECIPE, NET_RESULT_SUCCESS, 0, pSendPacket);
// 	}
}

void CAfmControl_Dit::NetProcess_FC_RECV_RECIPE(CNetPacket* pPacket)
{
// 	if (m_pAFC2P)
// 	{
// 		m_pAFC2P->AFC2P_DisplayMessage(_T("NetProcess_FC_RECV_RECIPE"));
// 	}
}

void CAfmControl_Dit::NetProcess_FC_RECIPE_COMP(CNetPacket* pPacket)
{
	// ƯÁ¤ ¸ðµâÀÇ Æ¯Á¤ ·¹½ÃÇÇ º¯°æ °á°ú¸¦ ¹ÞÀ½.
	int nModuleIndex		= pPacket->GetInt(0);		// AFM ¸ðµâÀÇ ¹øÈ£	
	int nResultCode			= pPacket->GetInt(1);		// ·¹½ÃÇÇ º¯°æ °á°ú 1:¼º°ø, 
	int nRecipeIndex		= pPacket->GetInt(2);		// ·¹½ÃÇÇ ¹øÈ£
	int nZoomIndex			= pPacket->GetInt(3);		// ÁÜ ¹øÈ£
	CString strRecipeName	= pPacket->GetString(0);	// ·¹½ÃÇÇ À̸§

	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
	if (pSendPacket)
	{
		pSendPacket->SetInt(m_nIndex);
		m_pClientSocket->SendToServer(CF_RECIPE_COMP, NET_RESULT_SUCCESS, m_nIndex, pSendPacket);
	}

// 	if (m_pAFC2P)
// 	{
// 		m_pAFC2P->AFC2P_DisplayMessage(_T("NetProcess_FC_RECIPE_COMP %d %d %d %d %s"), nModuleIndex, nResultCode, nRecipeIndex, nZoomIndex, strRecipeName);
// 	}
}

void CAfmControl_Dit::NetProcess_FC_RECIPE_COUNT(CNetPacket* pPacket)
{
	// ƯÁ¤ ¸ðµâÀÇ ÃÑ ·¹½ÃÇÇ ¼ö¸¦ ¹ÞÀ½.
	int nModuleIndex	= pPacket->GetInt(0);			// AFM ¸ðµâÀÇ ¹øÈ£
	int nRecipeCount	= pPacket->GetInt(1);			// ÃÑ ·¹½ÃÇÇÀÇ ¼ö

	//g_pLog->DisplayMessage(_T("NetProcess_FC_RECIPE_COUNT %d %d"), nModuleIndex, nRecipeCount);

// 	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
// 	if (pSendPacket)
// 	{
// 		pSendPacket->SetInt(0);
// 		m_pClientSocket->SendToServer(CF_RECIPE_INFO, NET_RESULT_SUCCESS, 0, pSendPacket);
// 	}
}

void CAfmControl_Dit::NetProcess_FC_RECIPE_INFO(CNetPacket* pPacket)
{
	// ƯÁ¤ ¸ðµâÀÇ Æ¯Á¤ ·¹½ÃÇÇ Á¤º¸¸¦ ¹ÞÀ½.
	int nModuleIndex		= pPacket->GetInt(0);		// AFM ¸ðµâÀÇ ¹øÈ£
	int nRecipeIndex		= pPacket->GetInt(1);		// ¿äûÇÑ Recipe ¹øÈ£
	int nZoomCount			= pPacket->GetInt(2);		// ¿äûÇÑ RecipeÀÇ ÁÜ °¹¼ö
	CString strRecipeName	= pPacket->GetString(0);	// ¿äûÇÑ RecipeÀÇ À̸§

	//g_pLog->DisplayMessage(_T("NetProcess_FC_RECIPE_INFO %d %d %d %s"), nModuleIndex, nRecipeIndex, nZoomCount, strRecipeName);

}

void CAfmControl_Dit::NetProcess_FC_SEND_BIT(CNetPacket* pPacket)
{
	int nIndex = pPacket->GetInt(0);
	int nSignalIndex = pPacket->GetInt(1);
	int nSignalData = pPacket->GetInt(2);

	switch(nSignalIndex)
	{
	case SB_SERVO_ON:
		break;

	case SB_ALARM:
		break;

	case SB_IN_MOTION:
		break;

	case SB_IN_POS:
		break;

	case SB_HOME:
		break;

	case SB_LIMIT_PLUS:
		break;

	case SB_LIMIT_MINUS:
		break;

	case SB_AF_ENABLE:
		m_nTracking = nSignalData;
		break;		
	}



}

void CAfmControl_Dit::NetProcess_FC_RECV_BIT(CNetPacket* pPacket)
{
	int nIndex = pPacket->GetInt(0);
	int nResultCode = pPacket->GetInt(1);
	int nSignalIndex = pPacket->GetInt(2);
	int nSignalData = pPacket->GetInt(3);

	switch(nSignalIndex)
	{
	case RB_ZOOM_INDEX:
		if (nSignalData!=-1) m_nZoomIndex = nSignalData;
		break;

	case RB_JOG_SPEED:
		break;

	case RB_HOME:
		break;

	case RB_JOG_COMMAND:
		break;

	case RB_AF_ENABLE:
		m_nTracking = nSignalData;
		break;		
	}

// 	if (m_pAFC2P)
// 	{
// 		m_pAFC2P->AFC2P_DisplayMessage(_T("NetProcess_FC_RECV_BIT %d %d %d %d"), nIndex, nResultCode, nSignalIndex, nSignalData);
// 	}
}
int	CAfmControl_Dit::NetProcess_FC_SEND_ALIVE()
{
	if (GetConnected()==FALSE) return 0;

	if (m_pClientSocket==NULL) return 0;

	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
	if (pSendPacket)
	{
		pSendPacket->SetInt(m_nIndex);
		return m_pClientSocket->SendToServer(CF_RECV_ALIVE, NET_RESULT_SUCCESS, m_nIndex, pSendPacket);
	}

	return 0;
}

BOOL	CAfmControl_Dit::NetProcess_FC_RECV_ALIVE(CNetPacket* packet)
{
	CTime currentTime;
	m_lastAliveTime = currentTime.GetTickCount();
	if (GetConnected()==TRUE)
	{
		m_bSetTime = TRUE;
	}
	else
	{
		m_bSetTime = FALSE;
	}
	return true;
}

int	CAfmControl_Dit::Connect(const CAfmControlInfo& controlInfo)
{
	m_bConnected = FALSE;
	m_ControlInfo = controlInfo;

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

	return 1;
}

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

	m_bConnected = FALSE;
}

int	CAfmControl_Dit::RecipeJogSpeed(double dSpeed)
{
	if (GetConnected()==FALSE) return 0;
	
	if (m_pClientSocket==NULL) return 0;

	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
	if (pSendPacket)
	{
		int nSpeed = int(dSpeed * 10000.0);
		pSendPacket->SetInt(m_nIndex);			// ModuleIndex
		pSendPacket->SetInt(RB_JOG_SPEED);		// Signal Type
		pSendPacket->SetInt(nSpeed);			// Signal Data
		return m_pClientSocket->SendToServer(CF_RECV_BIT, NET_RESULT_SUCCESS, m_nIndex, pSendPacket);
	}

	return 0;
}

int	CAfmControl_Dit::RecipeJogCommand(int nCmd)
{
	if (GetConnected()==FALSE) return 0;

	if (m_pClientSocket==NULL) return 0;

	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
	if (pSendPacket)
	{
		pSendPacket->SetInt(m_nIndex);			// ModuleIndex
		pSendPacket->SetInt(RB_JOG_COMMAND);	// Signal Type
		pSendPacket->SetInt(nCmd);				// Signal Data
		return m_pClientSocket->SendToServer(CF_RECV_BIT, NET_RESULT_SUCCESS, m_nIndex, pSendPacket);
	}

	return 0;
}
	
int	CAfmControl_Dit::RecipeTracking(int nTracking)
{
	if (GetConnected()==FALSE) return 0;

	if (m_pClientSocket==NULL) return 0;

	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
	if (pSendPacket)
	{
		pSendPacket->SetInt(m_nIndex);			// ModuleIndex
		pSendPacket->SetInt(RB_AF_ENABLE);		// Signal Type
		pSendPacket->SetInt(nTracking);			// Signal Data
		return m_pClientSocket->SendToServer(CF_RECV_BIT, NET_RESULT_SUCCESS, m_nIndex, pSendPacket);
	}

	return 0;
}


int	CAfmControl_Dit::RecipeZoom(int nZoomIndex)
{
	if (GetConnected()==FALSE) return 0;

	if (m_pClientSocket==NULL) return 0;

	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
	if (pSendPacket)
	{
		pSendPacket->SetInt(m_nIndex);			// ModuleIndex
		pSendPacket->SetInt(RB_ZOOM_INDEX);		// Signal Type
		pSendPacket->SetInt(nZoomIndex);		// Signal Data
		return m_pClientSocket->SendToServer(CF_RECV_BIT, NET_RESULT_SUCCESS, m_nIndex, pSendPacket);
	}

	return 0;
}

int	CAfmControl_Dit::RecipeChange(int nRecipeIndex, int nZoomIndex)
{
	if (GetConnected()==FALSE) return 0;

	if (m_pClientSocket==NULL) return 0;

	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
	if (pSendPacket)
	{
		pSendPacket->SetInt(m_nIndex);				// ModuleIndex
		pSendPacket->SetInt(nRecipeIndex);			// recipe index
		pSendPacket->SetInt(nZoomIndex);			// zoom index
		pSendPacket->SetString(m_strRecipeName);	// recipe name
		return m_pClientSocket->SendToServer(CF_RECV_RECIPE, NET_RESULT_SUCCESS, m_nIndex, pSendPacket);
	}

	return 0;
}

int	CAfmControl_Dit::RecipeChange(const CString& strRecipeName, int nZoomIndex)
{
	if (GetConnected()==FALSE) return 0;

	if (m_pClientSocket==NULL) return 0;

	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
	if (pSendPacket)
	{
		pSendPacket->SetInt(m_nIndex);				// ModuleIndex
		pSendPacket->SetInt(m_nRecipeIndex);		// recipe index
		pSendPacket->SetInt(nZoomIndex);			// zoom index
		pSendPacket->SetString(strRecipeName);		// recipe name
		return m_pClientSocket->SendToServer(CF_RECV_RECIPE, NET_RESULT_SUCCESS, m_nIndex, pSendPacket);
	}

	return 0;
}

BOOL CAfmControl_Dit::SetTracking(int nTracking)
{
	if (RecipeTracking(nTracking))
	{
		m_nTracking = nTracking;
		return TRUE;
	}

	return FALSE;
}

BOOL CAfmControl_Dit::SetZoomIndex(int nZoomIndex)
{
	if (RecipeZoom(nZoomIndex))
	{
		m_nZoomIndex = nZoomIndex;
		return TRUE;
	}

	return FALSE;
}

BOOL CAfmControl_Dit::SetRecipeIndex(int nRecipeIndex, int nZoomIndex)
{
	if (RecipeChange(nRecipeIndex, nZoomIndex))
	{
		m_nRecipeIndex = nRecipeIndex;
		m_nZoomIndex = nZoomIndex;
		return TRUE;
	}

	return FALSE;
}

BOOL CAfmControl_Dit::SetRecipeName(const CString& strRecipeName, int nZoomIndex)
{
	m_nRecipeIndex = nZoomIndex;

	if (RecipeChange(strRecipeName, nZoomIndex))
	{
		m_strRecipeName = strRecipeName;
		m_nZoomIndex = nZoomIndex;

		return TRUE;
	}

	return FALSE;
}

BOOL CAfmControl_Dit::SetSystemTime(SYSTEMTIME stCurrentTime)
{
	if (GetConnected()==FALSE) return 0;
	if (m_pClientSocket==NULL) return 0;

	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
	if (pSendPacket)
	{
		pSendPacket->SetInt(m_nIndex);					// ModuleIndex
		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

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

	return TRUE;
}

BOOL CAfmControl_Dit::GetTracking(int& nTracking) const
{
	if (GetConnected()==FALSE) return FALSE;

	nTracking = m_nTracking;

	return TRUE;
}

BOOL CAfmControl_Dit::GetZoomIndex(int& nZoomIndex) const
{
	if (GetConnected()==FALSE) return FALSE;

	nZoomIndex = m_nZoomIndex;

	return TRUE;
}

BOOL CAfmControl_Dit::GetRecipeIndex(int& nRecipeIdnex, int& nZoomIndex) const
{
	if (GetConnected()==FALSE) return FALSE;

	nRecipeIdnex = m_nRecipeIndex;

	nZoomIndex = m_nZoomIndex;

	return TRUE;
}

BOOL CAfmControl_Dit::GetRecipeName(CString& strRecipeName, int& nZoomIndex) const
{
	if (GetConnected()==FALSE) return FALSE;

	strRecipeName = strRecipeName;

	nZoomIndex = m_nZoomIndex;

	return TRUE;
}

BOOL CAfmControl_Dit::MoveToLimitPlus()
{
	return TRUE;
}

BOOL CAfmControl_Dit::MoveToLimitMinus()
{
	return TRUE;
}

int CAfmControl_Dit::MoveToHomePosition(int nHomePos)					// homing (move -limit)
{
	if (GetConnected()==FALSE) return 0;

	if (m_pClientSocket==NULL) return 0;

	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
	if (pSendPacket)
	{
		pSendPacket->SetInt(m_nIndex);				// ModuleIndex
		pSendPacket->SetInt(RB_HOME);				// Bit Command		
		return m_pClientSocket->SendToServer(CF_RECV_BIT, NET_RESULT_SUCCESS, m_nIndex, pSendPacket);
	} 

	return TRUE;
}


BOOL CAfmControl_Dit::MoveToBasePosition(int nZoomIndex)	// homing -> reference position
{
	if (GetConnected()==FALSE) return 0;

	if (m_pClientSocket==NULL) return 0;

	CNetPacket *pSendPacket = m_pClientSocket->GetPacket();
	if (pSendPacket)
	{
		pSendPacket->SetInt(m_nIndex);				// ModuleIndex
		pSendPacket->SetInt(RB_REF_POS);				// Bit Command		
		return m_pClientSocket->SendToServer(CF_RECV_BIT, NET_RESULT_SUCCESS, m_nIndex, pSendPacket);
	} 

	return TRUE;
}


BOOL CAfmControl_Dit::MoveToTargetPosition( double dPos )
{
	return TRUE;
}

int CAfmControl_Dit::GetAFMHomePosition(bool &bHome) const
{
	bHome = TRUE;
	return TRUE;
}

BOOL CAfmControl_Dit::GetInFocus( BOOL* pRtCheck )
{
	return TRUE;
}