// Copyright (c) 2008-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:

//

/*

 ============================================================================

 Name		: CommandLineHandler.cpp

 Author	  : 

 Version	 : 1.0

 Copyright   : Your copyright notice

 Description : CCommandHandler implementation

 ============================================================================

 */

#include "CommandHandler.h"

#include "cenreptestconst.h"

void CCommandHandler::ResetAndDestroyPtrArray(TAny* aPtr)

	{

	(STATIC_CAST(RPointerArray<HBufC>*, aPtr))->ResetAndDestroy();

	(STATIC_CAST(RPointerArray<HBufC>*, aPtr))->Close();

	}

CCommandHandler::CCommandHandler(CConsoleBase* aConsole) : iConsole(aConsole)

	{

	// No implementation required

	}

CCommandHandler::~CCommandHandler()

	{

	}

CCommandHandler* CCommandHandler::NewLC(CConsoleBase* aConsole)

	{

	CCommandHandler* self = new (ELeave) CCommandHandler(aConsole);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CCommandHandler* CCommandHandler::NewL(CConsoleBase* aConsole)

	{

	CCommandHandler* self = CCommandHandler::NewLC(aConsole);

	CleanupStack::Pop(); // self;

	return self;

	}

void CCommandHandler::ConstructL()

	{

	}

void CCommandHandler::HandleCommandL(const RArray<TPtrC>& aArgs)

	{

	RArray<TPtrC> cmdArgs;

	CleanupClosePushL(cmdArgs);

	if( aArgs.Count() < 2 )

	{

	HandleCommandError(EInvalidCmdArgs);

	User::Leave(KErrArgument);

	}

	//copy command arguments

	for (int index = 2; index < aArgs.Count(); ++index)

		{

		cmdArgs.Append(aArgs[index]);

		}

	RBuf command;

	CleanupClosePushL(command);

	command.CreateL(aArgs[0]);

	command.LowerCase();

	if(command.Find(KCmdIndicator) == 0)

		{

		if(command.Mid(1).Match(KCmdMode()) == 0)

			{

			RBuf mode;

			CleanupClosePushL(mode);

			mode.CreateL(aArgs[1]);

			mode.LowerCase();

			if(mode.Match(KModeCreate) == 0)

				{

				iConsole->Write(_L("Executing mode : create"));

				iConsole->Write(_L("\n"));

				//create setting in central repositiory

				CreateSettingInRepositoryL(cmdArgs);

				}

			else if(mode.Match(KModeValidate) == 0)

				{

				iConsole->Write(_L("Executing mode : validate"));

				iConsole->Write(_L("\n"));

				//validate setting in cenrep

				ValidateSettingInRepositoryL(cmdArgs);

				}

			else

				{

				//Repote error unknown mode

				HandleCommandError(EInvalidMode);

				}

			CleanupStack::PopAndDestroy(&mode);

			}

		else

			{

			// report error invalid command 

			HandleCommandError(EInvalidCmdArgs);

			}

		}

	else

		{

		// report error missing command

		HandleCommandError(EInvalidCmdArgs);

		}

	CleanupStack::PopAndDestroy(2);

	}

void CCommandHandler::HandleCommandError(TInt aError)

{

	switch(aError)

	{

		case EInvalidMode:

		case EInvalidCmdArgs:

			PrintUsage();

			break;

	}

}

TUint CCommandHandler::HexDesToUint(const TPtrC& aDes)

{

    TLex lex;

    lex.Assign(aDes);

    TUint intVal;

    lex.Val(intVal, EHex);

    return intVal;

}

TInt CCommandHandler::DesToInt(const TPtrC & aDes)

{

	TLex lex;

	lex.Assign(aDes);

	TInt realVal;

	lex.Val(realVal);

	return realVal;

}

TReal CCommandHandler::DesToReal(const TPtrC & aDes)

{

	TLex lex;

	lex.Assign(aDes);

	TReal realVal;

	lex.Val(realVal);

	return realVal;

}

void CCommandHandler::CreateSettingInRepositoryL(const RArray<TPtrC> & aCmdArgs)

{

	//Create repository object and set setting

	TPtrC repositoryUid = aCmdArgs[0]; // repository UID in hex format

	TPtrC settingId		= aCmdArgs[1]; // setting UID in hex format

	TPtrC settingType	= aCmdArgs[2]; // setting data format

	TPtrC settingVal	= aCmdArgs[3]; // setting value

	//print info message

	iConsole->Write(_L("Reading repository "));

	iConsole->Write(repositoryUid);

	CRepository *repository =  CRepository::NewL(HexDesToUid(repositoryUid));

	CleanupStack::PushL(repository);

	if(repository != NULL)

	{

		iConsole->Write(_L(" ...repository exists \n"));

		//Set setting here

		TInt err = repository->Create(HexDesToUint(settingId), DesToInt(settingVal));

		if(KErrAlreadyExists == err)

		{

			User::LeaveIfError(repository->Delete(HexDesToUint(settingId)));

			err = repository->Create(HexDesToUint(settingId), DesToInt(settingVal));

		}

		if(KErrNone == err)

		{

			iConsole->Write(_L("Setting created, Id : "));

			iConsole->Write(settingId);

		}

		else

		{

			User::Leave(err);

		}

	}

	CleanupStack::PopAndDestroy(repository);

}

void CCommandHandler::ValidateSettingL(CRepository *& repository, TPtrC settingId, TPtrC settingType, TPtrC settingVal)

{

	iConsole->Write(_L(" ...repository exists \n"));

	iConsole->Write(_L("Reading setting, Id : "));

	iConsole->Write(settingId);

	if(settingType.Match(KTypeInt) == 0)

	{

		ValidateIntValueL(repository, settingId, settingVal);

	}

	else if(settingType.Match(KTypeReal) == 0)

	{

		ValidateRealValueL(repository, settingId, settingVal);

	}

	else if(settingType.Match(KTypeString) == 0) 

	{

		ValidateStringValueL(repository, settingId, settingVal);

	}

	else if(settingType.Match(KTypeString8) == 0) 

	{

		ValidateString8ValueL(repository, settingId, settingVal);

	}

}

void CCommandHandler::ValidateIntValueL(CRepository *& repository, TPtrC settingId, TPtrC settingVal)

{

	TInt readVal;

	User::LeaveIfError(repository->Get(DesToInt(settingId), readVal));

	if(readVal == HexDesToUint(settingVal))

	{

		iConsole->Write(_L(" ...setting exists"));

	}

	else

	{

		User::Leave(KErrCorrupt);	

	}

}

void CCommandHandler::ValidateRealValueL(CRepository *& repository, TPtrC settingId, TPtrC settingVal)

{

	TReal readVal;

	User::LeaveIfError(repository->Get(DesToInt(settingId), readVal));

	if(readVal == DesToReal(settingVal))

	{

		iConsole->Write(_L(" ...setting exists"));

	}

	else

	{

		User::Leave(KErrCorrupt);	

	}

}

void CCommandHandler::ValidateStringValueL(CRepository *& repository, TPtrC settingId, TPtrC settingVal)

{

	TBuf<1024> string;

	User::LeaveIfError(repository->Get(DesToInt(settingId), string));

	if(string.Match(settingVal) == 0)

	{

		iConsole->Write(_L(" ...setting exists"));

	}

	else

	{

		User::Leave(KErrCorrupt);	

	}

}

void CCommandHandler::ValidateString8ValueL(CRepository *& repository, TPtrC settingId, TPtrC settingVal)

{

	TBuf8<1024> buf;

	User::LeaveIfError(repository->Get(DesToInt(settingId), buf));

	TBuf<1024> string;

	string.Copy(buf);

	if(string.Match(settingVal) == 0)

	{

		iConsole->Write(_L(" ...setting exists"));

	}

	else

	{

		User::Leave(KErrCorrupt);	

	}

}

void CCommandHandler::ValidateSettingInRepositoryL(const RArray<TPtrC> & aCmdArgs)

{

	//Create repository object and validate setting.

	TPtrC repositoryUid = aCmdArgs[0]; // repository UID in hex format

	TPtrC settingId		= aCmdArgs[1]; // setting UID in hex format

	TPtrC settingType	= aCmdArgs[2]; // setting data format

	TPtrC settingVal 	= aCmdArgs[3];

	//print info message

	iConsole->Write(_L("Reading repository "));

	iConsole->Write(repositoryUid);

	CRepository *repository =  CRepository::NewL(HexDesToUid(repositoryUid));

	CleanupStack::PushL(repository);

	if(repository != NULL)

	{

		ValidateSettingL(repository, settingId, settingType, settingVal);

	}

    CleanupStack::PopAndDestroy(repository);

}

TUid CCommandHandler::HexDesToUid(const TPtrC & aDes)

{

	return TUid::Uid(HexDesToUint(aDes));

}

void CCommandHandler::PrintUsage()

{

	iConsole->Write(_L("Invalid command or mode switch.\n"));

	iConsole->Write(_L("Usage:\n"));

	iConsole->Write(_L("CenrepTest -m <create|validate> <Repository Id> <Setting Id> <Setting Type> <Setting Value>\n"));

}