/*

* Copyright (c) 2002 - 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:  ?Description

*

*/

// SYSTEM INCLUDE FILES

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include "PsClientTestSuite.h"

#include <CPsQueryItem.h>

#include <CPcsDefs.h>

#include <CPsQuery.h>

#include <CPsRequestHandler.h>

#include <CPsClientData.h>

#include <badesca.h>

// Defines

#define KOneSecDelay 1000000

_LIT(groupformat,"cntdb://c:contacts.gdb?id=");

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

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

// CPsClientTestSuite::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

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

//

void CPsClientTestSuite::Delete() 

{

}

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

// CPsClientTestSuite::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt CPsClientTestSuite::RunMethodL( CStifItemParser& aItem ) 

    {

    TStifFunctionInfo const KFunctions[] = {

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function.

        ENTRY( "WriteTitleToLog",                CPsClientTestSuite::WriteTitleToLog ),

        ENTRY( "CreateContactsInPhone",          CPsClientTestSuite::CreateContactsL ),

	    ENTRY( "ADDGroups",                      CPsClientTestSuite::CreateGroupsInPhoneL ),

	    ENTRY( "DeleteAllContactsInPhonebook",   CPsClientTestSuite::DeleteAllContactsInPhonebookL ),

        ENTRY( "SearchOnInputString",            CPsClientTestSuite::SearchOnInputStringL ),

        ENTRY( "TC_ITU_SearchOnInputString",     CPsClientTestSuite::SearchOnInputStringL ), // For easy handling of .cgf file

        ENTRY( "TC_N97_SearchOnInputString",     CPsClientTestSuite::SearchOnInputStringL ), // For easy handling of .cgf file

        ENTRY( "TC_N00_SearchOnInputString",     CPsClientTestSuite::SearchOnInputStringL ), // For easy handling of .cgf file

        ENTRY( "SearchLookupMatchString",        CPsClientTestSuite::SearchLookupMatchStringL ),

        ENTRY( "TC_ITU_SearchLookupMatchString", CPsClientTestSuite::SearchLookupMatchStringL ), // For easy handling of .cgf file

        ENTRY( "TC_N97_SearchLookupMatchString", CPsClientTestSuite::SearchLookupMatchStringL ), // For easy handling of .cgf file

        ENTRY( "TC_N00_SearchLookupMatchString", CPsClientTestSuite::SearchLookupMatchStringL ), // For easy handling of .cgf file

        ENTRY( "TestSearchingInCache",           CPsClientTestSuite::SearchCacheL ),

        ENTRY( "TC_ITU_TestSearchingInCache",    CPsClientTestSuite::SearchCacheL ), // For easy handling of .cgf file

        ENTRY( "TC_N97_TestSearchingInCache",    CPsClientTestSuite::SearchCacheL ), // For easy handling of .cgf file

        ENTRY( "TC_N00_TestSearchingInCache",    CPsClientTestSuite::SearchCacheL ), // For easy handling of .cgf file

	    ENTRY( "CheckAdaptiveString",            CPsClientTestSuite::CheckAdaptiveStringL ),

	    ENTRY( "CheckCachingStatus",             CPsClientTestSuite::CheckCachingStatusL ),

	    ENTRY( "CheckVersion",                   CPsClientTestSuite::CheckVersion),

	    ENTRY( "CheckLanguageSupport",           CPsClientTestSuite::TestIsLanguageSupportedL),

	    ENTRY( "GetAllContents",                 CPsClientTestSuite::GetAllContentsL),

	    ENTRY( "TestSortOrder",                  CPsClientTestSuite::TestSortOrderL),

	    ENTRY( "TestSortOrderErrCaseL",          CPsClientTestSuite::TestSortOrderErrCaseL),	    

	    ENTRY( "TestSearchingWithInGroup",       CPsClientTestSuite::SearchWithInGroupL),

	    ENTRY( "ConvertToVpbkLink",              CPsClientTestSuite::ConvertToVpbkLinkL), 

	    ENTRY( "RemoveObserver",                 CPsClientTestSuite::RemoveObserverL ),

	    ENTRY( "ShutDown",                       CPsClientTestSuite::ShutDownL ),

	    ENTRY( "AddMarkedContactsTest",          CPsClientTestSuite::AddMarkedContactsTestL ),

	    ENTRY( "TestDataOrder",                  CPsClientTestSuite::TestDataOrderL ),

	    ENTRY( "TestDataOrderForErrL",           CPsClientTestSuite::TestDataOrderForErrL ),

	    ENTRY( "CancelSearch",                   CPsClientTestSuite::CancelSearchL )

        };

    const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// This writes a log line to ease search of the execution logs

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

TInt CPsClientTestSuite::WriteTitleToLog( )

{

	iReturnStatus = KErrNone;

    TName title;

    TestModuleIf().GetTestCaseTitleL(title);

	// Write the log

#ifdef _DEBUG

#ifdef __WINS__

    RDebug::Print( _L("[PCS] ################################################################") );

    RDebug::Print( _L("[PCS] ##### STIF: %S"), &title );

    RDebug::Print( _L("[PCS] ################################################################") );

#endif // __WINS__

#endif // _DEBUG

	// return error code

    return iReturnStatus;

}

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

// This test case creates contacts in the phonebook

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

TInt CPsClientTestSuite::CreateContactsL( CStifItemParser& aItem )

{

    iReturnStatus = KErrNone;

    // Create the input parser

    iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);

    // Parse the input data

    iInputParsedData->ParseInputL(aItem) ;  

    // Create the contacts

    iInputParsedData->CreateContactsL();

    // return error code

    return iReturnStatus;

}

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

