/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

*

*/

#include "stdafx.h"

#include "STATEngine.h"

#include "STATCommon.h"

#include "INI.h"

#include <string>

//----------------------------------------------------------------------------

// Constructor

CSTATEngine::CSTATEngine()

: pImageVerify(NULL), pConverter(NULL), pComms(NULL), pDecoder(NULL), pLog(NULL),

  minimumdelay(100), maximumdelay(30000), eStopProcessing(STAT_RUN), iCurrentCommand(0), bMultithreaded(false),

  eConnectType(SymbianInvalid), pDeviceInfo(NULL), iDeviceCode(0), iMaxTimeLimit(STAT_MAXTIME), dataSocket(NULL), settingSocket(true), iTEFSharedData(NULL)

{	

	memset(&szAddress, 0, sizeof(szAddress));

	statIniFile.SetIniFileName(STAT_INI_NAME);

}

//----------------------------------------------------------------------------

// Destructor

CSTATEngine::~CSTATEngine()

{

	Release();

}

//----------------------------------------------------------------------------

// Set things up

int

CSTATEngine::Initialise(const STATCONNECTTYPE eConnect, const char *pAddress)

{

	iDelay = minimumdelay;

	// logging - should be the first to be created for all other classes that depend on it

	pLog = new CSTATLogFile;

 	if (!pLog)

 		return E_OUTOFMEM;

	int ret = SetScreenshotDefaultDirectory();

	if (ret != ITS_OK)

		return ret;

	// image verification

 	pImageVerify = new CSTATImageVerify(pLog);

 	if (!pImageVerify)

 		return E_OUTOFMEM;

	// bitmap conversion

	pConverter = new CSTATDataFormatConverter(pLog);

 	if (!pConverter)

 		return E_OUTOFMEM;

	// script decoder

	pDecoder = new CSTATScriptDecoder(pLog);

 	if (!pDecoder)

 		return E_OUTOFMEM;

	// communications

	pComms = new STATComms();

 	if (!pComms)

 		return E_OUTOFMEM;

	else

	{

		EnterCriticalSection(&CriticalSection);

		ret = pComms->SetTransport(eConnect);

		if (ret == ITS_OK)

		{

			ret = pComms->Initialise();

			if (ret == ITS_OK)

				ret = pComms->Connect(pAddress);

			if (ret == ITS_OK)

			{

				strcpy(szAddress, pAddress);	// save port in case of restart after error

				eConnectType = eConnect;

			}

		}

		LeaveCriticalSection(&CriticalSection);

	}

	return ret;

}

//----------------------------------------------------------------------------

// Release resources

int

CSTATEngine::Release(void)

{

	if (pImageVerify)

	{

		delete pImageVerify;

		pImageVerify = NULL;

	}

	if (pConverter)

	{

		delete pConverter;

		pConverter = NULL;

	}

	if (pDecoder)

	{

		delete pDecoder;

		pDecoder = NULL;

	}

	if (pDeviceInfo)

	{

		delete [] pDeviceInfo;

		pDeviceInfo = NULL;

	}

	if (iTEFSharedData)

	{

		delete [] iTEFSharedData;

		iTEFSharedData = NULL;

	}

	EnterCriticalSection(&CriticalSection);

	if (pComms)

	{

		delete pComms;

		pComms = NULL;

	}

	// release this one last in case other objects are using it...

	if (pLog)

	{

		pLog->CloseLogFile();

		delete pLog;

		pLog = NULL;

	}

	LeaveCriticalSection(&CriticalSection);

	return ITS_OK;

}

//----------------------------------------------------------------------------

// Sets up log file

int

CSTATEngine::SetLogging(const CString& logfilename, const char* prefix, bool append, bool bMessages, bool bFile,

	MessageReporter *const aMessageReporter)

{

	EnterCriticalSection(&CriticalSection);

	//set default logging path

	CString defaultDirectory=STAT_LOGFILEPATH_VALUE;

	//read from inifile if entry exists

	if(statIniFile.SectionExists(ST_TEST_KEY) )

	{

		CString setting;

		setting.Empty();

		setting=statIniFile.GetKeyValue(ST_LOGFILEPATH,ST_TEST_KEY);

		if(!setting.IsEmpty())

			defaultDirectory = setting;

	}

	int ret = pLog->CreateLogFile(logfilename,defaultDirectory, prefix, append, bMessages, bFile);

	pLog->SetMessageReporter(aMessageReporter);

	// in case our transport was initialised before logging was

	// display the initialisation message if there is one

	if (ret == LOG_FILE_OK)

		Message(pComms->Error());

	LeaveCriticalSection(&CriticalSection);

	return ret;

}

