/*

* Copyright (c) 2007 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 FILES

#include <StifParser.h>

#include <CPsQueryItem.h>

#include "TestSuiteInputData.h"

#include "pstestcontactshandler.h"

#include "psclienttestsuitedefs.h"

#include <vpbkeng.rsg>

// ============================== MEMBER FUNCTIONS ============================

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

// Two Phase constructor

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

CTestSuiteInputData* CTestSuiteInputData::NewL(CStifItemParser& aItem, CPSRequestHandler& aPsClientHandler)

{

	CTestSuiteInputData* self = new (ELeave) CTestSuiteInputData();	

    CleanupStack::PushL(self);

    self->ConstructL(aItem, aPsClientHandler);

    CleanupStack::Pop();

    return self;

}

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

// Second phase construction

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

void CTestSuiteInputData::ConstructL(CStifItemParser& /*aItem*/,CPSRequestHandler& aPsClientHandler)

{

    iContactHandler = CPcsTestContactsHandler::NewL();

    iPsClientHandler = &aPsClientHandler;

    iMaxNumberOfResults = 100;

    iSortType = EAlphabetical;

}

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

// Default constructor

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

CTestSuiteInputData::CTestSuiteInputData()

{

}

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

// Destructor

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

CTestSuiteInputData::~CTestSuiteInputData()

{

    delete iQueryBuf;

    delete iKeyboardModeBuf;

	delete iContactHandler;

	delete iInputSearchString;

	delete iExpectedResultString;

	delete iGroupToBeSearched;

	iCacheUris.ResetAndDestroy();

	iResultData.ResetAndDestroy();

	iInputCacheData.ResetAndDestroy();

	iDisplayFields.Close();

	iSortOrder.Close();

	iExpectedLocations.Close();

}

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

// Destructor

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

TDesC& CTestSuiteInputData::KeyboardMode() const

{

	return *iKeyboardModeBuf;

}

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

// Sets the keyboard mode

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

void CTestSuiteInputData::SetKeyboardModeL(const TDesC& aKeyboardMode)

{

	iKeyboardModeBuf = aKeyboardMode.AllocL();

}

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

// Returns the search query (as specified in the config file)

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

TDesC& CTestSuiteInputData::Query() const

{

	return *iQueryBuf;

}

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

// Returns the Input string (as specified in the config file)

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

TDesC& CTestSuiteInputData::InputSearchString() const

{

	return *iInputSearchString;

}

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

// Returns the Input string (as specified in the config file)

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

const TDesC& CTestSuiteInputData::ExpectedResultString() const

{

    return *iExpectedResultString;

}

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

// Returns the Input boolean (as specified in the config file)

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

TBool CTestSuiteInputData::InputBoolean() const

{

    return iInputBoolean;

}

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

// Sets the search query

// 

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

void CTestSuiteInputData::SetQueryL(const TDesC& aQuery)

{

	iQueryBuf = aQuery.AllocL();

}

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

// Returns the input cache data

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

void CTestSuiteInputData::InputCacheData(TInt aIndex, cacheData& aInputCacheData) const

{

	if(aIndex >= iInputCacheData.Count())

	{

		return;

	}

	aInputCacheData = *(iInputCacheData[aIndex]);

}

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

// Appends the cachedata to results data 

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

void CTestSuiteInputData::AppendResultDataL(const cacheData& aResultData)

{

	iResultData.Append(&aResultData);

}

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

// Returns the count for inputcachedata

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

TInt CTestSuiteInputData::InputCacheDataCount() const

{

	return( iInputCacheData.Count() );

}

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

// Returns the expected results array 

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

void CTestSuiteInputData::ResultData(RPointerArray<cacheData>& aResultData) const

{

	for(TInt i=0; i<iResultData.Count(); i++ )

	{

		aResultData.Append(iResultData[i]);

	}

}

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

// Returns the sort Type

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

TSortType CTestSuiteInputData::GetSortType()

{

	return iSortType;

}

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

// Appends the cachedata to cache data 

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

void CTestSuiteInputData::AppendInputCacheDataL(const cacheData& aInputCacheData)

{

	iInputCacheData.Append(&aInputCacheData);

}

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

// Returns the count of the expected result data

// 

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

TInt CTestSuiteInputData::ResultDataCount() const

{

	return( iResultData.Count() );

}

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

// Return the cache uri at given index 

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

TDesC& CTestSuiteInputData::CacheUris(TInt aIndex) const

{

	if ( aIndex >= iCacheUris.Count() ) 

	{

		//return NULL;

	}

    return *(iCacheUris[aIndex]);

}

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

// Sets the cache uris

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

void CTestSuiteInputData::ApendCacheUrisL(RPointerArray<TDesC>& aCacheUriArray)

