#include "StdAfx.h"
#include "SignalControl_NetServer.h"
#include "SignalControl_Network.h"
#include "IOCPNetwork/NetServer.h"
#include "CHAutoDrsConnector/AutoDrsConnectorInfo.h"

using namespace CHSignalControls_Network;

CSignalControl_NetServer::CSignalControl_NetServer(ISignalControl_NetServer2Parent* pISCNS2P) : m_pISCNS2P(pISCNS2P)
{
	m_pMessageProcessor = new CMessageProcessor(static_cast<IMessageProcessor2Parent*>(this));
	m_pNetServer = new CNetServer();
	//InitNetwork();
}

CSignalControl_NetServer::~CSignalControl_NetServer(void)
{
	//DeinitNetwork();

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

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

BOOL CSignalControl_NetServer::InitNetwork()
{
	BOOL bResult = FALSE;

	if (m_pNetServer)
	{
		const int nClientCount = 4;
		m_pNetServer->SetIN2P(static_cast<IIOCPNetwork2Parent*>(this));
		m_pNetServer->SetClientInfo(Socket_SignalClient, nClientCount, NETCODE_NETWORK_SIGNAL, NETVER_NETWORK_SIGNAL, FALSE,1004);

		bResult = m_pNetServer->InitNetwork(ServerMode, nClientCount, NETPORT_NETWORK_SIGNAL, _T(""), TRUE);
	}

	if (m_pISCNS2P)
	{
		if (bResult)
		{
			m_pISCNS2P->ISCNS2P_DisplayMessage(_T("[SignalControl_NetServer] Init NetServer Success!"));
		}
		else
		{
			m_pISCNS2P->ISCNS2P_DisplayMessage(_T("[SignalControl_NetServer] Init NetServer Fail!"));
		}
	}

	return bResult;
}

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

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

void CHSignalControls_Network::CSignalControl_NetServer::IOCPNet2P_Connected( int Type )
{
	if (m_pISCNS2P)
	{
		m_pISCNS2P->ISCNS2P_DisplayMessage(_T("[SignalControl_NetServer] [%d]TypeClient is Connected!"), Type);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::IOCPNet2P_Disconnected( int Type, int nModuleNo /*= -1*/ )
{
	if (m_pISCNS2P)
	{
		m_pISCNS2P->ISCNS2P_DisplayMessage(_T("[SignalControl_NetServer] [%d]Client is Disconnected!"), nModuleNo);
	}
}

BOOL CHSignalControls_Network::CSignalControl_NetServer::IOCPNet2P_Received( int Type, CNetPacket* pPacket, int nContext /*= -1*/ )
{
	CSingleLock myLock(&m_csReceivePacket);
	myLock.Lock();
	
	if (m_pMessageProcessor==NULL) return FALSE;

	if (pPacket==NULL)  return FALSE;

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

	default:
		return FALSE;
		break;
	}

	return TRUE;
}

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

	if (m_pISCNS2P==NULL) return;

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

	CString strLog = _T("");

	switch(pData->m_unMsg)
	{
	case SC2SS_MODULE_INDEX:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [MODULE_INDEX] Message Received!"), pPacket->GetModuleNo());
		Process_ModuleIndex(pPacket->GetModuleNo(), nContext);
		break;

	case SC2SS_COMMAND_LIGHT:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_LIGHT] Message Received!"), pPacket->GetModuleNo());
		Process_CommandLight(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_COMMAND_LENS:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_LENS] Message Received!"), pPacket->GetModuleNo());
		Process_CommandLens(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_COMMAND_MOTOR_GO:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_MOTOR_GO] Message Received!"), pPacket->GetModuleNo());
		Process_CommandMotorGo(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_COMMAND_GLASS_GO:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_GLASS_GO] Message Received!"), pPacket->GetModuleNo());
		Process_CommandGlassGo(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_COMMAND_JOG:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_JOG] Message Received!"), pPacket->GetModuleNo());
		Process_CommandJog(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_COMMAND_JOG_SPEED:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_JOG_SPEED] Message Received!"), pPacket->GetModuleNo());
		Process_CommandJogSpeed(pPacket->GetModuleNo(), pPacket);
		break;
		
	case SC2SS_COMMAND_AFM:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_AFM] Message Received!"), pPacket->GetModuleNo());
		Process_CommandAfm(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_COMMAND_AFM_JOG:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_AFM_JOG] Message Received!"), pPacket->GetModuleNo());
		Process_CommandAfmJog(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_COMMAND_AFM_JOG_SPEED:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_AFM_SPEED] Message Received!"), pPacket->GetModuleNo());
		Process_CommandAfmJogSpeed(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_COMMAND_AFM_HOME:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_AFM_HOME] Message Received!"), pPacket->GetModuleNo());
		Process_CommandAfmHome(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_ACK_STATUS_LIGHT:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_STATUS_LIGHT] Message Received!"), pPacket->GetModuleNo());
		Process_AckStatusLight(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_ACK_STATUS_LENS:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_STATUS_LENS] Message Received!"), pPacket->GetModuleNo());
		Process_AckStatusLens(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_ACK_STATUS_MODULE_POS:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_STATUS_MODULE_POS] Message Received!"), pPacket->GetModuleNo());
		Process_AckStatusModulePos(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_ACK_STATUS_JOG_SPEED:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_STATUS_JOG_SPEED] Message Received!"), pPacket->GetModuleNo());
		Process_AckStatusJogSpeed(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_ACK_STATUS_AFM:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_STATUS_AFM] Message Received!"), pPacket->GetModuleNo());
		Process_AckStatusAfm(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_ACK_COMMAND_LOADING:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_COMMAND_LOADING] Message Received!"), pPacket->GetModuleNo());
		Process_AckCommandLoading(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_ACK_COMMAND_REVIEWRESULT:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_COMMAND_REVIEWRESULT] Message Received!"), pPacket->GetModuleNo());
		Process_AckCommandReviewResult(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_ACK_COMMAND_PLANSTART:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_COMMAND_PLANSTART] Message Received!"), pPacket->GetModuleNo());
		Process_AckCommandPlanStart(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_ACK_COMMAND_PLANEND:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_COMMAND_PLANEND] Message Received!"), pPacket->GetModuleNo());
		Process_AckCommandPlanEnd(pPacket->GetModuleNo(), pPacket);
		break;

	case SC2SS_STATUS_REVIEWRESULT:
		strLog.Format(_T("[SignalControl_NetServer] [%d]Client [STATUS_REVIEWRESULT] Message Received!"), pPacket->GetModuleNo());
		Process_StatusReviewResult(pPacket->GetModuleNo(), pPacket);
		break;
	}

	if (m_pISCNS2P)
	{
		m_pISCNS2P->ISCNS2P_DisplayMessage(strLog);
	}

	delete pPacket;
}

