/*

* 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 "statscriptdecoder.h"

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

// Contructor

CSTATScriptCommand::CSTATScriptCommand()

: cCommandID(0), pCommand(NULL), ulLength(0)

{

}

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

// Destructor

CSTATScriptCommand::~CSTATScriptCommand()

{

	Reset();

}

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

// Set command data

bool CSTATScriptCommand::SetData(const char *pData, const unsigned long theLength)

{

	Reset();

	if (pData && theLength)

	{

		pCommand = new char[theLength + 1];

		if (!pCommand)

			return false;

		memcpy(pCommand, pData, theLength);

		*(pCommand + theLength) = (char)0;

		ulLength = theLength;

	}

	return true;

}

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

// Destructor

void CSTATScriptCommand::Reset()

{

	if (pCommand)

	{

		delete [] pCommand;

		pCommand = NULL;

	}

	ulLength = 0;

}

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

// Script Decoder class

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

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

// Constructor

CSTATScriptDecoder::CSTATScriptDecoder(CSTATLogFile *theLog)

: lFileLength(0), iCounter(0),

  lpBuffer(NULL)

{

	pLog = theLog;

}

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

// Destructor

CSTATScriptDecoder::~CSTATScriptDecoder()

{

	Release();

}

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

// Read the script into memory

int

CSTATScriptDecoder::Initialise(const CString& file, bool bIsFile)

{

	lpBuffer = NULL;

	int ret = OPEN_SCRIPT_FILE_COMPLETE_FAILURE;

	// read the commands into memory

	if (bIsFile)

	{

		CFile script_file;

		if (script_file.Open(file, CFile::modeRead))

		{

			ret = ReadFileIntoMemory(script_file);

			script_file.Abort();

		}

	}

	else

		ret = ReadDataIntoMemory(file);

	// make sure we have valid start/end points in the script

	if (ret == ITS_OK)

		ret = ValidateScript();

	if (ret == ITS_OK)

	{

		pLog->WriteTimeToLog();

		if(bIsFile)

		{

			CString cBuffer = _T("Script file is : ");

			cBuffer += file;

			pLog->Write(cBuffer);

		}

		else

			pLog->Write(_T("Interpreting command script..."));

		ret = ITS_OK;

	}

	else

		Release();

	return ret;

}

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

// Release resources

void CSTATScriptDecoder::Release()

{

	LastCommand.Reset();

	// release the script

	if (lpBuffer && lFileLength)

	{

		delete [] lpBuffer;

		lpBuffer = NULL;

		lFileLength = iCounter = 0;

	}

}

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

// get the contents of a single command

int

CSTATScriptDecoder::GetNextCommand(CSTATScriptCommand **ppCommand)

{

	// get to the start of the command

	while (lpBuffer[iCounter] != '<')

	{

		// comment

		if (lpBuffer[iCounter] == '/' && lpBuffer[iCounter + 1] == '*')

		{

			if (ExtractComment())

			{

				*ppCommand = &LastCommand;

				return LastCommand.cCommandID;

			}

			return 0;

		}

		if (!IncrementCounter())

			return 0;

	}

	// step over the '<'

	if (!IncrementCounter())

		return 0;

	// save the command ID

	LastCommand.cCommandID = (char)toupper(lpBuffer[iCounter]);

	if (!IncrementCounter())

		return 0;

	// need to step over 'image' with '#image' command

	if (LastCommand.cCommandID == '#')

	{

		while (lpBuffer[iCounter] != ' ')

			if (!IncrementCounter())

				return 0;

		// step over the space

		if (!IncrementCounter())

			return 0;

	}

	int iBeginning = iCounter;

	// extract the command

	while (lpBuffer[iCounter] != '>')

		if (!IncrementCounter())

			return 0;

	// save our command

	LastCommand.SetData(lpBuffer + iBeginning, iCounter - iBeginning);

	// step over the '>'

	IncrementCounter();

	// set pointer to the command

	*ppCommand = &LastCommand;

	return LastCommand.cCommandID;

}

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

// PRIVATE METHODS

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

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

//reads string data into memory so that it can be decoded

int CSTATScriptDecoder::ReadDataIntoMemory(const CString& commands)

{

	// Convert CString to char *

	lFileLength = commands.GetLength();		//set length

	lpBuffer = new char [lFileLength + 1];		//allocate temporary buffer

	if (lpBuffer)

	{

		if (!pLog->ToAnsi(commands, 

								  lpBuffer, 

								  lFileLength))

		{

			return INTERPRET_COMMANDS_FAILURE;		//unable to convert to 8-bit

		}

		lpBuffer[lFileLength] = 0;

		return ITS_OK;

	}

	return E_OUTOFMEM;

}

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

//reads file data into memory so that it can be decoded

int CSTATScriptDecoder::ReadFileIntoMemory(CFile& scriptdata)

{

	try

	{

		lFileLength = scriptdata.GetLength();		//file length

		lpBuffer = new char [lFileLength + 1];		//allocate temporary buffer

		if (lpBuffer)

		{

			scriptdata.Read(lpBuffer, lFileLength);	//read in from the file and store in the buffer

			lpBuffer[lFileLength] = 0;

			return ITS_OK;

		}

	}

	catch(CFileException *e)

	{

		e -> Delete();

		return OPEN_SCRIPT_FILE_COMPLETE_FAILURE;

	}

	return E_OUTOFMEM;

}

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

// checks that start and end codes exist in the script

// on success, iCounter will be left ready for the first STAT command

int CSTATScriptDecoder::ValidateScript()

{

	CSTATScriptCommand *pCommand;

	bool bFound = false;

	// reset

	iCounter = 0;

	// look for end

	while (GetNextCommand(&pCommand))

	{

		if (pCommand->cCommandID == 'E')

		{

			bFound = true;

			break;

		}

	}

	if (bFound)

	{

		// reset

		iCounter = 0;

		bFound = false;

		// look for begin

		while (GetNextCommand(&pCommand))

		{

			if (pCommand->cCommandID == 'B')

			{

				bFound = true;

				iCounter -= 3;	// step back so this is the first command sent

				break;

			}

		}

	}

	if (!bFound)

		return BEGIN_COMMAND_FAILURE;

	return ITS_OK;

}

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

// get a comment

int

CSTATScriptDecoder::ExtractComment()

{

	int iBeginning = iCounter;

	LastCommand.cCommandID = lpBuffer[iCounter];

	iCounter += 2;

	while (((iCounter + 1) < lFileLength) &&

		   !(lpBuffer[iCounter] == '*' && lpBuffer[iCounter + 1] == '/') )

	{

		if (!IncrementCounter())

			return 0;

	}

	// get the last bit of the comment '*/'

	if ((iCounter + 1) < lFileLength)

		iCounter += 2;

	// save our comment

	LastCommand.SetData(lpBuffer + iBeginning, iCounter - iBeginning);

	return LastCommand.cCommandID;

}

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

// increment counter but make sure we don't go over the end of the script

bool CSTATScriptDecoder::IncrementCounter(void)

{

	return (++iCounter < lFileLength);

}