// Server.cpp

// 

// Copyright (c) 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include "Misc.h"

#include "stdafx.h"

#include "console_host.h"

#include "Server.h"

#include "ConsoleWindow.h"

#include "RemoteConsole.h"

const int KMajorVersion = 1;

const int KServerInitParam = ID_RC_CLOSE - 1;

static CServer* sServer = NULL;

LPCTSTR KServerWindowClassName = TEXT("ServerWindowClass");

LPCTSTR KServerConsoleName = TEXT("Server Console");

LPCTSTR KServerSocketName = TEXT("Server Socket");

class TCreateConsoleWindowPacket

	{

public:

	void Validate() const;

public:

	int iMajorVersion;

	int iMinorVersion;

	int iWidth;

	int iHeight;

	int iTitleLength;

	};

void TCreateConsoleWindowPacket::Validate() const

	{

	if (iMajorVersion > KMajorVersion)

		{

		throw KExceptionInvalidClientVersion;

		}

	}

CServer* CServer::New(HINSTANCE aAppHandle)

	{

	std::auto_ptr<CServer> self(new(EThrow) CServer(aAppHandle));

	self->Construct();

	return self.release();

	}

CServer::~CServer()

	{

	delete iSocket;

	delete iConsole;

	}

void CServer::HandleException(TException aException)

	{

	switch (aException)

		{

		case KExceptionNoMemory:

			iConsole->Write(TEXT("Out of memory\r\n"));

			break;

		case KExceptionWindowConstructFailed:

			iConsole->Write(TEXT("Failed to construct new window\r\n"));

			break;

		case KExceptionConsoleWindowConstructFailed:

			iConsole->Write(TEXT("Failed to construct new console window\r\n"));

			break;

		case KExceptionSocketConstructFailed:

			iConsole->Write(TEXT("Failed to construct new socket\r\n"));

			break;

		case KExceptionSocketBindFailed:

			iConsole->Write(TEXT("Failed to bind server socket. Is something else already listening on that port?\r\n"));

			break;

		case KExceptionSocketListenFailed:

			iConsole->Write(TEXT("Failed to listen on server socket\r\n"));

			break;

		case KExceptionSocketSelectFailed:

			iConsole->Write(TEXT("Failed to asynchronously wait on socket\r\n"));

			break;

		case KExceptionSocketAcceptFailed:

			iConsole->Write(TEXT("Failed to accept to client connection\r\n"));

			break;

		case KExceptionSocketReadFailed:

			iConsole->Write(TEXT("Failed to read from socket\r\n"));

			break;

		case KExceptionInvalidClientVersion:

			iConsole->Write(TEXT("Invalid client version\r\n"));

			break;

		case KExceptionFailedToWritePrefsFile:

			iConsole->Write(TEXT("Failed to write preferences file\r\n"));

			break;

		default:

			iConsole->Write(TEXT("Unknown error\r\n"));

			break;

		}

	}

TPreferences& CServer::Preferences()

	{

	return iPreferences;

	}

const TPreferences& CServer::Preferences() const

	{

	return iPreferences;

	}

CServer::CServer(HINSTANCE aAppHandle) : iAppHandle(aAppHandle), iSocket(NULL), iConsole(NULL), iPort(0)

	{

	sServer = this;

	}

void CServer::Construct()

	{

	WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX); 

	wcex.style			= CS_HREDRAW | CS_VREDRAW;

	wcex.lpfnWndProc	= (WNDPROC)CWindow::HandleMessage;

	wcex.cbClsExtra		= 0;

	wcex.cbWndExtra		= 0;

	wcex.hInstance		= iAppHandle;

	wcex.hIcon			= LoadIcon(iAppHandle, (LPCTSTR)IDI_CONSOLE_HOST);

	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);

	wcex.hbrBackground	= NULL;

	wcex.lpszMenuName	= (LPCTSTR)ID_SERVER_MENU;

	wcex.lpszClassName	= KServerWindowClassName;

	wcex.hIconSm		= LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);

	if (RegisterClassEx(&wcex) == 0)

		{

		throw KExceptionWindowClassRegistrationFailed;

		}

	iConsole = CConsoleWindow::New(iAppHandle, KServerWindowClassName, TEXT("Remote Console Server"), CW_USEDEFAULT, CW_USEDEFAULT, 40, 20, 20, this, NULL, TRUE);

	iConsole->SetName(KServerConsoleName);

	try

		{

		iPreferences.Read();

		}

	catch (...)

		{

		iConsole->Write(TEXT("Unable to read preferences"));

		}

	iSocket = CServerSocket::New(*iConsole);

	iSocket->SetName(KServerSocketName);

	PostMessage(iConsole->Handle(), WM_COMMAND, KServerInitParam, 0);

	}