void CSignalControl_NetServer::Process_ModuleIndex(int nModuleIndex, int nContext)
{
	if (m_pISCNS2P==NULL || 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(nModuleIndex, FALSE);
			return;
		}
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandLight( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pNetServer==NULL || pPacket==NULL) return;

	m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_LIGHT, NET_RESULT_SUCCESS);

	if (m_pISCNS2P)
	{
		int nLevel = pPacket->GetInt(0);
		m_pISCNS2P->ISCNS2P_CommandLight(nModuleIndex, nLevel);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandLens( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pNetServer==NULL || pPacket==NULL) return;

	m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_LENS, NET_RESULT_SUCCESS);

	if (m_pISCNS2P)
	{
		int nLevel = pPacket->GetInt(0);
		m_pISCNS2P->ISCNS2P_CommandLens(nModuleIndex, nLevel);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandMotorGo( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pNetServer==NULL || pPacket==NULL) return;

	m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_MOTOR_GO, NET_RESULT_SUCCESS);

	if (m_pISCNS2P)
	{
		int nPosUmX = pPacket->GetInt(0);
		int nPosUmY = pPacket->GetInt(1);
		m_pISCNS2P->ISCNS2P_CommandMotorGo(nModuleIndex, nPosUmX, nPosUmY);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandGlassGo( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pNetServer==NULL || pPacket==NULL) return;

	m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_GLASS_GO, NET_RESULT_SUCCESS);

	if (m_pISCNS2P)
	{
		int nPosUmX = pPacket->GetInt(0);
		int nPosUmY = pPacket->GetInt(1);
		m_pISCNS2P->ISCNS2P_CommandGlassGo(nModuleIndex, nPosUmX, nPosUmY);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandJog( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pNetServer==NULL || pPacket==NULL) return;

	m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_JOG, NET_RESULT_SUCCESS);

	if (m_pISCNS2P)
	{
		int nJog = pPacket->GetInt(0);
		m_pISCNS2P->ISCNS2P_CommandJog(nModuleIndex, nJog);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandJogSpeed( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pNetServer==NULL || pPacket==NULL) return;

	m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_JOG_SPEED, NET_RESULT_SUCCESS);

	if (m_pISCNS2P)
	{
		int nSpeed = pPacket->GetInt(0);
		m_pISCNS2P->ISCNS2P_CommandJogSpeed(nModuleIndex, nSpeed);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandAfm( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pNetServer==NULL || pPacket==NULL) return;

	m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_AFM, NET_RESULT_SUCCESS);

	if (m_pISCNS2P)
	{
		int nAfm = pPacket->GetInt(0);
		m_pISCNS2P->ISCNS2P_CommandAfm(nModuleIndex, nAfm);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandAfmJog( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pNetServer==NULL || pPacket==NULL) return;

	m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_AFM_JOG, NET_RESULT_SUCCESS);

	if (m_pISCNS2P)
	{
		int nJog = pPacket->GetInt(0);
		m_pISCNS2P->ISCNS2P_CommandAfmJog(nModuleIndex, nJog);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandAfmJogSpeed( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pNetServer==NULL || pPacket==NULL) return;

	m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_AFM_JOG_SPEED, NET_RESULT_SUCCESS);

	if (m_pISCNS2P)
	{
		int nSpeed = pPacket->GetInt(0);
		m_pISCNS2P->ISCNS2P_CommandAfmJogSpeed(nModuleIndex, nSpeed);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandAfmHome( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pNetServer==NULL || pPacket==NULL) return;

	m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_AFM_HOME, NET_RESULT_SUCCESS);

	if (m_pISCNS2P)
	{
		int nAfmHome = pPacket->GetInt(0);
		m_pISCNS2P->ISCNS2P_CommandAfmHome(nModuleIndex);
	}
}

