/*

* 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 <collate.h>

#include "TestSuiteInputData.h"

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

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

// Two Phase constructor

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

CTestSuiteInputData* CTestSuiteInputData::NewL(CStifItemParser& aItem)

{

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

    CleanupStack::PushL(self);

    self->ConstructL(aItem);

    CleanupStack::Pop();

    return self;

}

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

// Default constructor

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

CTestSuiteInputData::CTestSuiteInputData()

{

}

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

// Destructor

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

CTestSuiteInputData::~CTestSuiteInputData()

{    	

    if(iQueryBuf)

    {

    	delete iQueryBuf;

		iQueryBuf = NULL;    

    }	

    if(iKeyboardModeBuf)

    {

    	delete iKeyboardModeBuf;

    	iKeyboardModeBuf = NULL;

    }

    iCacheUris.ResetAndDestroy();

	iDisplayFields.Close();

}

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

// Destructor

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

TDesC& CTestSuiteInputData::KeyboardMode() const

{

	return *iKeyboardModeBuf;

}

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

// Returns the Id

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

TInt CTestSuiteInputData::Id()

{

	return iId;

}

void CTestSuiteInputData::Data(RPointerArray<TDesC> & aDataArray)

{

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

	{

		aDataArray.Append(iDataArray[i]->AllocL());

	}

}

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

// Sets the keyboard mode

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

void CTestSuiteInputData::SetKeyboardModeL(const TDesC& aKeyboardMode)

{

	iKeyboardModeBuf = aKeyboardMode.AllocL();

}

TSortType CTestSuiteInputData::SortType() const

{

	return iSortType;

}

void CTestSuiteInputData::SetSortType(TSortType aSortType)

{

	iSortType = aSortType;

}

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

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

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

TDesC& CTestSuiteInputData::Query() const

{

	return *iQueryBuf;

}

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

// Sets the search query

// 

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

void CTestSuiteInputData::SetQueryL(const TDesC& aQuery)

{

	iQueryBuf = aQuery.AllocL();

}

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

// Return the cache uri at given index 

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

TDesC& CTestSuiteInputData::CacheUriAt(TInt aIndex) const

{

	if ( aIndex >= iCacheUris.Count() ) 

	{

		HBufC* temp = HBufC::NewL(2);

		temp->Des().Copy(KNullDesC);

		return *temp;

	}

    return *(iCacheUris[aIndex]);

}

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

// Return the cache uri 

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

void CTestSuiteInputData::CacheUris(RPointerArray<TDesC> & aUriArray)

{

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

	{

		aUriArray.Append(iCacheUris[i]->AllocL());

	}

}

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

// Sets the cache uris

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

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

{

    iCacheUris.ResetAndDestroy();

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

    	iCacheUris.Append(aCacheUriArray[i]);

}

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

// Return the display fields

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

void CTestSuiteInputData::DisplayFields(RArray<TInt>& aDisplayFields)

{

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

	{

		aDisplayFields.Append(iDisplayFields[i]);

	}

}

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

// Return the group ids

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

void CTestSuiteInputData::GroupIds(RArray<TInt>& aGroupId)

{

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

	{

		aGroupId.Append(iGroupIds[i]);

	}

}

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

// Second phase construction

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

void CTestSuiteInputData::ConstructL(CStifItemParser& /*aItem*/)

{

}

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

// 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(KSearchQueryTag) == 0)

		    {

		    	// Search query

		    	ParseInputForSearchQueryL(dataPtr);

		    }

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

		    {

		    	// Data store uris

		    	ParseInputForDataStoresUriL(dataPtr);

		    }

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

		    {

		    	// Id

		    	ParseInputForIdL(dataPtr);

		    }

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

		    {

		    	// data

		    	ParseInputForData(dataPtr);

		    }

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

		    {

		    	// Display fields

		    	ParseInputForDisplayFieldsL(dataPtr);

		    }

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

		    {

		    	// Sorting

		    	ParseInputForSortTypeL(dataPtr);

		    }

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

		    {

		    	// Sorting

		    	ParseInputForGroupIdsL(dataPtr);

		    }

		}

		else

		{

			// Wrong Input..

			User::Leave(KErrGeneral);

		}

	}

}

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

// This function parses input for number id

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

void CTestSuiteInputData::ParseInputForIdL(TDesC& aInput)

{

    TInt fieldId = 0;

    TLex num(aInput);

    TInt err = num.Val(fieldId);

    if(err == KErrNone)

    {

        iId = fieldId;

    }

    else

    {

        User::Leave(KErrArgument);

    }

}

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

// This function parses input for sort type

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

void CTestSuiteInputData::ParseInputForSortTypeL(TDesC& aInput)

{

//	TSortType sorttype;

	// set the sort type

	if(aInput.Compare(KAlphabetic) == 0)

	{

	    iSortType = EAlphabetical;

	}

	else if (aInput.Compare(KPattern) == 0)

	{

	    iSortType = EPatternBased;

	}

	else

	{

		User::Leave(KErrArgument);

	}

}

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

