/*

* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* which accompanies this distribution, and is available

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*   ?description_line

*

*/

//  INCLUDES

#include "FT_CPosTp25.h"

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLandmarkSearch.h> 

#include <EPos_CPosLmTextCriteria.h>

#include <EPos_CPosLmCatNameCriteria.h>

#include <EPos_CPosLMItemIterator.h>    

#include <EPos_CPosLmDisplayData.h>

#include <EPos_CPosLmDisplayItem.h>

#include <EPos_TPosLMSortPref.h>

#include "FT_CSearchResult.h"

#include <EPos_Landmarks.h>

#include "FT_LandmarkConstants.h"

// CONSTANTS

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

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

// CPosTp25::CloseTest

//

// (other items were commented in a header).

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

//

void CPosTp25::CloseTest()

    {

    iLog->Log(_L("CloseTest"));

    delete iLandmarkSearch;

    iLandmarkSearch = NULL;

    delete iDatabase;

    iDatabase=NULL;

    iCategorySearchResults.ResetAndDestroy();

    }

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

// CPosTp25::StartL

//

// (other items were commented in a header).

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

//

void CPosTp25::StartL()

    {

    _LIT(KEmptyTextCriteriaErr, "An empty string as text criteria should not be allowed");

    _LIT(KEmptyTextCriteriaErr1, "An empty text criteria should not be allowed");

    // copy test db to the private path

    _LIT(KTestPath, "c:\\system\\test\\testdata\\");

    CFileMan* fileMan = CFileMan::NewL(iFileSession);

    CleanupStack::PushL(fileMan);

    TBuf<150> srcPath;

    srcPath.Append(KTestPath);

    srcPath.Append(KTp25TestDb);

    TInt er = fileMan->Copy(srcPath, KLmTp25DefaultDbPath,

            CFileMan::EOverWrite);

    if (er != KErrNone)

        iLog->Log(_L("Error when copying file"));

    CleanupStack::PopAndDestroy(fileMan);

    CPosLmDatabaseManager* manager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(manager);

    // This db must exist

    manager->SetDefaultDatabaseUriL(KTp25TestDb);

    CleanupStack::PopAndDestroy(manager);

    iDatabase = CPosLandmarkDatabase::OpenL(KTp25TestDb);

    if (iDatabase->IsInitializingNeeded())

        {

        TRAPD( err, ExecuteAndDeleteLD( iDatabase->InitializeL() ) );

        AssertTrueSecL(err == KErrNone, _L("Init db failed"));

        }

    iLandmarkSearch = CPosLandmarkSearch::NewL(*iDatabase);

    TInt err = KErrNone;

    CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();

    // Start by testing some error flows, returning KErrArgument

    TRAP(err, iLandmarkSearch->StartCategorySearchL(*nameCriteria, CPosLmCategoryManager::ECategorySortOrderNone)); 

    AssertTrueSecL(err == KErrArgument, KEmptyTextCriteriaErr1);

    // Test with a landmark search criteria into a category search operation

    CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

    textCriteria->SetTextL(_L("*"));

    TRAP(err, iLandmarkSearch->StartCategorySearchL(*textCriteria, CPosLmCategoryManager::ECategorySortOrderNone));

    AssertTrueSecL(err == KErrArgument, KEmptyTextCriteriaErr);

    CleanupStack::PopAndDestroy(textCriteria);

    // Test empty string

    nameCriteria->SetSearchPatternL(_L(""));   

    TRAP(err, iLandmarkSearch->StartCategorySearchL(*nameCriteria, CPosLmCategoryManager::ECategorySortOrderNone));

    AssertTrueSecL(err == KErrArgument, KEmptyTextCriteriaErr);

    CleanupStack::PopAndDestroy(nameCriteria);

    // test with maximum nr of characters in search pattern

    TestSearchPatternLengthL();

    AppendCategorySearchResultsL();

	// Search synchronously

    iLog->Log(_L("Testing search with criterias read from LmDbSearchResult.txt syncronously"));

    SearchL(iCategorySearchResults, ESynchronous);

    iLog->Log(_L("Testing search with sort order"));

    SearchWithSortOrderL(iCategorySearchResults, ESynchronous);

    iLog->Log(_L("Testing search with maximum nr of matches"));

    SearchWithMaximumL(iCategorySearchResults, ESynchronous);

	// Search asynchronously

    iLog->Log(_L("Testing search with criterias read from LmDbSearchResult.txt asyncronously"));

    SearchL(iCategorySearchResults, EAsynchronous);

    iLog->Log(_L("Testing search with sort order asynchronously"));

    SearchWithSortOrderL(iCategorySearchResults, EAsynchronous);

    iLog->Log(_L("Testing search with maximum nr of matches asynchronously"));

    SearchWithMaximumL(iCategorySearchResults, EAsynchronous);

	// Search asynchronously with User::WaitForRequest()

    iLog->Log(_L("Testing search with criterias read from LmDbSearchResult.txt asyncronously using User::WaitForRequest()"));

    SearchL(iCategorySearchResults, EWaitForRequest);

    iLog->Log(_L("Testing search with sort order asynchronously using User::WaitForRequest()"));

    SearchWithSortOrderL(iCategorySearchResults, EWaitForRequest);

    iLog->Log(_L("Testing search with maximum nr of matches asynchronously using User::WaitForRequest()"));

    SearchWithMaximumL(iCategorySearchResults, EWaitForRequest);

	// Search for added categories

    iLog->Log(_L("Testing search after category has been added"));

    SearchAfterAddedCategoryL();

	// Cancel search test

    iLog->Log(_L("Testing category search and cancel"));    

    SearchAndCancelL();

    iLog->Log(_L("Testing category search and cancel in callback"));    

    SearchAndCancelL(ETrue);

    delete iDatabase;

    iDatabase = NULL;

    delete iLandmarkSearch;

    iLandmarkSearch = NULL;

    iDatabase = UseGlobalCategoriesL();

    if (iDatabase->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(iDatabase->InitializeL());

       }

    iLandmarkSearch = CPosLandmarkSearch::NewL(*iDatabase);

    // Do reset so that global categories are included

    CPosLmCategoryManager* categoryManager = CPosLmCategoryManager::NewL(*iDatabase);

    CleanupStack::PushL(categoryManager);   

    ExecuteAndDeleteLD(categoryManager->ResetGlobalCategoriesL());

    CleanupStack::PopAndDestroy(categoryManager);

    iLog->Log(_L("Testing search with global categories included, sync"));

    SearchGlobalL(iCategorySearchResults, ETrue);

    iLog->Log(_L("Testing search with global categories included, asyncronously"));

    SearchGlobalL(iCategorySearchResults, EFalse);

    // Verify error report "ESLI-62DBXR Landmarks - Sort order is not correctly implemented"

    // Check that CPosLandmarkSearch::MatchIteratorL are CPosLandmarkDatabase::LandmarkIteratorL

    // are sorted correctly (should be identically sorted)

    VerifySortOrderL();

    RemoveGlobalCategoriesL();

    delete iLandmarkSearch;

    iLandmarkSearch = NULL;

    }

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