// This test case creates groups in the phonebook

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

TInt CPsClientTestSuite::CreateGroupsInPhoneL( CStifItemParser& aItem )

{

	iReturnStatus = KErrNone;

	// Create the input parser

	iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);

	// Parse the input data

  	iInputParsedData->ParseInputL(aItem) ;	

	// return error code

    return iReturnStatus;

}

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

// This test case creates a new CPsQueryItem object and checks 

// if the creation is successfull.

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

TInt CPsClientTestSuite::SearchCacheL( CStifItemParser& aItem )

{

	RTimerWait(KOneSecDelay);

	iReturnStatus = KErrGeneral;

	// Create the input parser

	iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);

	// Parse the input data

  	iInputParsedData->ParseInputL(aItem) ;	

	// Create the contacts

	iInputParsedData->CreateContactsL();

	// Perform the search settings

	iInputParsedData->PerformSearchSettingsL(*iSettings);

	// set search settings

	iPsClientHandler->SetSearchSettingsL(*iSettings); 

	// Create the search query 

	iInputParsedData->CreateSearchQueryL(*iPsQuery,iInputParsedData->Query());

	//Wait for one second

	RTimerWait(KOneSecDelay);

	//Perform the search

	iPsClientHandler->SearchL(*iPsQuery);

	CActiveScheduler::Start();

   	// return error code

    return iReturnStatus;

}

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

// This test case creates a new CPsQueryItem object and checks 

// if search cancelling doesn't crash.

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

TInt CPsClientTestSuite::CancelSearchL( CStifItemParser& aItem )

{

	RTimerWait(KOneSecDelay);

	iReturnStatus = KErrGeneral;

	// Create the input parser

	iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);

	// Parse the input data

  	iInputParsedData->ParseInputL(aItem) ;	

	// Perform the search settings

	iInputParsedData->PerformSearchSettingsL(*iSettings);

	// set search settings

	iPsClientHandler->SetSearchSettingsL(*iSettings); 

	// Create the search query 

	iInputParsedData->CreateSearchQueryL(*iPsQuery,iInputParsedData->Query());

	//Wait for one second

	RTimerWait(KOneSecDelay);

	//Perform the search

	iPsClientHandler->SearchL(*iPsQuery);

    //Cancel search

    iPsClientHandler->CancelSearch();

	//Wait for one second

	RTimerWait(KOneSecDelay);

   	// return error code

    return KErrNone;

}

void CPsClientTestSuite::HandlePsResultsUpdate(RPointerArray<CPsClientData>& searchResults,

		                                       RPointerArray<CPsPattern>& /*searchSeqs*/)