{

    iCacheUris.ResetAndDestroy();

	for(TInt i =0; i <aCacheUriArray.Count(); i++ ) 

    	iCacheUris.Append(aCacheUriArray[i]);

}

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

// Returns the count of the cacheuris

// 

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

TInt CTestSuiteInputData::CacheUrisCount() const

{

	return( iCacheUris.Count() );

}

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

// This function parses the input parameters

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

void CTestSuiteInputData::ParseInputL(CStifItemParser& aItem)

{

	TPtrC string;

   	// parsing type to be set before parsing a string 

	// EQuoteStyleParsing: information between quotes is handled as a one string. 

	aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

	// loop till there is a token in i/p string

	while ( aItem.GetNextString ( string ) == KErrNone )

	{

		HBufC *item = string.AllocL();

		TChar sqBracketOpen = '[';

		TChar sqBracketClose = ']';

		TInt sqBracketStartPos = string.Locate(sqBracketOpen);

		TInt sqBracketEndPos = string.Locate(sqBracketClose);

		if ( (sqBracketStartPos!=KErrNotFound) && (sqBracketEndPos!=KErrNotFound) )

		{

			TPtrC16 optionPtr = string.Left(sqBracketStartPos);	

			TPtrC16 dataPtr = string.Mid(sqBracketStartPos+1, sqBracketEndPos-sqBracketStartPos-1);	

			// Check the type of tag, then do the corresponding parsing

            if(optionPtr.Compare(KCreateContacts) == 0)

            {

                // Contacts to be created

                ParseInputForContactsDataL(dataPtr,0);

            }

			else if(optionPtr.Compare(KSearchQueryTag) == 0)

		    {

		    	// Search query

		    	ParseInputForSearchQueryL(dataPtr);

		    }

		    else if(optionPtr.Compare(KUriTag) == 0)

		    {

		    	// Data store uris

		    	ParseInputForDataStoresUriL(dataPtr);

		    }

		    else if(optionPtr.Compare(KSearchExpectedResult) == 0)

		    {

		    	// Expected results

		    	ParseInputForContactsDataL(dataPtr,1);

		    }

            else if(optionPtr.Compare(KSearchExpectedMatchLocations) == 0)

            {

                // Expected match locations result

                ParseInputForMatchLocationsL(dataPtr);

            }		    

		    else if(optionPtr.Compare(KSetDisplayFields) == 0)

		    {

		    	// Display fields

		    	ParseInputForDisplayFieldsL(dataPtr);

		    }

		    else if(optionPtr.Compare(KSearchOnInputString) == 0)

		    {

		    	// Input search string

		    	ParseInputInputSearchStringL(dataPtr);

		    }

            else if(optionPtr.Compare(KExpectedResultString) == 0)

            {

                // Expected result string

                ParseInputExpectedResultStringL(dataPtr);

            }

            else if(optionPtr.Compare(KInputBoolean) == 0)

            {

                // Input boolean

                ParseInputInputBoolean(dataPtr);

            }

		    else if(optionPtr.Compare(KSearchExpectedResultForInput) == 0)

		    {

		    	// Expected results for input string search

				ParseInputForContactsDataL(dataPtr,1);

		    }

		    else if(optionPtr.Compare(KSupprotedLanguage) == 0)

		    {

		    	// Languages supported

		    	ParseInputForLanguageSupportL(dataPtr);

		    }

		    else if(optionPtr.Compare(KAddGroup) == 0)

		    {

		    	// Add groups to phonebook

		    	ParseInputForAddingGroupsL(dataPtr);

		    }

		    else if(optionPtr.Compare(KSearchInGroup) == 0)

		    {

		    	// Search within a particular group

		    	ParseInputForSearchWithinGroupL(dataPtr);

		    }

			else if(optionPtr.Compare(KSortOrderTag) == 0)

		    {

		    	// Search within a particular group

		    	ParseInputForSortOrderL(dataPtr);

		    }	  

		}

		else

		{

			// Wrong Input..

			User::Leave(KErrGeneral);

		}

	}

}

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

// Returned parsed expected result locations

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

const RArray<TPsMatchLocation>& CTestSuiteInputData::ExpectedLocations()

    {

    return iExpectedLocations;

    }

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

// Parses the input parameters for contacts data for creating contacts in 

// the phonebook

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

void CTestSuiteInputData::ParseInputForContactsDataL(TDesC& aInput,TInt aType)