// CPosTp25::SearchL

//

// (other items were commented in a header).

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

//

void CPosTp25::SearchL(

    const RPointerArray<CCategorySearchResult>& aSearchResults, 

    TExecutionMode aExecutionMode)

    {

    _LIT(KNumOfMatchesErr, "No. of matches is incorrect when the search is performed");

    _LIT(KNotFoundErr, "Id %d not found in parsed Lm search results when the search is performed syncronously");

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

        {   

        CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();

        nameCriteria->SetSearchPatternL(aSearchResults[i]->TextCriteria());

        CPosLmDisplayData* displayData = CPosLmDisplayData::NewL();

		    CleanupStack::PushL(displayData);

        iLandmarkSearch->SetDisplayData(*displayData);

        iOperation = iLandmarkSearch->StartCategorySearchL(*nameCriteria, CPosLmCategoryManager::ECategorySortOrderNone); 

        // The execution flow

        switch (aExecutionMode)

            {

            case ESynchronous:

                ExecuteAndDeleteLD(iOperation);

                break;

            case EAsynchronous:

                RunAsyncOperationLD(iOperation);

                break;

            case EWaitForRequest:

                RunAsyncOperationByWaitForReqL(iOperation);

                delete iOperation;

                break;

            }

        CPosLmItemIterator* iter = iLandmarkSearch->MatchIteratorL();

        CleanupStack::PushL(iter);

        if ((TUint)(aSearchResults[i]->SearchResult()).Count() != iLandmarkSearch->NumOfMatches())

            {

            _LIT(KExpected, "Expected no. of matches: %d");

            _LIT(KReturned, "Returned no. of matches: %d");

            TBuf<100> info;

            info.Format(KExpected, (aSearchResults[i]->SearchResult()).Count());

            iLog->Log(info);

            info.Format(KReturned, iLandmarkSearch->NumOfMatches());

            iLog->Log(info);

            iLog->Log(_L("Name criteria: "));

            iLog->Log(nameCriteria->SearchPattern());

            iLog->Log(KNumOfMatchesErr);

            User::Leave(-1);

            }

        TPosLmItemId id = iter->NextL();

        while (id != KPosLmNullItemId)

            {

            AssertTrueSecL(aSearchResults[i]->FindSearchResult(id), KNotFoundErr, id);

            id = iter->NextL();

            }

		// Check DisplayData below                

        TInt nrr = displayData->Count();

            if ((TUint)(aSearchResults[i]->SearchResult()).Count() != displayData->Count())

            {

            _LIT(KExpected, "Expected no. of displaydata matches: %d");

            _LIT(KReturned, "Returned no. of displaydata matches: %d");

            TBuf<100> info;

            info.Format(KExpected, (aSearchResults[i]->SearchResult()).Count());

            iLog->Log(info);

            info.Format(KReturned, displayData->Count());

            iLog->Log(info);

            iLog->Log(_L("Name criteria: "));

            iLog->Log(nameCriteria->SearchPattern());

            iLog->Log(KNumOfMatchesErr);

            User::Leave(-1);

            }

        TInt itemId = displayData->NewItemIndex();

        while (itemId != KPosLmNoNewItems)

            {

            CPosLmDisplayItem& item = displayData->DisplayItem(itemId);

            if (item.DisplayItemType() != CPosLmDisplayItem::ECategoryItem)

            	{

            	iLog->Log(_L("ERROR :::::"));

            	iLog->Log(_L("Wrong item returned, only ECategoryItem should be returned"));

            	User::Leave(-1);

            	}

            if (item.DisplayItemType() == CPosLmDisplayItem::ELandmarkItem)

            	{

            	iLog->Log(_L("Is ELandmarkItem:::::"));

            	}

            if (item.DatabaseIndex() != 0)

            	{

            	// When single search, index should always be 0

            	iLog->Log(_L("Wrong DatabaseIndex, should be 0"));

            	User::Leave(-1);

            	}

			      TInt categoryId = item.Category().CategoryId();

            if (!aSearchResults[i]->FindSearchResult(categoryId))

            	{

            	iLog->Log(_L("Not Found"));

            	TPtrC name;

				      item.Category().GetCategoryName(name);

    			    iLog->Log(name);

            	iLog->Log(_L("Could not find LandmarkCategory"));

            	User::Leave(-1);

            	}

            	itemId = displayData->NewItemIndex();

            }

        CleanupStack::PopAndDestroy(iter);

				iLandmarkSearch->UnsetDisplayData();

				CleanupStack::PopAndDestroy(displayData);

        CleanupStack::PopAndDestroy(nameCriteria);

        }

    }

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