// status
void CHSignalControls_Network::CSignalControl_NetServer::Process_StatusReviewResult( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pNetServer==NULL || pPacket==NULL) return;

	m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_STATUS_REVIEWRESULT, NET_RESULT_SUCCESS);

	if (m_pISCNS2P)
	{
		int nModuleIndex = pPacket->GetInt(0);
		int nPlanIndex = pPacket->GetInt(1);
		int nResultCount = pPacket->GetInt(2);
		CSignalControlResultData* pResultData = (CSignalControlResultData*)pPacket->GetBuffer();
		m_pISCNS2P->ISCNS2P_StatusReviewResult(nModuleIndex, nPlanIndex, nResultCount, pResultData);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_AckStatusLight( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pISCNS2P)
	{
		m_pISCNS2P->ISCNS2P_AckStatusLight(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_AckStatusLens( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pISCNS2P)
	{
		m_pISCNS2P->ISCNS2P_AckStatusLens(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_AckStatusModulePos( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pISCNS2P)
	{
		m_pISCNS2P->ISCNS2P_AckStatusModulePos(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_AckStatusJogSpeed( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pISCNS2P)
	{
		m_pISCNS2P->ISCNS2P_AckStatusJogSpeed(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_AckStatusAfm( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pISCNS2P)
	{
		m_pISCNS2P->ISCNS2P_AckStatusAfm(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_AckCommandLoading( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pISCNS2P)
	{
		m_pISCNS2P->ISCNS2P_AckCommandLoading(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_AckCommandReviewResult( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pISCNS2P)
	{
		m_pISCNS2P->ISCNS2P_AckCommandReviewResult(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_AckCommandPlanStart( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pISCNS2P)
	{
		m_pISCNS2P->ISCNS2P_AckCommandPlanStart(nModuleIndex);
	}
}

void CHSignalControls_Network::CSignalControl_NetServer::Process_AckCommandPlanEnd( int nModuleIndex, CNetPacket *pPacket )
{
	if (m_pISCNS2P)
	{
		m_pISCNS2P->ISCNS2P_AckCommandPlanStart(nModuleIndex);
	}
}

int CHSignalControls_Network::CSignalControl_NetServer::Send_StatusLight( int nModuleIndex, int nLight )
{
	if (m_pNetServer==NULL) return 0;

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

	pPacket->SetInt(nLight);

	return m_pNetServer->SendToClient(nModuleIndex, SS2SC_STATUS_LIGHT, NET_RESULT_SUCCESS, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetServer::Send_StatusLens( int nModuleIndex, int nLens )
{
	if (m_pNetServer==NULL) return 0;

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

	pPacket->SetInt(nLens);

	return m_pNetServer->SendToClient(nModuleIndex, SS2SC_STATUS_LENS, NET_RESULT_SUCCESS, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetServer::Send_StatusModulePos( int nModuleIndex, int nPosUmX, int nPosUmY )
{
	if (m_pNetServer==NULL) return 0;

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

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

	return m_pNetServer->SendToClient(nModuleIndex, SS2SC_STATUS_MODULE_POS, NET_RESULT_SUCCESS, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetServer::Send_StatusJogSpeed( int nModuleIndex, double dJogSpeed )
{
	if (m_pNetServer==NULL) return 0;

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

	pPacket->SetDouble(dJogSpeed);

	return m_pNetServer->SendToClient(nModuleIndex, SS2SC_STATUS_JOG_SPEED, NET_RESULT_SUCCESS, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetServer::Send_StatusAfm( int nModuleIndex, int nAfm )
{
	if (m_pNetServer==NULL) return 0;

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

	pPacket->SetInt(nAfm);

	return m_pNetServer->SendToClient(nModuleIndex, SS2SC_STATUS_AFM, NET_RESULT_SUCCESS, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetServer::Send_CommandLoading( char* pTrasferData )
{
	if (m_pNetServer==NULL) return 0;

	BOOL bRetValue = TRUE;

	int nClientCount= m_pNetServer->GetClientCount();
	for (int nIdx=0; nIdx<nClientCount; nIdx++)
	{
		CNetPacket *pPacket = m_pNetServer->GetPacket();
		if (pPacket==NULL) continue;

		int nSize = sizeof(SDrsTransferData);
		pPacket->SetBuffer(nSize, pTrasferData);

		bRetValue = bRetValue & m_pNetServer->SendToClient(nIdx, SS2SC_COMMAND_LOADING, NET_RESULT_SUCCESS, pPacket);
	}

	return bRetValue;
}

int CHSignalControls_Network::CSignalControl_NetServer::Send_CommandReviewResult( int nModuleIndex, int nPlanIndex, int nResultCount, char* pResultData, int nMagLevel , int nDrsEtcCount)
{
	if (m_pNetServer==NULL) return 0;

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

	pPacket->SetInt(nModuleIndex);
	pPacket->SetInt(nPlanIndex);
	pPacket->SetInt(nResultCount);
	pPacket->SetInt(nMagLevel);
	pPacket->SetInt(nDrsEtcCount);
	pPacket->SetBuffer(sizeof(CSignalControlResultData)*nResultCount, pResultData);

	return m_pNetServer->SendToClient(nModuleIndex, SS2SC_COMMAND_REVIEWRESULT, NET_RESULT_SUCCESS, pPacket);
}

int CHSignalControls_Network::CSignalControl_NetServer::Send_CommandPlanStart( int nPlanIndex )
{
	if (m_pNetServer==NULL) return 0;

	BOOL bRetValue = TRUE;

	int nClientCount= m_pNetServer->GetClientCount();
	for (int nIdx=0; nIdx<nClientCount; nIdx++)
	{
		CNetPacket *pPacket = m_pNetServer->GetPacket();
		if (pPacket==NULL) continue;

		pPacket->SetInt(nPlanIndex);

		bRetValue = bRetValue & m_pNetServer->SendToClient(nIdx, SS2SC_COMMAND_PLANSTART, NET_RESULT_SUCCESS, pPacket);
	}

	return bRetValue;
}

int CHSignalControls_Network::CSignalControl_NetServer::Send_CommandPlanEnd( int nPlanIndex )
{
	if (m_pNetServer==NULL) return 0;

	BOOL bRetValue = TRUE;

	int nClientCount= m_pNetServer->GetClientCount();
	for (int nIdx=0; nIdx<nClientCount; nIdx++)
	{
		CNetPacket *pPacket = m_pNetServer->GetPacket();
		if (pPacket==NULL) continue;

		pPacket->SetInt(nPlanIndex);

		bRetValue = bRetValue & m_pNetServer->SendToClient(nIdx, SS2SC_COMMAND_PLANEND, NET_RESULT_SUCCESS, pPacket);
	}

	return bRetValue;
}