/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

// ServerManager.cpp: implementation of the CServerManager class.

//

//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "ServerManager.h"

#include "ConnectionImpl.h"

#include "resource.h"

#ifdef _DEBUG

extern BOOL gDoLogging;

#endif

#define LOG_SERVERMANAGER

#if defined(LOG_SERVERMANAGER) && defined(_DEBUG)

extern char TCDebugMsg[];

#define TCDEBUGOPEN() if (gDoLogging) { m_DebugLog->WaitForAccess(); }

#define TCDEBUGLOGS(s) if (gDoLogging) { sprintf(TCDebugMsg,"%s", s); m_DebugLog->log(TCDebugMsg); }

#define TCDEBUGLOGA1(s, a1) if (gDoLogging) { sprintf(TCDebugMsg, s, a1); m_DebugLog->log(TCDebugMsg); }

#define TCDEBUGLOGA2(s, a1, a2) if (gDoLogging) { sprintf(TCDebugMsg, s, a1, a2); m_DebugLog->log(TCDebugMsg); }

#define TCDEBUGLOGA3(s, a1, a2, a3) if (gDoLogging) { sprintf(TCDebugMsg, s, a1, a2, a3); m_DebugLog->log(TCDebugMsg); }

#define TCDEBUGCLOSE() if (gDoLogging) { m_DebugLog->ReleaseAccess(); }

#else

#define TCDEBUGOPEN()

#define TCDEBUGLOGS(s)

#define TCDEBUGLOGA1(s, a1)

#define TCDEBUGLOGA2(s, a1, a2)

#define TCDEBUGLOGA3(s, a1, a2, a3)

#define TCDEBUGCLOSE()

#endif

extern char* gServerLocation;

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

CServerManager::CServerManager()

{

	m_DebugLog = NULL;

	m_Server = NULL;

	m_ConnectionList = NULL;

	m_ClientList = NULL;

	m_NextClientId = 0;

	m_NextConnectionId = 0;

	m_Version[0] = NULL;

	m_ExeLocation = NULL;

	m_ProtocolList = NULL;

	m_CommList = NULL;

}

CServerManager::CServerManager(const char* exeLocation)

{

#ifdef _DEBUG

	if (gDoLogging)

		m_DebugLog = new TCDebugLog("TCF_ServerLog", ::GetCurrentProcessId());

	else

		m_DebugLog = NULL;

#else

	m_DebugLog = NULL;

#endif

	TCDEBUGOPEN();

	TCDEBUGLOGS("CServerManager::CServerManager\n");

	m_Server = new CServerCommand();

	m_ConnectionList = new ConnectionList();

	m_ConnectionList->clear();

	m_ClientList = new ClientList();

	m_ClientList->clear();

	m_NextClientId = ::GetCurrentProcessId() * 100;

	m_NextConnectionId = (::GetCurrentProcessId() * 100) + 100;

	int ret = ::LoadString(::GetModuleHandle(NULL), IDS_VERSION, m_Version, MAX_VERSION_STRING);

	TCDEBUGLOGA1(" version=%s\n", m_Version);

	TCDEBUGLOGA1(" exeLocation=%s\n", exeLocation);

	m_ExeLocation = new char[MAX_EXEPATHNAME];

	m_ExeLocation[0] = '\0';

	strcpy(m_ExeLocation, exeLocation);

	TCDEBUGLOGA1(" m_ExeLocation=%s\n", m_ExeLocation);

	m_ProtocolList = new ProtocolRegistry();

	m_ProtocolList->clear();

	m_CommList = new CommRegistry();

	m_CommList->clear();

	TCDEBUGCLOSE();

}

CServerManager::~CServerManager()

{

	TCDEBUGOPEN();

	TCDEBUGLOGS("CServerManager::~CServerManager\n");

	if (m_Server)

		delete m_Server;

	if (m_ConnectionList)

	{

		m_ConnectionList->clear();

		delete m_ConnectionList;

	}

	if (m_ClientList)

	{

		m_ClientList->clear();

		delete m_ClientList;

	}

	if (m_ExeLocation)

		delete[] m_ExeLocation;

	if (m_ProtocolList)

	{

		m_ProtocolList->clear();

		delete m_ProtocolList;

	}

	if (m_CommList)

	{

		m_CommList->clear();

		delete m_CommList;

	}

	TCDEBUGCLOSE();

	if (m_DebugLog)

		delete m_DebugLog;

}

void CServerManager::CommandThread()