//----------------------------------------------------------------------------

// Sets up log file

void

CSTATEngine::SetCommandDelay(int iMillisecondDelay)

{

	iDelay = iMillisecondDelay;

	// set some limits

	if (iDelay < 100)

		iDelay = minimumdelay;

	if (iDelay > 30000)

		iDelay = maximumdelay;

}

//----------------------------------------------------------------------------

// Open, read and count the amount of commands on this script

int

CSTATEngine::GetCommandCount(CString file, int *pCount)

{

	EnterCriticalSection(&CriticalSection);

	int ret = pDecoder->Initialise(file, true);

	if (ret != ITS_OK)

		ret = pDecoder->Initialise(file, false);

	if (ret == ITS_OK)

	{

		CSTATScriptCommand *pSendCommand;

		int iCount = 0;

		// get a command from the script

		while (pDecoder->GetNextCommand(&pSendCommand) && ret == ITS_OK)

		{

			iCount++;

			if (pSendCommand->cCommandID == STAT_END)

				break;

		}

		// set the count

		if (ret == ITS_OK)

			(*pCount) = iCount;

	}

	pDecoder->Release();

	LeaveCriticalSection(&CriticalSection);

	return ret;

}

//----------------------------------------------------------------------------

// Open and read a script file's contents

int

CSTATEngine::OpenScriptFile(CString file, bool bIsFile)

{

	EnterCriticalSection(&CriticalSection);

	int ret = pDecoder->Initialise(file, bIsFile);

	LeaveCriticalSection(&CriticalSection);

	return ret;

}

//----------------------------------------------------------------------------

// Execute a script file

int

CSTATEngine::RunScript(ScriptProgressMonitor *const monitor)

