/*

* 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_CPosTp125.h"

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLmMultiDbSearch.h> 

#include <EPos_CPosLmTextCriteria.h>

#include <EPos_CPosLmCatNameCriteria.h>

#include <EPos_CPosLMItemIterator.h>    

#include <EPos_TPosLMSortPref.h>

#include "FT_CSearchResult.h"

#include <EPos_CPosLmDatabaseManager.h>

#include <EPos_CPosLmDisplayData.h>

#include <EPos_CPosLmDisplayItem.h>

#include "FT_LandmarkConstants.h"

// CONSTANTS

    _LIT(KPizzeria,          "Pizzeria");           // Db 1, id  1

    _LIT(KHambergerbar,      "Hamburgerbar");       // Db 1, id  2        

    _LIT(KKinarestaurang,    "Kinarestaurang");     // Db 1, id  3

    _LIT(KGaraget,           "Garaget");            // Db 1, id  4

    _LIT(KBilverkstad,       "Bilverkstad");        // Db 1, id  5

    _LIT(KPastaRestaurang,   "Pasta Restaurang");   // Db 2, id  6

    _LIT(KBilia,             "Bilia");              // Db 2, id  7

    _LIT(KVolksWagen,        "VolksWagen");         // Db 2, id  8

    _LIT(KTaxiGoteborg,      "Taxi Göteborg");      // Db 2, id  9

    _LIT(KTaxi,              "Taxi");               // Db 2, id 10

    _LIT(KStadsbibliotek,    "Stadsbibliotek");     // Db 2, id 11

    _LIT(KSystembolag,       "Systembolag");        // Db 2, id 12

    _LIT(KNokiKontor,        "Nokia Kontor");       // Db 2, id 13

    _LIT(KTietoEnatorKontor, "TietoEnator kontor"); // Db 2, id 14

    _LIT(KThaiRestaurang,    "Thai Restaurang");    // Db 3, id 15

    _LIT(KMcDonalds,         "McDonalds");          // Db 3, id 16

    _LIT(KBurgerKing,        "BurgerKing");         // Db 3, id 17

    _LIT(KFrisor,            "Frisör");             // Db 3, id 18

    _LIT(KHunddagis,         "Hunddagis");          // Db 3, id 19

    _LIT(KVeterinar,         "Veterinär");          // Db 3, id 20

    _LIT(KKyrkogard,         "Kyrkogċrd");          // Db 4, id 21

    _LIT(KMuseum,            "Museum");             // Db 4, id 22

    _LIT(KDagis,             "Dagis");              // Db 4, id 23

    _LIT(KStadspark,         "StadsPark");          // Db 4, id 24

    _LIT(KSjukhus,           "Sjukhus");            // Db 5, id 25

    _LIT(KLakare,            "Läkare");             // Db 5, id 26

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

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

// CPosTp125::CloseTest

//

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

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

//

void CPosTp125::CloseTest()

    {

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

    delete iLandmarksMultiDbSearch;

    iLandmarksMultiDbSearch = NULL;

    delete iDatabase;

    iDatabase=NULL;

    iCategorySearchResults.ResetAndDestroy();

    TRAPD(err, RemoveGlobalCategoriesL());

    TBuf<50> buf;

    if (err != KErrNone) 

        {

        buf.Format(_L("RemoveGlobalCategoriesL leaved with %d"), err);

        iLog->Log(buf);

        }

    }

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

// CPosTp125::StartL

//

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

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

//

void CPosTp125::StartL()

    {

    RemoveAllLmDatabasesL();

    CopyTestDbFileL(KDb20);

    CopyTestDbFileL(KDb40);

    CopyTestDbFileL(KDb60);

    CopyTestDbFileL(KDb80);

    CopyTestDbFileL(KDb105);

    SetupDbArrayL();

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

    CDesCArray* dbList = new (ELeave) CDesCArrayFlat(8);

    CleanupStack::PushL(dbList);

    dbList->AppendL(KDb20);

    dbList->AppendL(KDb40);

    dbList->AppendL(KDb60);

    dbList->AppendL(KDb80);

    dbList->AppendL(KDb105);

    RemoveExtraCategoriesL();

    iLandmarksMultiDbSearch = CPosLmMultiDbSearch::NewL(*dbList);

    TInt err = KErrNone;

    CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();

    // Start by testing some error flows, returning KErrArgument

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

    AssertTrueSecL(err == KErrArgument, KEmptyTextCriteriaErr);

    // Test empty string

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

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

    AssertTrueSecL(err == KErrArgument, KEmptyTextCriteriaErr);

    CleanupStack::PopAndDestroy(nameCriteria);

    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 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 iLandmarksMultiDbSearch;

    iLandmarksMultiDbSearch = NULL;

    CPosLmDatabaseManager* dbMan = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbMan);

    dbMan->SetDefaultDatabaseUriL(KDb20);

    iDatabase = CPosLandmarkDatabase::OpenL();

    iLandmarksMultiDbSearch = CPosLmMultiDbSearch::NewL(*dbList);

    // Do reset so that global categories are included

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

    ExecuteAndDeleteLD(iDatabase->InitializeL());

    CleanupStack::PushL(categoryManager);   

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

    // Test to add the global categories to one more DB

    delete iDatabase;

    iDatabase = NULL;

    delete iLandmarksMultiDbSearch;

    iLandmarksMultiDbSearch = NULL;

    dbMan->SetDefaultDatabaseUriL(KDb40);

    CleanupStack::PopAndDestroy(dbMan);

    iDatabase = CPosLandmarkDatabase::OpenL();

    iLandmarksMultiDbSearch = CPosLmMultiDbSearch::NewL(*dbList);

    // Do reset so that global categories are included

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

    ExecuteAndDeleteLD(iDatabase->InitializeL());

    CleanupStack::PushL(categoryManager2);   

    CleanupStack::PopAndDestroy(categoryManager2);

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

    TestDuplicateGlobalCategoriesL(iCategorySearchResults, ETrue);

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

    TestDuplicateGlobalCategoriesL(iCategorySearchResults, EFalse);

    RemoveGlobalCategoriesL();

    CleanupStack::PopAndDestroy(dbList);

    }

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

// CPosTp125::SearchL

//

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

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

//

void CPosTp125::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");

    CPosLmDisplayData* displayData = CPosLmDisplayData::NewL();

    CleanupStack::PushL(displayData);

    iLandmarksMultiDbSearch->SetDisplayData(*displayData);

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

        {   

        CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();

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

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

        // The execution flow

        switch (aExecutionMode)

            {

            case ESynchronous:

                ExecuteAndDeleteLD(iOperation);

                break;

            case EAsynchronous:

                RunAsyncOperationLD(iOperation);

                break;

            }

        TInt matchesSum = 0;

        for (TInt count = 0; count < 5; count++)

            {

            matchesSum += iLandmarksMultiDbSearch->NumOfMatches(count);

            }

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

            {

           	iLog->Log(KNumOfMatchesErr);

    		User::Leave(-1);

            }

        // Test the display data:

        TInt displayCount = displayData->Count();

        if (displayCount != matchesSum)

            {

            iLog->Log(KNumOfMatchesErr);

    		User::Leave(-1);

            }

        TInt count = 0;

        TInt dbIndex = 0;

        TInt categoryId = 0;

        TPtrC categoryName;

        TBuf<100> categoryName2;

        _LIT(KErrCatMismatch, "Category wrong in display data");

        _LIT(KErrorWrongType, "Display data doesn't indicate ECategoryItem when it should.");

        for (count = 0; count < displayCount; count++)

            {

            CPosLmDisplayItem& displayItem = displayData->DisplayItem(count);

            // Check that the item indicates that it contains a category

            AssertTrueSecL(displayItem.DisplayItemType() == CPosLmDisplayItem::ECategoryItem, KErrorWrongType);

            const CPosLandmarkCategory& displayCategory = displayItem.Category();

            dbIndex = displayItem.DatabaseIndex();

            categoryId = displayCategory.CategoryId();

            // Check that the db index is correct

            AssertThatIdIsInCorrectDbL(dbIndex, categoryId);

            // Check that this match is correct

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

            displayCategory.GetCategoryName(categoryName);

            categoryName2 = (*iDbArray)[categoryId - 1]; // Compensate for 0-index

            // Check that the category name is correct

            AssertTrueSecL(categoryName == categoryName2, KErrCatMismatch);

            }

        CPosLmItemIterator* iter = NULL;

        for (count = 0; count < 5; count++)

            {

            iter = iLandmarksMultiDbSearch->MatchIteratorL(count);

            CleanupStack::PushL(iter);

            TPosLmItemId id = iter->NextL();

            while (id != KPosLmNullItemId)

                {

                AssertThatIdIsInCorrectDbL(count, id);

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

                id = iter->NextL();            

                }

            CleanupStack::PopAndDestroy(iter);

            iter = NULL;

            }

        CleanupStack::PopAndDestroy(nameCriteria);

        }

        iLandmarksMultiDbSearch->UnsetDisplayData();

        CleanupStack::PopAndDestroy(displayData);

    }

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

// CPosTp125::SearchWithSortOrderL

//

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

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

//

void CPosTp125::SearchWithSortOrderL(

    const RPointerArray<CCategorySearchResult>& aSearchResults, 

    TExecutionMode aExecutionMode)

    {

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

    _LIT(KErrorInSorting, "Error in sorting");

    CPosLmCategoryManager::TCategorySortPref sortPref;

    CPosLmDisplayData* displayData = CPosLmDisplayData::NewL();

    CleanupStack::PushL(displayData);

    iLandmarksMultiDbSearch->SetDisplayData(*displayData);

    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 = iLandmarksMultiDbSearch->StartCategorySearchL(*nameCriteria, sortPref);

                }

            else 

                {

                sortPref = CPosLmCategoryManager::ECategorySortOrderNameDescending;

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

                }

            // The execution flow

            switch (aExecutionMode)

                {

                case ESynchronous:

                    ExecuteAndDeleteLD(iOperation);

                    break;

                case EAsynchronous:

                    RunAsyncOperationLD(iOperation);

                    break;

                }

            TInt matchesSum = 0;

            for (TInt count = 0; count < 5; count++)

                {

                matchesSum += iLandmarksMultiDbSearch->NumOfMatches(count);

                }

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

                {

               	iLog->Log(KNumOfMatchesErr);

    			User::Leave(-1);

                }

            TInt displayCount = displayData->Count();

            if (displayCount != matchesSum)

                {

                iLog->Log(KNumOfMatchesErr);

    			User::Leave(-1);

                }

            // Test the display data:

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

                }

            CDesCArrayFlat* sortedArray = NULL;

            SortResultsL(searchResultsSorted, sortedArray);

            CleanupStack::PopAndDestroy(); // searchResultsSorted

            CleanupStack::PushL(sortedArray);

            if (sortPref == CPosLmCategoryManager::ECategorySortOrderNameDescending)

                {

                InvertArrayL(sortedArray);

                }

            TInt count = 0;

            TInt categoryId = 0;

            TBuf<100> categoryName2;

            TBuf<100> categoryName3;

            for (count = 0; count < displayCount; count++)

                {

                CPosLmDisplayItem& displayItem = displayData->DisplayItem(count);

                const CPosLandmarkCategory& displayCategory = displayItem.Category();

                categoryId = displayCategory.CategoryId();

                categoryName2 = (*iDbArray)[categoryId - 1]; // Compensate for 0-index

                categoryName3 = (*sortedArray)[count];

                // Check that sort order is correct

                AssertTrueSecL(categoryName3 == categoryName2, _L("Error in sorting"));

                }

            CleanupStack::PopAndDestroy(sortedArray);   

            typedef RArray<TInt> myArrayType;

            RArray<myArrayType> resultArray;

            myArrayType array1;

            myArrayType array2;

            myArrayType array3;

            myArrayType array4;

            myArrayType array5;

            CleanupClosePushL(resultArray);

            CleanupClosePushL(array1);

            CleanupClosePushL(array2);

            CleanupClosePushL(array3);

            CleanupClosePushL(array4);

            CleanupClosePushL(array5);

            if (sortPref == CPosLmCategoryManager::ECategorySortOrderNameAscending)

                {                        

                array1.AppendL(5);

                array1.AppendL(4);

                array1.AppendL(2);

                array1.AppendL(3);

                array1.AppendL(1);

                array2.AppendL(7);

                array2.AppendL(13);

                array2.AppendL(6);

                array2.AppendL(11);

                array2.AppendL(12);

                array2.AppendL(10);

                array2.AppendL(9);

                array2.AppendL(14);

                array2.AppendL(8);

                array3.AppendL(17);

                array3.AppendL(18);

                array3.AppendL(19);

                array3.AppendL(16);

                array3.AppendL(15);

                array3.AppendL(20);

                array4.AppendL(23);

                array4.AppendL(21);

                array4.AppendL(22);

                array4.AppendL(24);

                array5.AppendL(26);

                array5.AppendL(25);

                }

            else

                {

                array1.AppendL(1);

                array1.AppendL(3);

                array1.AppendL(2);

                array1.AppendL(4);

                array1.AppendL(5);

                array2.AppendL(8);

                array2.AppendL(14);

                array2.AppendL(9);

                array2.AppendL(10);

                array2.AppendL(12);

                array2.AppendL(11);

                array2.AppendL(6);

                array2.AppendL(13);

                array2.AppendL(7);

                array3.AppendL(20);

                array3.AppendL(15);

                array3.AppendL(16);

                array3.AppendL(19);

                array3.AppendL(18);

                array3.AppendL(17);

                array4.AppendL(24);

                array4.AppendL(22);

                array4.AppendL(21);

                array4.AppendL(23);

                array5.AppendL(25);

                array5.AppendL(26);

                }

            resultArray.Append(array1);

            resultArray.Append(array2);

            resultArray.Append(array3);