/*

* Copyright (c) 2005-2006 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:  Read instructions from message file

*

*/

#include <f32file.h>

#include <e32cmn.h>

#include <utf.h>

#include <barsc.h>

#include <barsread.h>

#include <epos_comasuplpospayload.h>

#include "epos_comasuplmessagefilereader.h"

#include <postester.rsg>

#include "epos_comasuplmessageinfo.h"

#include "epos_comasuplpostesterlogger.h"

_LIT(KResourcePath, "\\resource\\");

_LIT(KResourceName, "postester.rsc");

_LIT8(KConnectErr, "Error: Could not connect to server.");

_LIT8(KErrOpen, "Error: Could not open file");

_LIT8(KParseErr, "Error: Error in Parsing");

_LIT8(KPayloadErr, "Error: Wrong payload type.");

_LIT8(KInstructionErr, "Error: Wrong instruction type.");

_LIT8(KResourceNotFound, "Resource file not found.");

void ResetAndDestroy(TAny* aArray)

    {

    	((RPointerArray<COMASuplMessageInfo>*)aArray)->ResetAndDestroy();

    	delete aArray;

    }

COMASuplMessageFileReader* COMASuplMessageFileReader::

											NewL( TFileName& aFilePath

										, COMASuplPosTesterLogger* aLog)

	{

	COMASuplMessageFileReader* self = new( ELeave )

								COMASuplMessageFileReader(aLog);

	CleanupStack::PushL( self );

	self->ConstructL( aFilePath );

	CleanupStack::Pop(self);

	return self;

	}

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

// Destructor

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

//

COMASuplMessageFileReader::~COMASuplMessageFileReader()

	{

	iRFile.Close();

	iRFs.Close();

	delete iFileData;

	}

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

// Destructor

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

//

RPointerArray< COMASuplMessageInfo >& COMASuplMessageFileReader::

														GetMessageListL()

	{

	TBool noEoF = ETrue;

	RPointerArray< COMASuplMessageInfo >* messageArray = 

							new(ELeave)RPointerArray< COMASuplMessageInfo >;

	CleanupStack::PushL(TCleanupItem(*ResetAndDestroy, messageArray));

	while(noEoF)

		{

		//Read one Message

		HBufC8* messageBlock = NULL;

		if(ReadOneMessageBlockL(messageBlock))

			{

			CleanupStack::PushL(messageBlock);

			COMASuplMessageInfo* msgInfo = NULL;

			GetMsgInfoL(messageBlock, msgInfo);

			messageArray->Append(msgInfo);

			CleanupStack::Pop(messageBlock);

			}

		else

			{

			noEoF = EFalse;

			}

		delete messageBlock;

		}

	CleanupStack::Pop(messageArray);

	return *messageArray;

	}

COMASuplMessageFileReader::COMASuplMessageFileReader(COMASuplPosTesterLogger* aLog)

	{

	iLogger = aLog;

	}

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

// Second phase constructor

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

//

void COMASuplMessageFileReader::ConstructL(TFileName& aFilePath)

	{

	TInt err = KErrGeneral;

	err = iRFs.Connect();

	if(err != KErrNone)

		{

		iLogger->WriteLine(KConnectErr);

		User::LeaveIfError(err);

		}

	if(0 == aFilePath.Length())

		{

		ReadFileInfoFromResourceL();

		}

	else

		{

		iMsgFileName.Copy(aFilePath);

		}

	HBufC* filename = HBufC::NewL(iMsgFileName.Length() + 2 * KExtraBuffer);

	CleanupStack::PushL(filename);

	TPtr filenamePtr = filename->Des();

	filenamePtr.Copy(_L("Info: Path of Message File Used is: "));

	filenamePtr.Append(iMsgFileName);

	HBufC8* displayName = 

				CnvUtfConverter::ConvertFromUnicodeToUtf8L(filenamePtr);

	iLogger->WriteLine(*displayName);

	CleanupStack::PopAndDestroy(filename);

	delete displayName;

	err = iRFile.Open(iRFs, iMsgFileName, EFileShareReadersOnly);

	if(err != KErrNone)

		{

		iLogger->WriteLine(KErrOpen);

		User::LeaveIfError(err);

		}

	FileDataReaderL();

	}

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