{

	RArray<TInt> contactIdsArray;

	TInt leaveErrorCode(KErrNone);

	switch(iCurrentOperation)

	{

		case EDeleteSearchedResults:

		    // Deleted all the contacts contained in the search results

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

		        {

		        contactIdsArray.Append(searchResults[i]->Id());

		        }

		    TRAP( iReturnStatus, iInputParsedData->DeleteContactsWithIdsL(contactIdsArray) );

		    break;

		case EGetGroupId:

		    // Get the group Id. If there are more than one results,

		    // then there is an error

		    if(searchResults.Count() == 1)

		        {

		        iGroupToBeSearchedId = searchResults[0]->Id();

		        }

		    else if(searchResults.Count() > 1)

		        {

		        iReturnStatus = KErrArgument;

		        }

		    CActiveScheduler::Stop();

		    break;

		case EConvertToVpbkLink:

		    // Get the contact link for the first element.

		    if(searchResults.Count() )

		        {

		        iReturnStatus = KErrNone;

		        TRAP ( leaveErrorCode, 

		                TBool ret = iInputParsedData->TestVpbkLinkForIdL(*iPsClientHandler,*(searchResults[0]));

                        if (!ret)

                            iReturnStatus = KErrGeneral;

                        );

                if ( leaveErrorCode )

                    {

                    iReturnStatus = leaveErrorCode;

                    }

		        }

		    else

		        {

		        iReturnStatus = KErrGeneral;

		        }

		    CActiveScheduler::Stop();

		    break;

		case EMarkedContacts:

		    TRAP( leaveErrorCode,

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

                    {

                    CPsClientData* markContact = searchResults[i]->CloneL();

                    iMarkedContacts.Append(markContact);

                    }

                );

		    if ( leaveErrorCode )

		        {

		        iReturnStatus = leaveErrorCode;

		        }

		    CActiveScheduler::Stop();

		    break;

		case EDefaultCase:

		    // Search is complete. Compare the results with expected results

		    TRAP( leaveErrorCode, iReturnStatus = iInputParsedData->CompareResWithExpResL(searchResults));

		    if ( leaveErrorCode )

		        {

		        iReturnStatus = leaveErrorCode;

		        }

		    CActiveScheduler::Stop();

		    break;

		default :

		    break;

	} // End Switch	

}

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

// Searches for a query in input string.

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

TInt CPsClientTestSuite::SearchOnInputStringL(CStifItemParser& aItem)

{

    RTimerWait(KOneSecDelay);

	iReturnStatus = KErrNone;

	// Create the input parser

	iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);

	// Parse the input data

  	iInputParsedData->ParseInputL(aItem);

  	//Get the input string

	HBufC* inputStr = iInputParsedData->InputSearchString().AllocL();

	//To obtain the result;

	CDesCArray* matchSet = new( ELeave ) CDesCArrayFlat(1);

	RArray<TPsMatchLocation> matchLocation;

	// Create the search query

	iInputParsedData->CreateSearchQueryL(*iPsQuery,iInputParsedData->Query());

	//Wait for one second

	RTimerWait(KOneSecDelay);

	//Perform the search

	iPsClientHandler->LookupL(*iPsQuery, *inputStr, *matchSet, matchLocation);

	// Retrieve the expected result

	RPointerArray<cacheData> expResultData;

	iInputParsedData->ResultData(expResultData);

	// If the expected search result has more than one element, then

	// it is an error since we have only one input string to be searched.

	if(expResultData.Count() > 1)

	{

		iReturnStatus = KErrArgument;

	}

	// Perform the comparison of matched sequences

	TInt expResCount = 0;

	if(expResultData.Count())

	{

		expResCount = expResultData[0]->data.Count();

	}

	else

	{

		expResCount = 0;

	}

	// compare the obtained result with desired result set

	if( (matchSet->Count() == expResCount) && (KErrNone == iReturnStatus) )

	{

		TInt totalMatches = 0;

		for(TInt i = 0; i < matchSet->Count(); i++)	

		{

			for(TInt j = 0; j < expResultData[0]->data.Count(); j++)

			{

				HBufC* temp1 = ((*matchSet)[i]).AllocL();

				HBufC* temp2 = (*(expResultData[0]->data[j])).AllocL();

				temp1->Des().LowerCase();

				temp2->Des().LowerCase();

				if((*temp1).Compare(*temp2) == 0 )

				{

					totalMatches++;

					expResultData[0]->data.Remove(j);

					break;

				} 

			}

		}

		// If the totalmatches == total number of results in match set,

		// then testcase is successful

		if(matchSet->Count() == totalMatches)

		{

			iReturnStatus = KErrNone;

		}

		else

		{

			iReturnStatus = KErrArgument;

		}

	}

	else

	{

		iReturnStatus = KErrArgument;

	}

	//compare match Locations

	const RArray<TPsMatchLocation>& expectedLocations = iInputParsedData->ExpectedLocations();

	if ( expectedLocations.Count() != matchLocation.Count() )

	    {

	    iReturnStatus = KErrArgument; //matchLocations differs from expected result

	    }

	for ( TInt i(0); i < expectedLocations.Count() && KErrNone == iReturnStatus; ++i )

	    {

	    if ( (expectedLocations[i].index != matchLocation[i].index) ||

	         (expectedLocations[i].length != matchLocation[i].length)   )

	        {

	        iReturnStatus = KErrArgument; //matchLocations differs from expected result

	        }

	    }

	matchLocation.Close();

	matchLocation.Reset();

	matchSet->Reset();

	// return error code

    return iReturnStatus;

}

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

