// 
// CServerSocket.cpp
// 

#include "stdafx.h"
#include <streams.h>
#include "CServerSocket.h"
#include "GlobalDefs.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

//////////////////////////////////////////////////////////////////////////////
CServerSocket::CServerSocket()
{
	mListener  = INVALID_SOCKET;
    mAccepted = INVALID_SOCKET;
	mIsReceiving = FALSE;
	mIsConnected = FALSE;
	mRcvThread   = NULL;
	mLsnThread   = NULL;
	mListenPort  = 10080;
	mIsListening = FALSE;

}

CServerSocket::~CServerSocket()
{

	DeleteAccepted();
	DeleteListener();
	StopListening();
	StopReceiving();
}

SOCKET CServerSocket::GetSocket(void)
{	
	SOCKET ret   = mAccepted;
	mAccepted      = INVALID_SOCKET;
	return ret;		
}
BOOL CServerSocket::Create(void)
{
	DeleteListener();

	int  val  = 0;
	BOOL pass = FALSE;

	mListener = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (mListener != INVALID_SOCKET)
	{
		// Settings on socket
		BOOL  sopt = TRUE;
		setsockopt(mListener, IPPROTO_TCP, TCP_NODELAY, 
			(char *)&sopt, sizeof(BOOL));
		setsockopt(mListener, SOL_SOCKET, SO_DONTLINGER, 
			(char *)&sopt, sizeof(BOOL));

		// Bind socket and listen
		SOCKADDR_IN  addr;
		memset(&addr, 0, sizeof(SOCKADDR_IN));
		addr.sin_family      = AF_INET;
		addr.sin_addr.s_addr = htonl(INADDR_ANY);
		addr.sin_port        = htons(mListenPort);
		val = bind(mListener, (struct sockaddr*) &addr, sizeof(addr));
		pass = (val != SOCKET_ERROR);
	}

	if (pass)
	{
		// Put the socket into the listening status
		val = listen(mListener, SOMAXCONN);
		pass = (val != SOCKET_ERROR);
	}

	if (!pass)
	{
		DeleteListener();
	}
	return pass;
}
BOOL CServerSocket::StartListening(void)
{
	// Create socket if necessary
	if (mListener == INVALID_SOCKET)
	{
		Create();
	}

	if (mListener != INVALID_SOCKET)
	{
		if (mIsListening)
		{
			return TRUE;
		}

		DWORD threadID = 0;
		mLsnThread = CreateThread(NULL, 0, ListeningThrd, 
			this, 0, &threadID);
		return (mLsnThread != NULL);
	}

	return FALSE;
}
DWORD WINAPI CServerSocket::ListeningThrd(void *pParam)
{
	ASSERT(pParam);

	CServerSocket * pListen = (CServerSocket *) pParam;
	pListen->mIsListening  = TRUE;
	while (pListen->mIsListening)
	{
		if (!pListen->Accept())
		{
			pListen->mIsListening = FALSE;
			break;
		}
	}

	return 1;
}
BOOL CServerSocket::Accept(void)
{
	if (mListener != INVALID_SOCKET)
	{
		SOCKADDR_IN  saddr;
		int len = sizeof(SOCKADDR_IN);
		SOCKET accepted = accept(mListener, (SOCKADDR *)&saddr, &len);
		if (accepted == INVALID_SOCKET)
		{
			return FALSE;
		}
		
		if (mAccepted == INVALID_SOCKET)
		{
			mAccepted = accepted;
			// Settings on socket
			BOOL sopt = TRUE;
			setsockopt(accepted, IPPROTO_TCP, TCP_NODELAY, 
				(char *)&sopt, sizeof(BOOL));
			setsockopt(accepted, SOL_SOCKET, SO_DONTLINGER, 
				(char *)&sopt, sizeof(BOOL));
			// Send a message to the controller
			Broadcast(msg_NewSocketAccepted);
			return TRUE;
			
		}
		else
		{
			closesocket(accepted);
		}
	}
	return FALSE;
}

BOOL CServerSocket::StartReceiving(void)
{
	if (mAccepted != INVALID_SOCKET)
	{
		if (mIsReceiving)
		{
			return TRUE;
		}

		DWORD threadID = 0;
		mRcvThread = CreateThread(NULL, 0, ReceivingThrd, 
			this, 0, &threadID);
		return (mRcvThread != NULL);
	}
	return FALSE;
}

void CServerSocket::StopReceiving(void)
{
	if (mIsReceiving)
	{
		DeleteAccepted();
		if (mRcvThread != NULL) 
		{
            WaitForSingleObject(mRcvThread, INFINITE);
			mRcvThread = NULL;
		}
	}
}

DWORD WINAPI CServerSocket::ReceivingThrd(void * pParam)
{
	CServerSocket * pSock = (CServerSocket *) pParam;
	if (pSock)
	{
		pSock->mIsReceiving = TRUE;
		pSock->ReceivingLoop();
		return 1;
	}	
	return 0;
}
void CServerSocket::ReceivingLoop(void)
{
	char buffer[MAX_COMMAND_SIZE];
	long bytes = 0;

	mIsReceiving = TRUE;
	while (mIsReceiving)
	{				
		bytes = recv(mAccepted, (char *)buffer, MAX_COMMAND_SIZE, 0);
		if (bytes == SOCKET_ERROR || bytes == 0)
		{
			mIsReceiving = FALSE;
		}
		else
		{
			Broadcast(msg_CommandReceived, buffer);
		}
	}

}
BOOL CServerSocket::Send(const char * inBuffer, long inLength)
{
	if(mAccepted)
	{

		int val = send(mAccepted, inBuffer, inLength, 0);
		return (val != SOCKET_ERROR);
	}
	else
		return FALSE;
}
void CServerSocket::DeleteListener(void)
{
	if (mListener != INVALID_SOCKET)
	{
		closesocket(mListener);
		mListener = INVALID_SOCKET;
	}
}

void CServerSocket::DeleteAccepted(void)
{
	
		if (mAccepted != INVALID_SOCKET)
		{
			closesocket(mAccepted);
			mAccepted = INVALID_SOCKET;
		}
	
}	
void CServerSocket::StopListening(void)
{
	if (mListener != INVALID_SOCKET && mIsListening)
	{
		DeleteListener();
		// Make sure the receiving thread has been terminated 
		if (mLsnThread != NULL) 
		{
            WaitForSingleObject(mLsnThread, INFINITE);
			mLsnThread = NULL;
		}
	}
}
void CServerSocket::SetListenPort(WORD inPort)
{
	mListenPort = inPort;
}

WORD CServerSocket::GetListenPort(void)
{
	return mListenPort;
}
BOOL CServerSocket::IsSocketReady(void)
{

		if (mAccepted == INVALID_SOCKET)
		{
			return FALSE;
		}
	
	return TRUE;
}
//DEL void CServerSocket::Detach(void)
//DEL {
//DEL 	if (mAccepted != INVALID_SOCKET)
//DEL 	{
//DEL 		closesocket(mAccepted);
//DEL 		mAccepted = INVALID_SOCKET;
//DEL 		mIsConnected = FALSE;
//DEL 	}
//DEL }

void CServerSocket::SetSocket(SOCKET inSocket)
{
	mAccepted=inSocket;
	mIsConnected=TRUE;
}