// Reads complete data of a file in a buffer on heap.

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

//

TDesC8& COMASuplMessageFileReader::FileDataReaderL()

	{

	TInt fileSize = 0;

	User::LeaveIfError(iRFile.Size(fileSize));

	iFileData = HBufC8::NewL(fileSize);

	TPtr8 data = (iFileData->Des());

	User::LeaveIfError(iRFile.Read(data));

	return *iFileData;

	}

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

// Reads one message block from the buffer which contains complete data

// of the file.

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

//

TBool COMASuplMessageFileReader::ReadOneMessageBlockL(HBufC8*& aMessageBlock)

	{

	TInt msgBlockEnd = iFileData->Find(KMsgBlockDelimiter);

	if(msgBlockEnd > 0)

		{

		aMessageBlock = HBufC8::NewL(msgBlockEnd 

									+ KMsgBlockDelimiter().Length());

		aMessageBlock->Des().Copy(iFileData->Ptr(), msgBlockEnd 

									+ KMsgBlockDelimiter().Length());

		iFileData->Des().Delete(0, msgBlockEnd 

									+ KMsgBlockDelimiter().Length());

		return ETrue;

		}

	if(iFileData->Length() > 0)

		{

		iLogger->WriteLine(KParseErr);

		User::Leave(KErrNotFound);

		}

	return EFalse;

	}

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

// Extracts "instruction", "payload type" and "payload" from the message 

// block.

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

//

TInt COMASuplMessageFileReader::ParseMessageBlockL(HBufC8& aMessageBlock

						, COMASuplMessageInfo::TOMASuplOperationType& aOpType

						, COMASuplPosPayload& aPayload)

	{

	TInt payloadType = KErrNotFound;

	//find \r\n

	TInt typeDelimLoc = KErrNotFound;

	TInt opDelimLoc = KErrNotFound;

	TPtrC8 block = aMessageBlock.Mid(0);

	opDelimLoc = block.Find(KTypeDelimiter);

	if(opDelimLoc > 0)

		{

		TPtrC8 opType(block.Left(opDelimLoc));

		aOpType = GetOperationTypeL(opType);

		if(COMASuplMessageInfo::ESend == aOpType)

			{

			TPtrC8 payloadPart = block.Mid(opDelimLoc + KTypeDelimiter().Length());

			typeDelimLoc = payloadPart.Find(KTypeDelimiter);

			if(typeDelimLoc  > 0)

				{

				TPtrC8 type (payloadPart.Left(typeDelimLoc));

				HBufC8* typeToTrim = type.AllocL();

				typeToTrim->Des().Trim();

				TLex8 lex(typeToTrim->Des());

				TInt err = lex.Val(payloadType);

				delete typeToTrim;

				if(err != KErrNone)

					{

					iLogger->WriteLine(KParseErr);

					User::Leave(err);

					}

				TInt endPos = 0;

				TPtrC8 payloadPtr = payloadPart.Mid(typeDelimLoc + 

												KTypeDelimiter().Length());

				endPos = payloadPtr.Find(KMsgBlockDelimiter);

				TPtrC8 onlyPayload = payloadPtr.Left(endPos);

				HBufC8* payLoadData = onlyPayload.AllocL();//need not delete

				CleanupStack::PushL(payLoadData);

				PreparePayLoadL(aPayload, *payLoadData, payloadType);

				CleanupStack::Pop(payLoadData);

				}

			else

				{

				iLogger->WriteLine(KParseErr);

				User::Leave(KErrNotFound);

				}

			}

		else

			{

			return KErrNone;

			}

		}

	else

		{

		iLogger->WriteLine(KParseErr);

		User::Leave(KErrNotFound);

		}

	return KErrNone;

	}

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

