/*
* 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 "T_DataCElementParser.h"
#include "T_BTUtil.h"

/*@{*/

//Commands
_LIT(KCmdNewL, 												"NewL");
_LIT(KCmdReset,		 										"Reset");
_LIT(KCmdBuilder, 											"Builder");
_LIT(KCmdSetBuilder, 										"SetBuilder");
_LIT(KCmdParseElementsL, 									"ParseElementsL");
_LIT(KCmdBufferedParseL, 									"BufferedParseL");
_LIT(KCmdDestructor, 										"~");

//Parameters
_LIT(KObject,												"object");
_LIT(KExpected,												"expected");
_LIT(KType,													"type");
_LIT(KFileName,												"filename");

/*@}*/

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CT_DataCElementParser* CT_DataCElementParser::NewL()
	{
	CT_DataCElementParser*	ret=new (ELeave) CT_DataCElementParser();
	CleanupStack::PushL(ret);
	ret->ConstructL();
	CleanupStack::Pop(ret);
	return ret;
	}

CT_DataCElementParser::CT_DataCElementParser()
:	iCElementParser(NULL)
	{
	}

void CT_DataCElementParser::ConstructL()
	{
	User::LeaveIfError(iRFs.Connect());
	}

CT_DataCElementParser::~CT_DataCElementParser()
	{
	DestroyData();
	iRFs.Close();
	}

void CT_DataCElementParser::SetObjectL(TAny* aAny)
	{
	DestroyData();
	iCElementParser = static_cast<CElementParser*> (aAny);
	}

void CT_DataCElementParser::DisownObjectL()
	{
	iCElementParser = NULL;
	}

void CT_DataCElementParser::DestroyData()
	{
	delete iCElementParser;
	iCElementParser=NULL;
	}

inline TCleanupOperation CT_DataCElementParser::CleanupOperation()
	{
	return CleanupOperation;
	}

void CT_DataCElementParser::CleanupOperation(TAny* aAny)
	{
	CElementParser* parser=static_cast<CElementParser*>(aAny);
	delete parser;
	}

/**
 * Process a command read from the ini file
 *
 * @param aCommand			The command to process
 * @param aSection			The section in the ini containing data for the command
 * @param aAsyncErrorIndex	Command index for async calls to return errors to
 *
 * @return					ETrue if the command is processed
 *
 * @leave					System wide error
 */
TBool CT_DataCElementParser::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt /*aAsyncErrorIndex*/)
	{
	TBool	ret=ETrue;

	if ( aCommand==KCmdNewL )
		{
		DoCmdNewL(aSection);
		}
	else if ( aCommand==KCmdReset )
		{
		DoCmdReset(aSection);
		}
	else if ( aCommand==KCmdBuilder )
		{
		DoCmdBuilder(aSection);
		}
	else if ( aCommand==KCmdSetBuilder )
		{
		DoCmdSetBuilder(aSection);
		}
	else if ( aCommand==KCmdParseElementsL )
		{
		DoCmdParseElementsL(aSection);
		}
	else if ( aCommand==KCmdBufferedParseL )
		{
		DoCmdBufferedParseL(aSection);
		}
	else if ( aCommand==KCmdDestructor )
		{
		DoCmdDestructor();
		}
	else
		{
		ret=EFalse;
		}

	return ret;
	}


/**
Test NewL()
*/
void CT_DataCElementParser::DoCmdNewL(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("CElementParser NewL Call"));
	DestroyData();

	MSdpElementBuilder* elementBuilder = NULL;
	TPtrC 								theObject;
	TPtrC								theType;
	if( GetStringFromConfig(aSection, KObject(), theObject) )
		{
		if( GetStringFromConfig(aSection, KType(), theType) )
			{
			elementBuilder = CT_BTUtil::ElementBuilderCastL(*this, theObject, theType);
			}
		else
			{
			ERR_PRINTF1(_L("Error: Type is not specified."));
			SetBlockResult(EFail);
			}
		}

	TRAPD(err, iCElementParser = CElementParser::NewL(elementBuilder));
	if(err != KErrNone)
		{
		ERR_PRINTF2(_L("CElementParser NewL failed with error %d"), err);
		SetError(err);
		}
	}

/**
Test Reset()
*/
void CT_DataCElementParser::DoCmdReset(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("CElementParser Reset Call"));

	TPtrC								theObject;
	TPtrC								theType;
	if( GetStringFromConfig(aSection, KObject(), theObject) )
		{
		if( GetStringFromConfig(aSection, KType(), theType) )
			{
			MSdpElementBuilder* elementBuilder = CT_BTUtil::ElementBuilderCastL(*this, theObject, theType);
			iCElementParser->Reset(elementBuilder);
			}
		else
			{
			ERR_PRINTF1(_L("Error: Type is not specified."));
			SetBlockResult(EFail);
			}
		}
	else
		{
		iCElementParser->Reset();
		}
	}