// CPosTp25::TestSearchPatternLengthL

//

// (other items were commented in a header).

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

//

void CPosTp25::TestSearchPatternLengthL()

    {

    iLog->Log(_L("TestSearchPatternLengthL"));

    CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();  

    //Test with maximum size of search pattern

    //KPosLmMaxCategoryNameLength is 124 (from EPos_Landmarks.h)

    HBufC* hbuf = HBufC::NewLC(KPosLmMaxCategoryNameLength+1);

    while(hbuf->Des().Length() < KPosLmMaxCategoryNameLength)

        {

        hbuf->Des().Append(_L("*"));

        }

    nameCriteria->SetSearchPatternL(*hbuf);

    hbuf->Des().Append(_L("*"));

    TRAPD(err, nameCriteria->SetSearchPatternL(*hbuf));

    AssertTrueSecL(err == KErrArgument, _L("It should not be possible to set search pattern"));            

    CleanupStack::PopAndDestroy(hbuf);

    CleanupStack::PopAndDestroy(nameCriteria);

    }

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

// CPosTp25::SearchWithSortOrderL

//

// (other items were commented in a header).

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

//

void CPosTp25::SearchWithSortOrderL(

    const RPointerArray<CCategorySearchResult>& aSearchResults, 

    TExecutionMode aExecutionMode)

    {

    _LIT(KNumOfMatchesErr, "No. of matches is incorrect when the search is performed");

    CPosLmCategoryManager::TCategorySortPref sortPref;

    for (TInt j=0;j<2;j++)

        {

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

            {   

            CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();

            nameCriteria->SetSearchPatternL(aSearchResults[i]->TextCriteria());

            if (j==0) 

                {

                sortPref = CPosLmCategoryManager::ECategorySortOrderNameAscending;

                iOperation = iLandmarkSearch->StartCategorySearchL(*nameCriteria, sortPref);

                }

            else 

                {

                sortPref = CPosLmCategoryManager::ECategorySortOrderNameDescending;

                iOperation = iLandmarkSearch->StartCategorySearchL(*nameCriteria, sortPref);

                }

            // The execution flow

            switch (aExecutionMode)

                {

                case ESynchronous:

                    ExecuteAndDeleteLD(iOperation);

                    break;

                case EAsynchronous:

                    RunAsyncOperationLD(iOperation);

                    break;

                case EWaitForRequest:

                    RunAsyncOperationByWaitForReqL(iOperation);

                    delete iOperation;

                    break;

                }

            CPosLmItemIterator* iter = iLandmarkSearch->MatchIteratorL();

            CleanupStack::PushL(iter);

            // Create a sorted list out of the search result

            RArray<TPosLmItemId> searchResults = aSearchResults[i]->SearchResult();

            // To avoid User-44 create a copy of the aSearchResults[i]

            RArray<TPosLmItemId> searchResultsSorted;

            CleanupClosePushL(searchResultsSorted);

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

                {

                searchResultsSorted.Append(searchResults[kk]);

                }

            CategoriesSortL(searchResultsSorted, sortPref);

            if ((TUint)(aSearchResults[i]->SearchResult()).Count() != iLandmarkSearch->NumOfMatches())

                {

                _LIT(KExpected, "Expected no. of matches: %d");

                _LIT(KReturned, "Returned no. of matches: %d");

                TBuf<100> info;

                info.Format(KExpected, (aSearchResults[i]->SearchResult()).Count());

                iLog->Log(info);

                info.Format(KReturned, iLandmarkSearch->NumOfMatches());

                iLog->Log(info);

                iLog->Log(_L("Name criteria: "));

                iLog->Log(nameCriteria->SearchPattern());

                iLog->Log(KNumOfMatchesErr);

            		User::Leave(-1);

                }

            TPosLmItemId id = iter->NextL();

            TInt counter=0;

            while (id != KPosLmNullItemId)

                {

                // Check that sort order is correct

                AssertTrueSecL(searchResultsSorted[counter] == id, _L("Error in sorting"));

                id = iter->NextL();

                counter++;

                }

            CleanupStack::PopAndDestroy(&searchResultsSorted);

            CleanupStack::PopAndDestroy(2, nameCriteria);

            }

        }

    }

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