// This function parses input for cache uris

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

void CTestSuiteInputData::ParseInputForData(TDesC& aInput)

{

	RPointerArray<TDesC> data;

	TChar separator = ',';

	// Get the uris which are separated by commas

	GetCharacterSeparatedDataL( aInput,separator, data);

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

	{

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

        iDataArray.Append(data[i]);

	}

}

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

// 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);

        }

        else

        {

            iDisplayFields.Append(fieldId);

        }

	}

}

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

// This function parses the input for expected group ids

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

void CTestSuiteInputData::ParseInputForGroupIdsL(TDesC& aInput)

{

	RPointerArray<TDesC> grpIdsBuf;

	TChar separator = ',';

	GetCharacterSeparatedDataL( aInput,separator, grpIdsBuf);

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

	{

		TInt groupId = 0;

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

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

        if(err != KErrNone)

        {

            User::Leave(KErrGeneral);

        }

        else

        {

            iGroupIds.Append(groupId);

        }

	}

}

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

// This function splits the the input separated by particular character

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

void CTestSuiteInputData::GetCharacterSeparatedDataL(TDesC& aInput,TChar aSeparator, RPointerArray<TDesC> &aSeparatedData)

{

	TInt SeparatorPos = -1 ;

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

	{

        TInt Startpos = SeparatorPos + 1;

		// Get the data for each contact

        while((aInput[j] != aSeparator) && (j < ( aInput.Length()-1) ) )

            j++;

		if(j == (aInput.Length() - 1))

			j++; 

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

        // Add data to the output

        HBufC* tempData = dataPtr.AllocL();

        aSeparatedData.Append(tempData);

        SeparatorPos = j ;  

        j++;   

    }

}

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

// This function parses the input for search query

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

void CTestSuiteInputData::ParseInputForSearchQueryL(TDesC& aInput)

{

	RPointerArray<TDesC> queryData;

	TChar separator = ',';

	GetCharacterSeparatedDataL( aInput,separator, queryData);

    // If there are more than 2 field, then it is an error

    if(queryData.Count() == 2)

    {

    	iQueryBuf = queryData[0]->AllocL();

    	iKeyboardModeBuf = queryData[1]->AllocL();

    	queryData.ResetAndDestroy();

    }

    else

    {

    	queryData.ResetAndDestroy();

     	User::Leave(KErrArgument);

    }

}

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

// This function creates the search query from the input buffer

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

void CTestSuiteInputData::CreateSearchQueryL(CPsQuery& aPsQuery,TDesC& aQueryBuf)

{

	TKeyboardModes keyboardMode = EModeUndefined;

    // Check the keyboard mode

	if(iKeyboardModeBuf->Des().Compare(KItut) == 0)

	{

	    keyboardMode = EItut;

	}

	else if (iKeyboardModeBuf->Des().Compare(KQwerty) == 0)

	{

	    keyboardMode = EQwerty;

	}

	else // mixed mode

	{

		// convert the search query to the required format

		_LIT(KCode,"i");

		for(TInt i = 0; i < aQueryBuf.Length(); i++)

		{

			CPsQueryItem* item = CPsQueryItem::NewL();

	    	item->SetCharacter(aQueryBuf[i]); // set search character

	    	// set the keyboard mode

	    	if( (iKeyboardModeBuf->Des().Mid(i,1)).Compare(KCode) == 0)

 			{

 				item->SetMode(EItut);

 			}

 			else 

 			{

 				item->SetMode(EQwerty);

 			}

 			aPsQuery.AppendL(*item);

		}

		return ;

	}

	// create the query as CPsQuery object

	// for EItut and EQwerty mode

	for(TInt j = 0; j < aQueryBuf.Length(); j++)

	{

		CPsQueryItem* item1 = CPsQueryItem::NewL();

	    item1->SetCharacter(aQueryBuf[j]);

	    item1->SetMode(keyboardMode);

	    aPsQuery.AppendL(*item1);

	}

}

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

// Perform the search settings

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

void CTestSuiteInputData::PerformSearchSettingsL(CPsSettings& aSettings)

{

	RPointerArray<TDesC> databases; // list of databases

	RArray<TInt> displayFields;     // list of display fields

	TInt maxResults = 100;

	// add the display fields

    if(iDisplayFields.Count())

    {

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

		    displayFields.Append(iDisplayFields[i]);

    }

    else

    {

	    displayFields.Append(6); // Firstname

	    displayFields.Append(4); // Lastname

	    displayFields.Append(27); // Company name

    }

    // Set the databases to be searched 

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

	{

		databases.Append(iCacheUris[i]->AllocL());

	}

	// Perform the settings

	aSettings.SetSearchUrisL(databases);

    aSettings.SetDisplayFieldsL(displayFields);

    aSettings.SetMaxResults(maxResults);