/**
Test Builder()
*/
void CT_DataCElementParser::DoCmdBuilder(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("CElementParser Builder Call"));
	MSdpElementBuilder* actualBuilder = iCElementParser->Builder();

	TPtrC								theObject;
	TPtrC								theType;
	if( GetStringFromConfig(aSection, KObject(), theObject) )
		{
		if( GetStringFromConfig(aSection, KType(), theType) )
			{
			MSdpElementBuilder*	expectedBuilder = CT_BTUtil::ElementBuilderCastL(*this, theObject, theType);
			if( actualBuilder != expectedBuilder )
				{
				ERR_PRINTF1(_L("Builder not as expected!"));
				SetBlockResult(EFail);
				}
			}
		else
			{
			ERR_PRINTF1(_L("Error: Type is not specified."));
			SetBlockResult(EFail);
			}
		}
	}

/**
Test SetBuilder()
*/
void CT_DataCElementParser::DoCmdSetBuilder(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("CElementParser SetBuilder Call"));

	MSdpElementBuilder* elementBuilder = NULL;
	TPtrC								theObject;
	TPtrC								theType;
	if( GetStringFromConfig(aSection, KObject(), theObject) )
		{
		if( GetStringFromConfig(aSection, KType(), theType) )
			{
			elementBuilder = CT_BTUtil::ElementBuilderCastL(*this, theObject, theType);
			}
		else
			{
			ERR_PRINTF1(_L("Error: Type is not specified."));
			SetBlockResult(EFail);
			}
		}

	iCElementParser->SetBuilder(elementBuilder);
	}

/**
Test ParseElementsL()
*/
void CT_DataCElementParser::DoCmdParseElementsL(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("CElementParser ParseElementsL Call"));

	TPtrC								fileName;
	if( GetStringFromConfig(aSection, KFileName(), fileName) )
		{
		RFile file;
		User::LeaveIfError(file.Open(iRFs, fileName, EFileRead));
		CleanupClosePushL(file);
		
		TInt fileSize = 0;
		file.Size(fileSize);
		HBufC8* buff = HBufC8::NewLC(fileSize);
		TPtr8 tprBuff = buff->Des();
		file.Read(tprBuff);
		
		TInt numberOfBytes = 0;
		TRAPD(err, numberOfBytes = iCElementParser->ParseElementsL(tprBuff));
		INFO_PRINTF2(_L("CElementParser::ParseElementsL() result: actual = %d"), numberOfBytes);
		if(err != KErrNone)
			{
			ERR_PRINTF2(_L("CElementParser ParseElementsL failed with error %d"), err);
			SetError(err);
			}
		else
			{
			TInt	expected;
			if( GetIntFromConfig(aSection, KExpected(), expected) )
				{
				if( numberOfBytes != expected )
					{
					ERR_PRINTF1(_L("ParseElementsL not as expected!"));
					SetBlockResult(EFail);
					}
				}
			else
				{
				ERR_PRINTF2(_L("Missing expected value %S"), &KExpected());
				SetBlockResult(EFail);
				}
			}
		CleanupStack::PopAndDestroy(2, &file);
		}
	else
		{
		ERR_PRINTF2(_L("Missing parameter %S"), &KExpected());
		SetBlockResult(EFail);
		}
	}

/**
Test BufferedParseL()
*/
void CT_DataCElementParser::DoCmdBufferedParseL(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("CElementParser BufferedParseL Call"));

	TPtrC								fileName;
	if( GetStringFromConfig(aSection, KFileName(), fileName) )
		{
		RFile file;
		User::LeaveIfError(file.Open(iRFs, fileName, EFileRead));
		CleanupClosePushL(file);
		
		TInt fileSize = 0;
		file.Size(fileSize);
		HBufC8* buff = HBufC8::NewLC(fileSize);
		TPtr8 tprBuff = buff->Des();
		file.Read(tprBuff);

		TBool	boolResult = EFalse;
		TRAPD(err, boolResult = iCElementParser->BufferedParseL(tprBuff));
		INFO_PRINTF2(_L("CElementParser::BufferedParseL() result: actual = %d"), boolResult);
		if(err != KErrNone)
			{
			ERR_PRINTF2(_L("CElementParser BufferedParseL failed with error %d"), err);
			SetError(err);
			}
		else
			{
			TBool expected = EFalse;
			if( GetBoolFromConfig(aSection, KExpected(), expected) )
				{
				if( boolResult != expected )
					{
					ERR_PRINTF1(_L("BufferedParseL not as expected!"));
					SetBlockResult(EFail);
					}
				}
			else
				{
				ERR_PRINTF2(_L("Missing expected value %S"), &KExpected());
				SetBlockResult(EFail);
				}
			}
		CleanupStack::PopAndDestroy(2, &file);
		}
	else
		{
		ERR_PRINTF2(_L("Missing parameter %S"), &KExpected());
		SetBlockResult(EFail);
		}
	}

/**
Test ~CElementParser()
*/
void CT_DataCElementParser::DoCmdDestructor()
	{
	INFO_PRINTF1(_L("CElementParser Destructor Call"));

	DestroyData();
	}