// Searches for a query in input string.

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

TInt CPsClientTestSuite::SearchLookupMatchStringL(CStifItemParser& aItem)

{

    RTimerWait(KOneSecDelay);

    iReturnStatus = KErrNone;

    // Create the input parser

    iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);

    // Parse the input data

    iInputParsedData->ParseInputL(aItem);

    //Get the input string

    HBufC* inputStr = iInputParsedData->InputSearchString().AllocL();

    // Create the search query

    iInputParsedData->CreateSearchQueryL(*iPsQuery,iInputParsedData->Query());

    TBuf<KPsQueryMaxLen> result;

    //Wait for one second

    RTimerWait(KOneSecDelay);

    //Perform the search

    iPsClientHandler->LookupMatchL(*iPsQuery, *inputStr, result);

    if ( iInputParsedData->ExpectedResultString() != result )

    {

        iReturnStatus = KErrArgument;

    }

    return iReturnStatus;

}

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

// Checks the Adaptive Grid string.

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

TInt CPsClientTestSuite::CheckAdaptiveStringL(CStifItemParser& aItem)

{

    RTimerWait(KOneSecDelay);

    iReturnStatus = KErrNone;

    // Create the input parser

    iInputParsedData = CTestSuiteInputData::NewL(aItem,*iPsClientHandler);

    // Parse the input data

    iInputParsedData->ParseInputL(aItem);

    // If more than one cacheuris are configured, this is not

    // supported by the test suite

    HBufC* dataStore = HBufC::NewL(50);

    if(iInputParsedData->CacheUrisCount() == 1)

    {

        dataStore->Des().Copy(iInputParsedData->CacheUris(0)); 

    }

    else

    {

        User::Leave(KErrArgument);

    }

    CDesCArrayFlat* dataStoreArr = NULL;

    dataStoreArr = new (ELeave) CDesCArrayFlat( 1 );

    CleanupStack::PushL( dataStoreArr );

    dataStoreArr->AppendL( *dataStore );

    // Search Text

    //Get the input string

    HBufC* searchText = iInputParsedData->InputSearchString().AllocL();

    // Company Name

    TBool companyName = iInputParsedData->InputBoolean();

    TBuf<KPsAdaptiveGridStringMaxLen> result;

    // Wait for one second

    RTimerWait(KOneSecDelay);

    TPtrC16 ptr = dataStoreArr->MdcaPoint(0);

    // Get the Adaptive Grid

    iPsClientHandler->GetAdaptiveGridCharactersL( *dataStoreArr,

	                                              searchText->Des(),

												  companyName,

												  result );

    CleanupStack::PopAndDestroy( dataStoreArr );

    delete dataStore;

    if ( iInputParsedData->ExpectedResultString() != result )

    {

        iReturnStatus = KErrArgument;

    }

    return iReturnStatus;

}

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

// Stores the caching status of the psengine

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

void CPsClientTestSuite::CachingStatus(TCachingStatus& aStatus, TInt& /*aError*/)