// CPosTp25::SearchWithMaximumL

//

// (other items were commented in a header).

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

//

void CPosTp25::SearchWithMaximumL(

    const RPointerArray<CCategorySearchResult>& aSearchResults, 

    TExecutionMode aExecutionMode)

    {

    _LIT(KNumOfMatchesErr, "No. of matches is incorrect when SearchWithMaximumL is performed");

    _LIT(KNotFoundErr, "Id %d not found in parsed Lm search results when the search is performed syncronously");

    CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();

    // First get the maximum number of matches

    nameCriteria->SetSearchPatternL(_L("*"));  

    ExecuteAndDeleteLD(iLandmarkSearch->StartCategorySearchL(*nameCriteria, CPosLmCategoryManager::ECategorySortOrderNone)); 

    TInt max = iLandmarkSearch->NumOfMatches();

    for (TInt j=1;j<=max;j++)

        {

        nameCriteria->SetSearchPatternL(_L("*"));

        iLandmarkSearch->SetMaxNumOfMatches(j);

        iOperation = iLandmarkSearch->StartCategorySearchL(*nameCriteria, CPosLmCategoryManager::ECategorySortOrderNone); 

        // The execution flow

        switch (aExecutionMode)

            {

            case ESynchronous:

                ExecuteAndDeleteLD(iOperation);

                break;

            case EAsynchronous:

                RunAsyncOperationLD(iOperation);

                break;

            case EWaitForRequest:

                RunAsyncOperationByWaitForReqL(iOperation);

                delete iOperation;

                break;

            }

        AssertTrueSecL((TUint)j == iLandmarkSearch->NumOfMatches(), KNumOfMatchesErr);

        CPosLmItemIterator* iter = iLandmarkSearch->MatchIteratorL();

        CleanupStack::PushL(iter);

        TPosLmItemId id = iter->NextL();

        while (id != KPosLmNullItemId)

            {

            // Use search result for position 0, should always be for *

            AssertTrueSecL(aSearchResults[0]->FindSearchResult(id), KNotFoundErr, id);

            id = iter->NextL();

            }

        CleanupStack::PopAndDestroy(iter);

        }

    CleanupStack::PopAndDestroy(nameCriteria);

    }

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

// CPosTp25::SearchAfterAddedCategoryL

//

// (other items were commented in a header).

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

//

void CPosTp25::SearchAfterAddedCategoryL()

    {