{

	TCDEBUGOPEN();

	TCDEBUGLOGS("CServerManager::CommandThread\n");

	TCDEBUGCLOSE();

	bool done = false;

	eServerCommand command = eCmdNone;

	ServerCommandData cmdrsp; pServerCommandData pCmdrsp = &cmdrsp;

	pServerMessageData pMsg = new ServerMessageData();

	TCDEBUGOPEN();

	RegisterAllProtocols();

	RegisterAllComms();

	TCDEBUGCLOSE();

	while(!done)

	{

		while(!m_Server->GetCommand(pCmdrsp, pMsg))

		{

			Sleep(1);

		}

		command = pCmdrsp->command;

		switch(command)

		{

		case eCmdConnect:

			{

	TCDEBUGOPEN();

				TCDEBUGLOGS(" eCmdConnect\n");

	TCDEBUGCLOSE();

				long ret = TCAPI_ERR_NONE;

				BOOL connCreated = FALSE;

				CConnectionImpl* conn = (CConnectionImpl*)FindConnection(&pCmdrsp->connectSettings);

				if (conn == NULL)

				{

					// create new one

					DWORD connId = m_NextConnectionId;

					conn = new CConnectionImpl(pCmdrsp->connectSettings, connId);

					TCDEBUGOPEN();

					const char* commPath = FindCommPath(pCmdrsp->connectSettings.connectType);

					TCDEBUGCLOSE();

					TCDEBUGOPEN();

					const char* protPath = FindProtocolPath(pCmdrsp->connectSettings.decodeFormat);

					TCDEBUGCLOSE();

					if (protPath == NULL || commPath == NULL)

					{

						ret = TCAPI_ERR_UNKNOWN_MEDIA_TYPE;

					}

					else

					{

						if (conn->CreateCommProtocols(commPath, protPath))

						{

							connCreated = TRUE;

						}

						else

						{

							ret = TCAPI_ERR_UNKNOWN_MEDIA_TYPE;

						}

					}

				}

				if (ret == TCAPI_ERR_NONE && (conn->IsDisconnected() || conn->IsRetryTimedOut()))

				{

					ret = conn->DoConnect();

				}

				if (ret == TCAPI_ERR_NONE)

				{

					DWORD id = m_NextClientId++;

					// create client

					CClient* client = new CClient(conn, pCmdrsp->clientOptions, id);

					// add client to connection's list

					conn->AddClient(client);

					// add client to total list

					m_ClientList->push_back(client);

					// add connection to connection list

					if (connCreated)

						m_ConnectionList->push_back(conn);

					m_NextConnectionId++;

					pCmdrsp->response = eRspOK;

					pCmdrsp->clientId = id;

					m_Server->SendResponse(pCmdrsp);

				}

				else

				{

					if (conn->m_OsError > 0)

						pCmdrsp->osError = conn->m_OsError;

					else

						pCmdrsp->osError = 0;

					if (connCreated)

						delete conn;

					pCmdrsp->response = eRspError;

					pCmdrsp->error = ret;

					m_Server->SendResponse(pCmdrsp);

				}

			}

			break;

		case eCmdDisconnect:

			{

	TCDEBUGOPEN();

				TCDEBUGLOGS(" eCmdDisconnect\n");

	TCDEBUGCLOSE();

				DWORD id = pCmdrsp->clientId;

				// find this client in our list

				CClient* client = FindClient(id);

				if (client)

				{

					// get the connection for this client

					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();

					// pause the processing so we can delete the client 

					conn->PauseProcessing();

					// stop processing this client

					client->Stop();

					// remove client from registry

					conn->RemoveClientFromRegistry(client);

					// remove from connections client list

					conn->RemoveClient(client);

					// remove from total client list

					RemoveClient(client);

					// delete client

					delete client;

					// no more clients on this connection, disconnect this connection

					if (conn->GetNumberClients() == 0)

					{

						conn->ExitProcessing();

						conn->DoDisconnect();

						RemoveConnection(conn);

						delete conn;

					}

					else

					{

						conn->RestartProcessing();

					}

				}

				pCmdrsp->response = eRspOK;

				m_Server->SendResponse(pCmdrsp);

			}

			break;

		case eCmdSetMessageIds:

			{

	TCDEBUGOPEN();

				TCDEBUGLOGS(" eCmdSetMessageIds\n");

	TCDEBUGCLOSE();

				long ret = TCAPI_ERR_NONE;

				DWORD id = pCmdrsp->clientId;

				bool restart = false;

				// find client

				CClient* client = FindClient(id);

				if (client)

				{

					// get connection

					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();

					if (conn->IsProcessingContinuing())

					{

						conn->PauseProcessing();

						restart = true;

					}

					if (conn->IsDisconnected())

					{

						ret = TCAPI_ERR_MEDIA_NOT_OPEN;

					}

					else if (conn->IsRetryInProgress())

					{

						ret = TCAPI_ERR_COMM_RETRY_IN_PROGRESS;

					}

					else if (conn->IsRetryTimedOut())

					{

						ret = TCAPI_ERR_COMM_TIMEOUT;

					}

					if (ret == TCAPI_ERR_NONE)

					{

						// add client to connection's registry

						conn->AddClientToRegistry(client, pCmdrsp->number, pCmdrsp->messageIds);

					}

					if (restart)

						conn->RestartProcessing();

				}

				if (ret == TCAPI_ERR_NONE)

				{

					pCmdrsp->response = eRspOK;

				}

				else

				{

					pCmdrsp->response = eRspError;

					pCmdrsp->error = ret;

				}

				m_Server->SendResponse(pCmdrsp);

			}

			break;

		case eCmdGetNumberConnections:

			{

	TCDEBUGOPEN();

				TCDEBUGLOGS(" eCmdGetNumberConnections\n");

	TCDEBUGCLOSE();

				long num = m_ConnectionList->size();

				pCmdrsp->response = eRspOK;

				pCmdrsp->numConnections = num;

				m_Server->SendResponse(pCmdrsp);

			}

			break;

		case eCmdGetConnectionType:

			{

	TCDEBUGOPEN();

				TCDEBUGLOGS(" eCmdGetConnectionType\n");

	TCDEBUGCLOSE();

				long index = pCmdrsp->index;

				CConnectionImpl* pConn = (CConnectionImpl*)FindConnection(index);

				if (pConn != NULL)

				{

					pCmdrsp->response = eRspOK;

					strncpy(pCmdrsp->connectSettings.connectType, pConn->m_ConnectSettings->connectType, MAX_CONNECTION_TYPE);

//					pCmdrsp->connectSettings.connectType = pConn->m_ConnectSettings->connectType;

					m_Server->SendResponse(pCmdrsp);

				}

				else

				{

					pCmdrsp->response = eRspError;

					pCmdrsp->error = TCAPI_ERR_MISSING_CONNECTION_SPEC;

					m_Server->SendResponse(pCmdrsp);

				}

			}

			break;

		case eCmdOpenStream:

			{

	TCDEBUGOPEN();

				TCDEBUGLOGS(" eCmdOpenStream\n");

	TCDEBUGCLOSE();

				long ret = TCAPI_ERR_NONE;

				// find client

				DWORD id = pCmdrsp->clientId;

				CClient* client = FindClient(id);

				if (client)

				{

					// get connection

					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();

					if (conn->IsDisconnected())

					{

						ret = TCAPI_ERR_MEDIA_NOT_OPEN;

					}

					else if (conn->IsRetryInProgress())

					{

						ret = TCAPI_ERR_COMM_RETRY_IN_PROGRESS;

					}

					else if (conn->IsRetryTimedOut())

					{

						ret = TCAPI_ERR_COMM_TIMEOUT;

					}

					if (ret == TCAPI_ERR_NONE)

					{

						bool restart = false;

						if (conn->IsProcessingContinuing())

						{

							restart = true;

							conn->PauseProcessing();

						}

						client->OpenStream(&pCmdrsp->destinationOptions);

						if (restart)

							conn->RestartProcessing();

					}

				}

				if (ret == TCAPI_ERR_NONE)

				{

					pCmdrsp->response = eRspOK;

				}

				else

				{

					pCmdrsp->response = eRspError;

					pCmdrsp->error = ret;

				}

				m_Server->SendResponse(pCmdrsp);

			}

			break;

		case eCmdCloseStream:

			{

	TCDEBUGOPEN();

				TCDEBUGLOGS(" eCmdCloseStream\n");

	TCDEBUGCLOSE();

				long ret = TCAPI_ERR_NONE;

				DWORD id = pCmdrsp->clientId;

				bool restart = false;

				CClient* client = FindClient(id);

				if (client)

				{

					// get connection

					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();

					if (conn->IsConnected())

					{

						if (!conn->IsRetryTimedOut() && !conn->IsRetryInProgress())

						{

							if (conn->IsProcessingContinuing())

							{

								conn->PauseProcessing();

								restart = true;

							}

						}

						client->CloseStream();

						if (!conn->IsRetryTimedOut() && !conn->IsRetryInProgress())

						{

							if (restart)

								conn->RestartProcessing();

						}

					}

				}

				if (ret == TCAPI_ERR_NONE)

				{

					pCmdrsp->response = eRspOK;

				}

				else

				{

					pCmdrsp->response = eRspError;

					pCmdrsp->error = ret;

				}

				m_Server->SendResponse(pCmdrsp);

			}

			break;

		case eCmdOpenMessageFile:

			{

	TCDEBUGOPEN();

				TCDEBUGLOGS(" eCmdOpenMessageFile\n");

	TCDEBUGCLOSE();

				long ret = TCAPI_ERR_NONE;

				// find client

				DWORD id = pCmdrsp->clientId;

				CClient* client = FindClient(id);

				if (client)

				{

					// get connection

					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();

					if (conn->IsDisconnected())

					{

						ret = TCAPI_ERR_MEDIA_NOT_OPEN;

					}

					else if (conn->IsRetryInProgress())

					{

						ret = TCAPI_ERR_COMM_RETRY_IN_PROGRESS;

					}

					else if (conn->IsRetryTimedOut())

					{

						ret = TCAPI_ERR_COMM_TIMEOUT;

					}

					if (ret == TCAPI_ERR_NONE)

					{

						bool restart = false;

						if (conn->IsProcessingContinuing())

						{

							restart = true;

							conn->PauseProcessing();

						}

						client->OpenMessageFile(&pCmdrsp->destinationOptions);

						if (restart)

							conn->RestartProcessing();

					}

				}

				if (ret == TCAPI_ERR_NONE)

				{

					pCmdrsp->response = eRspOK;

				}

				else

				{

					pCmdrsp->response = eRspError;

					pCmdrsp->error = ret;

				}

				m_Server->SendResponse(pCmdrsp);

			}

			break;

		case eCmdCloseMessageFile:

			{

	TCDEBUGOPEN();