{

	TChar comma = ',';

	TChar bracketOpen = '(';

	TChar bracketClose = ')';

	TInt commaPos = aInput.Locate(comma);

	TInt numOfContacts = 0;

	if(commaPos !=KErrNotFound )

	{

		TPtrC temp = aInput.Left(commaPos);

		TLex num(temp);

		TInt err = num.Val(numOfContacts);  // parse the string to extract integer value

		TInt startofBracket = aInput.Locate(bracketOpen);

		for(TInt i =0; i<numOfContacts; i++ )

		{

		    TInt j = startofBracket;

			// Get the data for each contact

			while(aInput[j] != bracketClose )

			    j++;

			TPtrC16 dataPtr = aInput.Mid(startofBracket + 1,j - 1 - startofBracket );	

			AddSingleContactDataL(dataPtr,aType);

		    if(i<numOfContacts - 1 )

		    {

                while(aInput[j] != bracketOpen )

			    j++;

				startofBracket = j;

		    }

		}

	}

}

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

// This function adds single contacts data

// if (aType),

//    then it is added to  the iResultData

// else

// 	  it is added to  the iInputCacheData

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

void CTestSuiteInputData::AddSingleContactDataL(TDesC& aInput, TInt aType)

{

	TChar comma = ',';

	TChar colon = ':';

	TInt commaPos = -1 ;

	cacheData* tempcacheData = new (ELeave) cacheData();

    TInt arrCount = iInputCacheData.Count();	

	for (TInt j = 0 ; j< aInput.Length();)

	{

        TInt Startpos = commaPos + 1;

        while(aInput[j] != colon)

            j++;

        TPtrC16 vpbkfielddataPtr = aInput.Mid(Startpos ,j - Startpos);

        // Get the corresponding integer value			

        TInt fieldId  =  GetFieldIdFromVpbkIdentifierL(vpbkfielddataPtr);

        tempcacheData->vpbkId.Append(fieldId);

        Startpos = j + 1;   

        while ( (j < aInput.Length()) && (aInput[j] != comma) )

            j++;

        TPtrC16 dataPtr = aInput.Mid(Startpos ,j - Startpos);	

        // Add data to the class

        commaPos = j ;  

        j++;   

	}

	// Check and add to appropriate data structure

	if(aType)

    {

        iResultData.Append(tempcacheData);

    }

	else

	{

        iInputCacheData.Append(tempcacheData);

	}

}

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

// Parses the input parameters for result match locations

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

void CTestSuiteInputData::ParseInputForMatchLocationsL(TDesC& aInput)

    {

    const TChar KComma(',');

    const TChar KColon(':');

    if ( 0 == aInput.Length() )

        {

        return;

        }

    TLex lex(aInput);

    do

        {

        TInt index;

        TInt length;

        User::LeaveIfError( lex.Val( index ) );

        if ( KColon != lex.Get() )

            {

            User::Leave( KErrArgument );

            }

        User::LeaveIfError( lex.Val( length ) );

        TPsMatchLocation newLocation = {index, length, TBidiText::ELeftToRight }; 

        iExpectedLocations.AppendL( newLocation );

        } while ( KComma == lex.Get() );

    }

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

// This function returns the vpbk id corresponding to config file strings

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

TInt CTestSuiteInputData::GetFieldIdFromVpbkIdentifierL(TDesC& aIdentifierAsString)

{

	if(aIdentifierAsString.Compare(KFirstName) == 0)

	{

	 	return R_VPBK_FIELD_TYPE_FIRSTNAME;

	}

	else if(aIdentifierAsString.Compare(KLastName) == 0)

	{

		return R_VPBK_FIELD_TYPE_LASTNAME;

	}

	else if(aIdentifierAsString.Compare(KCompanyName) == 0)

	{

		return R_VPBK_FIELD_TYPE_COMPANYNAME;

	}

	return -1;

}

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

// This function parses input for cache uris

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

void CTestSuiteInputData::ParseInputForDataStoresUriL(TDesC& aInput)

{

	RPointerArray<TDesC> Uris;

	TChar separator = ',';

	// Get the uris which are separated by commas

	GetCharacterSeparatedDataL( aInput,separator, Uris);

	for(TInt i = 0; i< Uris.Count(); i++)

	{

        HBufC *temp = Uris[i]->AllocL();

        iCacheUris.Append(Uris[i]);

	}

}

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

// This function parses the input for display fields

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

void CTestSuiteInputData::ParseInputForDisplayFieldsL(TDesC& aInput)

{

	RPointerArray<TDesC> dispFieldsBuf;

	TChar separator = ',';

	GetCharacterSeparatedDataL(aInput, separator, dispFieldsBuf);

	for (TInt i = 0; i< dispFieldsBuf.Count(); i++)

	{

		TInt fieldId = 0;

		TLex num(*(dispFieldsBuf[i]));

		TInt err = num.Val(fieldId); // parse the string to extract integer value

		if (err != KErrNone)

		{

            User::Leave(KErrGeneral);