{

	int ret = ITS_OK;

	iCurrentCommand = 0;

	eStopProcessing = STAT_RUN;

	iDeviceCode = 0;

	// anything smaller can cause problems and doesn't make sense anyway!

	if (iMaxTimeLimit < 1000)

		iMaxTimeLimit = 1000;

	// pointers to our command structures

	CSTATScriptCommand *pSendCommand;

	CSTATScriptCommand *pRecvCommand;

	char lastCommand = NULL;

	receivedData.Empty( );

	// get a command from the script

	while (pDecoder->GetNextCommand(&pSendCommand) && ret == ITS_OK)

	{

		iCurrentCommand++;

		if (StopProcessing())

		{

			pComms->Send(STAT_RESYNCID);

			ret = E_USERCANCEL;

			break;

		}

		if (lastCommand == STAT_REBOOT)

		{

			ret = ITS_OK;

			break;

		}

		switch(pSendCommand->cCommandID)

		{

			case 'P':

				Message(pSendCommand->Command());

				Sleep(atol(pSendCommand->Command()));

				break;

			case '/':

				Message(pSendCommand->Command());

				break;

			case '#':

				{

					Message(pSendCommand->Command());

					cScreenshotDirectory = pSendCommand->Command();

					if(cScreenshotDirectory.Right(1) != _T("\\"))

						cScreenshotDirectory += _T("\\");

					CreateAllDirectories(cScreenshotDirectory);

				}

				break;

			default:

				{

					// send the command and retrieve a response

					int iResyncErrors = 0;

					while ((ret = SendCommand(pSendCommand, &pRecvCommand)) == E_RESYNCCOMMAND)

					{

						Sleep(STAT_RETRYDELAY);

						iResyncErrors++;

						if (iResyncErrors > STAT_MAXERRORS)

						{

							Message("Too many resync errors - stopping");

							ret = E_COMMANDFAILED;

							break;

						}

					}

					if (ret == ITS_OK)

					{

						// perform special operations for these commands

						switch(pSendCommand->cCommandID)

						{

							case 'D':

								StoreData(pRecvCommand->Command(), pRecvCommand->Length(), pDeviceInfo);

								AppendCommandToSTATLog("*** DEVICE INFORMATION ***", pRecvCommand->Command(), pRecvCommand->Length());

								break;

							case 'S':

							{

								// convert and save the data returned in the response

								CString image = pSendCommand->Command();

								ret = ConvertAndSaveScreeenshot(image, pRecvCommand->Command(), pRecvCommand->Length());

								// imave verification

								if (ret == ITS_OK)

								{

									if (pImageVerify->IsActive() && pConverter->bWriteToFile)

									{

										ret = pImageVerify->VerifyImage(image);

										if (ret == VERIFICATION_PASS)

											ret = ITS_OK;

									}

								}

								break;

							}

							case 'T':

							{

								if(dataSocket==NULL)

								{

									// filename has been sent, now send the file itself

									CSTATScriptCommand oSendCommand;

									oSendCommand.cCommandID = pRecvCommand->cCommandID;

										// read and send the file contents

									if ((ret = ReadTransferFile(pSendCommand->Command(), &oSendCommand)) == ITS_OK)

									{

										int iResyncErrors = 0;

										while ((ret = SendCommand(&oSendCommand, &pRecvCommand)) == E_RESYNCCOMMAND)

										{

											Sleep(STAT_RETRYDELAY);

											iResyncErrors++;

											if (iResyncErrors > STAT_MAXERRORS)

											{

												Message("Too many resync errors - stopping");

												ret = E_COMMANDFAILED;

												break;

											}

										}

									}

								}

								else

								{

									//release the socket

									ret = ReleaseSocket();

								}

								break;

							}

							case 'R':

							case 'X':

							{	

								if(dataSocket==NULL)

								{

									// save the file contents

									ret = SaveTransferFile(pSendCommand->Command(), pRecvCommand->Command(), pRecvCommand->Length());

								}

								else

								{

									//release the socket

									ret = ReleaseSocket();

								}

								break;

							}

							case 'G':

							{

								// upload the device log file and write to STAT log file

								AppendCommandToSTATLog("*** DEVICE LOG ***", pRecvCommand->Command(), pRecvCommand->Length());

								break;

							}

							case STAT_REFRESH:

							case STAT_END:

							{

								ret = END_SCRIPT;

								break;

							}

							case 'N':

							{

								// Retrieve the TEF shared data

								StoreData(pRecvCommand->Command(), pRecvCommand->Length(), iTEFSharedData);

								AppendCommandToSTATLog("*** RETRIEVE TEF SHARED DATA ***", pRecvCommand->Command(), pRecvCommand->Length());

							}

							break;

							default:

							{

								Sleep(iDelay);

								break;

							}

						}

					}

					if (ret == ITS_OK)

					{

						// Data received from certain of the commands is stored

						// for retreival later.

						switch(pSendCommand->cCommandID)

						{

							case 'W':

							case 'V':

							//execute returns pid

							case 'J':

							//poll returns 0 1

							case '3':

								receivedData += oRecvCommand.Command();

								break;

							default:

								break;

						}

					}

				}

				break;

		}

		lastCommand = pSendCommand->cCommandID;

		if(monitor)

		{

			monitor->OnCompleteCommand( iCurrentCommand );

		}

	}

	pDecoder->Release();

	return ret;

}

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

// Converts a char * to it's Unicode equivalent

//

LPTSTR

CSTATEngine::ToUnicode(const char *string)

{

#ifdef UNICODE

	static TCHAR szBuffer[MAX_UNICODE_LEN + 1] = {0};

	szBuffer[0] = (TCHAR)0;

    // Convert to UNICODE.

    if (!MultiByteToWideChar(CP_ACP,					// conversion type

							 0,							// flags

							 string,					// source

							 -1,						// length

							 szBuffer,					// dest

							 MAX_UNICODE_LEN))			// length

    {

        return _T("Could not convert");

    }

    return szBuffer;

#else

	return (LPTSTR)string;

#endif

}

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

// Converts a Unicode to it's char * equivalent

//

char *

CSTATEngine::ToAnsi(LPCTSTR string)

{

#ifdef UNICODE

	static char szBuffer[MAX_UNICODE_LEN + 1] = {0};

	szBuffer[0] = (char)0;

    // Convert to ANSI.

    if (!WideCharToMultiByte(CP_ACP,					// conversion type

							 0,							// flags

							 string,					// source