// Prepares COMASuplPosPayload object from a descriptor.

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

//

void COMASuplMessageFileReader::PreparePayLoadL(

									COMASuplPosPayload& aPayloadObj

									, HBufC8& aPayload

									, TInt aPayloadType)

	{

	COMASuplPosPayload::TOMASuplPosPayloadType payloadType = 

											COMASuplPosPayload::ETIA801;

	switch(aPayloadType)

		{

		case 0:

			{

			payloadType = COMASuplPosPayload::ETIA801;

			break;

			}

		case 1:

			{

			payloadType = COMASuplPosPayload::ERRLP;

			break;

			}

		case 2:

			{

			payloadType = COMASuplPosPayload::ERRC;

			break;

			}

		default:

			{

			iLogger->WriteLine(KPayloadErr);

			User::Leave(KErrNotFound);

			}

		}

	aPayloadObj.SetPosPayload(&aPayload, payloadType);

	}

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

// Creates a COMASuplMessageInfo object from a message block.

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

//

void COMASuplMessageFileReader::GetMsgInfoL(HBufC8* aMessageBlock

							, COMASuplMessageInfo*& msgInfo)

	{

	delete msgInfo;

	COMASuplPosPayload* posPayLoad = COMASuplPosPayload::NewL();

	CleanupStack::PushL(posPayLoad);

	COMASuplMessageInfo::TOMASuplOperationType opType = COMASuplMessageInfo::EWait;

	ParseMessageBlockL(*aMessageBlock, opType, *posPayLoad);

	msgInfo = COMASuplMessageInfo::NewL(opType, *posPayLoad);

	CleanupStack::Pop(posPayLoad);

	delete posPayLoad;

	}

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

// Provides the type of instruction/operation.

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

//

COMASuplMessageInfo::TOMASuplOperationType 

COMASuplMessageFileReader::GetOperationTypeL(const TDesC8& aOpType)

	{

	if(aOpType.Compare(KSendOp) == 0)

		{

		return COMASuplMessageInfo::ESend;

		}

	else 

		{

		if(aOpType.Compare(KWaitOp) == 0)

			{

			return COMASuplMessageInfo::EWait;

			}

		else

			{

			iLogger->WriteLine(KInstructionErr);

			User::Leave(KErrNotFound);

			}

		}

	return COMASuplMessageInfo::EWait;

	}

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

// Reads default message file path and name from the resource file.

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

//

void COMASuplMessageFileReader::ReadFileInfoFromResourceL()

	{

	TBuf<128> resourceFileName;

	GetFileAbsolutePathL(resourceFileName);

    RResourceFile resourceFile;

    CleanupClosePushL(resourceFile);

    resourceFile.OpenL(iRFs, resourceFileName);

    resourceFile.ConfirmSignatureL(0);

    HBufC8* dataBuffer = resourceFile.AllocReadLC(R_POS_TESTER_MSG_FILE_PATH_NAME);

    TResourceReader theReader;

	theReader.SetBuffer(dataBuffer);

	TPtrC textdata = theReader.ReadTPtrC();

	iMsgFileName.Copy(textdata);

	CleanupStack::PopAndDestroy(dataBuffer);

	CleanupStack::PopAndDestroy(&resourceFile);//closing resource file

	}

void COMASuplMessageFileReader::GetFileAbsolutePathL(TDes& aResourceFileName)

	{

	TFindFile findResource(iRFs);

	TInt err = findResource.FindByDir(KResourceName(), KResourcePath());

	if(err != KErrNone)

		{

		iLogger->WriteLine(KResourceNotFound);

		User::Leave(err);

		}

	aResourceFileName.Copy(findResource.File());

	}