void CServer::Listen()

	{

	if (iPort != iPreferences.ServerPort())

		{

		delete iSocket;

		iSocket = CServerSocket::New(*iConsole);

		iSocket->SetName(KServerSocketName);

		iSocket->Listen(iPreferences.ServerPort(), 5, *this);

		iConsole->WriteFormat(TEXT("Listening on port %d\r\n"), iPreferences.ServerPort());

		iPort = iPreferences.ServerPort();

		}

	}

void CServer::HandleNewClient(CClientSocket& aClientSocket)

	{

	CSocketCommandReader* commandReader = CSocketCommandReader::New(aClientSocket, *this);

	commandReader->ReadCommand();

	}

void CServer::HandleSocketClosure(CSocket& aSocket)

	{

	ASSERT(&aSocket == iSocket);

	PostQuitMessage(0);

	}

void CServer::HandleSocketCommand(TPacketHeader::TPacketType aCommand, const char* aPacket, int aPacketLength, CSocketCommandReader& aReader)

	{

	switch (aCommand)

		{

		case TPacketHeader::ECommandCreateConsoleWindow:

			{

			iConsole->Write(TEXT("Creating new console window...\r\n"));

			const TCreateConsoleWindowPacket* createConsoleWindowPacket = new((char*)aPacket) TCreateConsoleWindowPacket;

			LPTSTR title = (TCHAR*)((char*)aPacket + sizeof(TCreateConsoleWindowPacket));

			try

				{

				createConsoleWindowPacket->Validate();

				CRemoteConsole* remoteConsole = CRemoteConsole::New(iAppHandle, aReader, title, createConsoleWindowPacket->iWidth, createConsoleWindowPacket->iHeight, iPreferences);

				int consoleId = remoteConsole->Id();

				iConsole->WriteFormat(TEXT("Created window \"%s\" (%d)...\r\n"), title, consoleId);

				aReader.SendResponse((char*)&consoleId, sizeof(int));

				}

			catch (TException aException)

				{

				int err = -2; // KErrGeneral.

				if (aException == KExceptionInvalidClientVersion)

					{

					err = -21; // KErrAccessDenied.

					}

				aReader.SendResponse((char*)&err, sizeof(int));

				delete &aReader;

				throw aException;

				}

			catch (...)

				{

				delete &aReader;

				throw KExceptionUnknown;

				}

			break;

			}

		case TPacketHeader::ECommandAttachKeyEventSocket:

			{

			iConsole->Write(TEXT("Attaching key event socket...\r\n"));

			int* consoleId = new((char*)aPacket) int;

			CRemoteConsole* remoteConsole = CRemoteConsole::Instance(*consoleId);

			if (remoteConsole)

				{

				remoteConsole->AttachKeyEventSocket(aReader.ReleaseSocket());

				iConsole->WriteFormat(TEXT("Attached key event socket to window %d...\r\n"), *consoleId);

				}

			delete &aReader;

			break;

			}

		default:

			{

			iConsole->WriteFormat(TEXT("Invalid server socket command: %d\r\n"), aCommand);

			delete &aReader;

			break;

			}

		}

	}

void CServer::HandleSocketClosure(CSocketCommandReader& aReader)

	{

	delete &aReader;

	}

void CServer::HandleWindowClosure(CWindow& aWindow)

	{

	ASSERT(&aWindow == iConsole);

	PostQuitMessage(0);

	}

LRESULT CALLBACK PrefsCallback(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)

	{

	switch (message)

		{

		case WM_INITDIALOG:

			TCHAR string[128];

			swprintf(string, TEXT("%u"), sServer->Preferences().ServerPort());

			SetDlgItemText(hDlg, ID_EDIT_PORT, string);

			swprintf(string, TEXT("%u"), sServer->Preferences().DefaultWindowWidth());

			SetDlgItemText(hDlg, ID_EDIT_WIN_WIDTH, string);

			swprintf(string, TEXT("%u"), sServer->Preferences().DefaultWindowHeight());

			SetDlgItemText(hDlg, ID_EDIT_WIN_HEIGHT, string);

			swprintf(string, TEXT("%u"), sServer->Preferences().DefaultWindowPosX());

			SetDlgItemText(hDlg, ID_EDIT_WIN_POS_X, string);

			swprintf(string, TEXT("%u"), sServer->Preferences().DefaultWindowPosY());

			SetDlgItemText(hDlg, ID_EDIT_WIN_POS_Y, string);

			EnableWindow(GetDlgItem(hDlg, ID_EDIT_WIN_POS_X), !sServer->Preferences().SystemPositionedWindows());

			EnableWindow(GetDlgItem(hDlg, ID_EDIT_WIN_POS_Y), !sServer->Preferences().SystemPositionedWindows());

			CheckDlgButton(hDlg, ID_CHECK_WIN_POS, sServer->Preferences().SystemPositionedWindows());

			swprintf(string, TEXT("%u"), sServer->Preferences().NumOverflowLines());

			SetDlgItemText(hDlg, ID_OVERFLOW_LINES, string);

			return TRUE;

		case WM_COMMAND:

			switch (LOWORD(wParam))

				{

				case IDOK:

					{

					TCHAR string[128];

					GetDlgItemText(hDlg, ID_EDIT_PORT, string, 128);

					unsigned int val;

					swscanf(string, TEXT("%u"), &val);

					sServer->Preferences().SetServerPort((unsigned short)val);

					GetDlgItemText(hDlg, ID_EDIT_WIN_WIDTH, string, 128);

					swscanf(string, TEXT("%u"), &val);

					sServer->Preferences().SetDefaultWindowWidth(val);

					GetDlgItemText(hDlg, ID_EDIT_WIN_HEIGHT, string, 128);

					swscanf(string, TEXT("%u"), &val);

					sServer->Preferences().SetDefaultWindowHeight(val);

					GetDlgItemText(hDlg, ID_EDIT_WIN_POS_X, string, 128);

					swscanf(string, TEXT("%u"), &val);

					sServer->Preferences().SetDefaultWindowPosX(val);

					GetDlgItemText(hDlg, ID_EDIT_WIN_POS_Y, string, 128);

					swscanf(string, TEXT("%u"), &val);

					sServer->Preferences().SetDefaultWindowPosY(val);

					GetDlgItemText(hDlg, ID_OVERFLOW_LINES, string, 128);

					swscanf(string, TEXT("%u"), &val);

					sServer->Preferences().SetNumOverflowLines(val);

					sServer->Preferences().SetSystemPositionedWindows((IsDlgButtonChecked(hDlg, ID_CHECK_WIN_POS) == BST_CHECKED) ? TRUE : FALSE);

					sServer->Preferences().Write();

					sServer->Listen();

					}	// Deliberate fall through.

				case IDCANCEL:

					{

					EndDialog(hDlg, LOWORD(wParam));

					return TRUE;

					}

				case ID_CHECK_WIN_POS:

					{

					int isChecked = IsDlgButtonChecked(hDlg, ID_CHECK_WIN_POS);

					EnableWindow(GetDlgItem(hDlg, ID_EDIT_WIN_POS_X), !isChecked);

					EnableWindow(GetDlgItem(hDlg, ID_EDIT_WIN_POS_Y), !isChecked);

					break;

					}

				}

			break;

		}

    return FALSE;

	}

LRESULT CServer::HandleWindowCommand(UINT aMessage, WPARAM aWParam, LPARAM aLParam)

	{

	int wmId = LOWORD(aWParam); 

	int wmEvent = HIWORD(aWParam); 

	switch (wmId)

		{

		case KServerInitParam:

			Listen();

			break;

		case ID_PREFS:

			DialogBox(iAppHandle, (LPCTSTR)IDD_PREFS_DIALOG, iConsole->Handle(), (DLGPROC)PrefsCallback);

			break;

		default:

			return DefWindowProc(iConsole->Handle(), aMessage, aWParam, aLParam);

		}

	return 0;

	}