/*

* Copyright (c) 2005 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_line

*

*/

//  INCLUDES

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLmCategoryCriteria.h>

#include <EPos_CPosLMItemIterator.h>    

#include <EPos_CPosLmMultiDbSearch.h>    

#include <EPos_CPosLmDatabaseManager.h> 

#include "FT_CPosTp121.h"

#include "FT_LandmarkConstants.h"

#include "FT_CCategoryLandmarkSearchResult.h"

// CONSTANTS

// Used when searching for global categories (Global categories are dynamically appended in the test.

// There are originally 26 local categories in the databases)

//const TPosLmItemId KRestaurant = 27;

const TPosLmItemId KBar = 28;

//const TPosLmItemId KGas_Station = 29;

const TPosLmItemId KHotel = 30;

//const TPosLmItemId KShop = 31;

const TPosLmItemId KSports_Ground = 33;

const TPosLmItemId KGarage = 34;

const TPosLmItemId KBus_Stop = 36;

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

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

// CPosTp121::CloseTest

//

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

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

//

void CPosTp121::CloseTest()

    {   

    delete iDatabases;

    delete iMultiDbSearch;

    iCategoryLandmarkSearchResults.ResetAndDestroy();

    }

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

// CPosTp121::InitTestL

//

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

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

//

void CPosTp121::InitTestL()

    {

    CLandmarkTestProcedureBase::InitTestL();

    // PrepareDatabases

    RemoveAllLmDatabasesL();

    CopyTestDbFileL(KDb20);

    CopyTestDbFileL(KDb40);

    CopyTestDbFileL(KDb60);

    CopyTestDbFileL(KDb80);

    CopyTestDbFileL(KDb105);

    iNrOfDatabases = 5;

    iLog->Log(_L("Test Dbs Copied"));

    // Initialize data members

    CPosLmDatabaseManager* dbManager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

    iDatabases = dbManager->ListDatabasesLC();

    CleanupStack::Pop(iDatabases);

    iDatabases->Sort(); 

    AssertTrueSecL((iDatabases->Count() == iNrOfDatabases), _L("Wrong number of databases"));

    iMultiDbSearch = CPosLmMultiDbSearch::NewL(*iDatabases);

    CleanupStack::PopAndDestroy(dbManager);

    iLog->Log(_L("Members ready"));

    TInt err = KErrNone;

    CPosLandmarkDatabase* database = NULL; 

    // Reset Global categories for all databases but EPOSLM_105.LDB and add the global category

    // "Hotel" to the 5 first landmarks in the databases.

    for (TInt i = 0; i < iNrOfDatabases - 1; i++) // Do not use global categories in the last db

        {

        database = CPosLandmarkDatabase::OpenL((*iDatabases)[i]);

        CleanupStack::PushL(database);

        if ( database->IsInitializingNeeded() )

            {

            TRAP( err, ExecuteAndDeleteLD( database->InitializeL() ) );

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

            }

        CPosLmCategoryManager* catMan = CPosLmCategoryManager::NewL(*database);

        CleanupStack::PushL(catMan);

        TRAP( err, ExecuteAndDeleteLD( catMan->ResetGlobalCategoriesL() ) );

        AssertTrueSecL( err == KErrNone, _L("Reset cats failed"));

        CleanupStack::PopAndDestroy(2, database);

        }   

    iLog->Log(_L("Cats reset"));

    // Initiallize iCategoryLandmarkSearchResults

    AppendCategoryLandmarkSearchResultsL();

    iLog->Log(_L("AppendCategoryLandmarkSearchResultsL done"));

    }

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

// CPosTp121::StartL

//

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

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

//

void CPosTp121::StartL()

    {

// 1. Search in various ways    

    iLog->Log(_L("Testing search with criteria read from LmDbSearchResult.txt synchronously, using CategoryName. Sort order: ascending"));

    TestSearchL(iCategoryLandmarkSearchResults, ESynchronous, ESortAscending);

    iLog->Log(_L("Testing search with criteria read from LmDbSearchResult.txt synchronously, using CategoryName. Sort order: descending"));

    TestSearchL(iCategoryLandmarkSearchResults, ESynchronous, ESortDescending);

    iLog->Log(_L("Testing search with criteria read from LmDbSearchResult.txt synchronously, using CategoryName. Sort order: none"));

    TestSearchL(iCategoryLandmarkSearchResults, ESynchronous, ESortNone);

    iLog->Log(_L("Testing search with criteria read from LmDbSearchResult.txt asynchronously, using CategoryName. Sort order: ascending"));

    TestSearchL(iCategoryLandmarkSearchResults, EAsynchronous, ESortAscending);

    iLog->Log(_L("Testing search with criteria read from LmDbSearchResult.txt asynchronously, using CategoryName. Sort order: descending"));

    TestSearchL(iCategoryLandmarkSearchResults, EAsynchronous, ESortDescending);

    iLog->Log(_L("Testing search with criteria read from LmDbSearchResult.txt asynchronously, using CategoryName. Sort order: none"));

    TestSearchL(iCategoryLandmarkSearchResults, EAsynchronous, ESortNone);

// 2. Search non-existing category

    iLog->Log(_L("Searching fon nonexisting entries synchronously"));

    SearchNonExistingL(ESynchronous);

    iLog->Log(_L("Searching for nonexisting entries asynchronously"));

    SearchNonExistingL(EAsynchronous);

// 3. Test maximum number of matches

    iLog->Log(_L("Searching with maximum number of results synchronously"));

    TestMaximumNrOfMatchesL(iCategoryLandmarkSearchResults, ESynchronous);

    iLog->Log(_L("Searching with maximum number of results asynchronously"));

    TestMaximumNrOfMatchesL(iCategoryLandmarkSearchResults, EAsynchronous);

// 4. Test cancel

    iLog->Log(_L("Search and cancel the search"));

    SearchAndCancelL();

// 5. Search in global categories

    // Add some more landmarks associated with global categories

    AddLandmarksToGlobalCategoriesL();

    iLog->Log(_L("SearchForLandmarksInGlobalCategoriesL asynchronously"));

    SearchForLandmarksInGlobalCategoriesL(EAsynchronous);

    iLog->Log(_L("SearchForLandmarksInGlobalCategoriesL synchronously"));

    SearchForLandmarksInGlobalCategoriesL(ESynchronous);

// 6. Test some leave codes

    iLog->Log(_L("Check that StartLandmarkSearchL leaves with correct codes"));

    TestLeaveCodesL();

// 7. Test automatically reset of search attributes

    iLog->Log(_L("Check that CPosLmCategoryCriteria resets other criteria when setting a new one"));

    TestResetSearchAttributesL();

// 8. Test searching by name is case insensitive

    iLog->Log(_L("Testing case insensitive"));

    TestCaseInsensitiveL();

// 9. Test search for categories containing wildcards

    iLog->Log(_L("Testing wild cards"));

    TestWildCardsL();

// 10. Test various combinations of refined search

    // Modify database2

    iLog->Log(_L("Testing refined search"));

    RIdArray idArray;

    CleanupClosePushL(idArray);

    idArray.Append(51);

    idArray.Append(52);

    idArray.Append(53);

    CPosLandmarkDatabase* db = CPosLandmarkDatabase::OpenL((*iDatabases)[2]);

    CleanupStack::PushL(db);

    CPosLmCategoryManager* catMan = CPosLmCategoryManager::NewL(*db);

    CleanupStack::PushL(catMan);

    ExecuteAndDeleteLD(catMan->AddCategoryToLandmarksL(14, idArray)); // 14 = TietoEnator kontor

    ExecuteAndDeleteLD(catMan->AddCategoryToLandmarksL(17, idArray)); // 17 = BurgerKing

    ExecuteAndDeleteLD(catMan->AddCategoryToLandmarksL(catMan->GetGlobalCategoryL(15000), idArray)); // 15000 = Entertainment

    CleanupStack::PopAndDestroy(3, &idArray);

    TestRefinedSearchL(ESynchronous);

    TestRefinedSearchL(EAsynchronous);

// 11. Test modify list of databases

    iLog->Log(_L("Testing modifying list of databases"));

    RIdArray expectedMatches;

    CleanupClosePushL(expectedMatches);

    expectedMatches.AppendL(iGasStationId1);

    expectedMatches.AppendL(iGasStationId2);

    expectedMatches.AppendL(51);

    expectedMatches.AppendL(52);

    expectedMatches.AppendL(53);

    TestDatabaseListL(expectedMatches);

// 12. Test on-the-fly

    iLog->Log(_L("Testing searching on the fly"));

    TestOnTheFlySearchL(expectedMatches);

    CleanupStack::PopAndDestroy(&expectedMatches);

    }

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

// CPosTp121::TestSearchL

//

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

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

//

void CPosTp121::TestSearchL(

    const RPointerArray<CCategoryLandmarkSearchResult>& aSearchResults, 

    TExecutionMode aExecutionMode, 

    TTp121SortOrder aSortOrder)

    {

    // Test SetMaxNumOfMatches, first set to one and then back to unlimited

    iMultiDbSearch->SetMaxNumOfMatches(1);

    iMultiDbSearch->SetMaxNumOfMatches();

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

        {   

        CPosLmCategoryCriteria* catSearchCriteria = CPosLmCategoryCriteria::NewLC();

        // Perform search by name

        catSearchCriteria->SetCategoryNameL(aSearchResults[i]->CategoryName());

        iLog->Log(aSearchResults[i]->CategoryName());

        SearchL(catSearchCriteria, aExecutionMode, aSearchResults[i]->Redefined(), aSortOrder);

        if (i != 28)

            {

            // Row 28 in xls-file contains an error. If fixed, TP21 starts to fail.

            ValidateSearchResultsL(aSearchResults[i], iMultiDbSearch, aSortOrder);

            ValidateTotalNrOfMatchesL(

                iMultiDbSearch->TotalNumOfMatches(),

                (TUint)(aSearchResults[i]->SearchResult()).Count(),

                catSearchCriteria->CategoryName());

            }

        CleanupStack::PopAndDestroy(catSearchCriteria);

        }

    }

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

// CPosTp121::SearchForLandmarksInGlobalCategoriesL

//

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

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

//

void CPosTp121::SearchForLandmarksInGlobalCategoriesL(

    TExecutionMode aExecutionMode)

    {

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

    CPosLmCategoryCriteria* catSearchCriteria = CPosLmCategoryCriteria::NewLC();

    RIdArray expectedIds;

    CleanupClosePushL(expectedIds);

    // Search for "Accommodation", should result in two matches

    catSearchCriteria->SetGlobalCategory( KAccommodation );

    SearchL(catSearchCriteria, aExecutionMode);

    expectedIds.AppendL(iRestaurantId1);

    expectedIds.AppendL(iRestaurantId2);

    ValidateSearchResultsL(expectedIds, iMultiDbSearch);

    expectedIds.Reset();

    // Search for "Entertainment" id using the global category id should result in two matches

    catSearchCriteria->SetGlobalCategory(KBusiness);

    SearchL(catSearchCriteria, aExecutionMode);

    expectedIds.AppendL(iGasStationId1);

    expectedIds.AppendL(iGasStationId2);

    ValidateSearchResultsL(expectedIds, iMultiDbSearch);

    expectedIds.Reset();

    // Search for "Accommodation" in the result from previous search

    catSearchCriteria->SetGlobalCategory(KAccommodation);

    SearchL(catSearchCriteria, aExecutionMode, ETrue);

    expectedIds.AppendL(iGasStationId2);

    ValidateSearchResultsL(expectedIds, iMultiDbSearch);

    expectedIds.Reset();

    // Search for a non existing global category in the result from previous search

    // Nothing should be found

    catSearchCriteria->SetCategoryNameL(_L("NonExistingGLobalCategory"));

    SearchL(catSearchCriteria, aExecutionMode, ETrue);

    ValidateSearchResultsL(expectedIds, iMultiDbSearch);

    expectedIds.Reset();

    // Search for "Accommodation" using the globalcategory id

    catSearchCriteria->SetGlobalCategory(3000);

    SearchL(catSearchCriteria, aExecutionMode);

    expectedIds.AppendL(iRestaurantId1);

    expectedIds.AppendL(iRestaurantId2);

    ValidateSearchResultsL(expectedIds, iMultiDbSearch);

    expectedIds.Reset();

    // Search for "Entertainment" using the globalcategory id from the result 

    // from previous search

    catSearchCriteria->SetGlobalCategory(15000);

    SearchL(catSearchCriteria, aExecutionMode, ETrue);

    expectedIds.AppendL(iGasStationId2);

    ValidateSearchResultsL(expectedIds, iMultiDbSearch);

    expectedIds.Reset();

    CleanupStack::PopAndDestroy(2, catSearchCriteria);

    }

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

// CPosTp121::AddLandmarksToGlobalCategoriesL

//

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

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

//

void CPosTp121::AddLandmarksToGlobalCategoriesL()

    {

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

    // Add some new landmarks to the dbs, associate some with global categories

    CPosLandmarkDatabase* db = CPosLandmarkDatabase::OpenL((*iDatabases)[0]);

    CleanupStack::PushL(db);

    CPosLandmark* lm = CPosLandmark::NewLC();

    lm->SetLandmarkNameL(_L("LandmarkName1"));

    lm->SetLandmarkDescriptionL(_L("SomeLandmarkDescription"));    

	/*************************************************************/

	// Search for id maintained by database for the global category

	CPosLmCategoryManager* catMan = CPosLmCategoryManager::NewL( *db );

	CleanupStack::PushL(catMan);

    TPosLmItemId globCatId1 = catMan->GetGlobalCategoryL( KAccommodation );

    TPosLmItemId globCatId2 = catMan->GetGlobalCategoryL( KEntertainment );

	CPosLandmarkCategory* cat = catMan->ReadCategoryLC( globCatId1 );

	CleanupStack::PopAndDestroy( 2 );	

	/*************************************************************/    

    lm->AddCategoryL( globCatId1 );  

    TPosLmItemId id = db->AddLandmarkL(*lm);

    iRestaurantId1 = id;

    CleanupStack::PopAndDestroy(2, db);    

    db = CPosLandmarkDatabase::OpenL((*iDatabases)[1]);

    CleanupStack::PushL(db);

    lm = CPosLandmark::NewLC();

    db->AddLandmarkL(*lm); // Add one uncategorized to increase id in order to avoid equal ids between dbs.

    lm->SetLandmarkNameL(_L("LandmarkName2"));

    lm->SetLandmarkDescriptionL(_L("SomeLandmarkDescription2"));    

    lm->AddCategoryL(KBus_Stop);

    id = db->AddLandmarkL(*lm);

    CleanupStack::PopAndDestroy(2, db);

    db = CPosLandmarkDatabase::OpenL((*iDatabases)[2]);

    CleanupStack::PushL(db);

    lm = CPosLandmark::NewLC();

    db->AddLandmarkL(*lm); // Add two uncategorized to increase id in order to avoid equal ids between dbs.

    db->AddLandmarkL(*lm); 

    lm->SetLandmarkNameL(_L("LandmarkName3"));

    lm->SetLandmarkDescriptionL(_L("SomeLandmarkDescription3"));    

    lm->AddCategoryL( globCatId2 ); 

    lm->AddCategoryL(KHotel);

    //lm->AddCategoryL(KShop);

    lm->AddCategoryL(KBar);

    lm->AddCategoryL(KSports_Ground);

    lm->AddCategoryL(KGarage);

    id = db->AddLandmarkL(*lm);

    iGarageId1 = id;

    iGasStationId1 = id;

    CleanupStack::PopAndDestroy(2, db);

    db = CPosLandmarkDatabase::OpenL((*iDatabases)[3]);

    CleanupStack::PushL(db);

    lm = CPosLandmark::NewLC();

    db->AddLandmarkL(*lm); // Add three uncategorized to increase id in order to avoid equal ids between dbs.

    db->AddLandmarkL(*lm); 

    db->AddLandmarkL(*lm); 

    lm->SetLandmarkNameL(_L("LandmarkName4"));

    lm->SetLandmarkDescriptionL(_L("SomeLandmarkDescription4"));    

    lm->AddCategoryL(KBar);

    lm->AddCategoryL( globCatId1 );  

    lm->AddCategoryL( globCatId2 );

    lm->AddCategoryL(KHotel);

   // lm->AddCategoryL(KShop);

   	lm->AddCategoryL(KBar);

    lm->AddCategoryL(1);

    lm->AddCategoryL(2);

    lm->AddCategoryL(3);

    id = db->AddLandmarkL(*lm);

    iRestaurantId2 = id;

    iGasStationId2 = id;

    CleanupStack::PopAndDestroy(lm);

    lm = CPosLandmark::NewLC();

    lm->SetLandmarkNameL(_L("LandmarkName5"));

    lm->SetLandmarkDescriptionL(_L("SomeLandmarkDescription5"));

    lm->AddCategoryL(KBus_Stop);

    db->AddLandmarkL(*lm);

    CleanupStack::PopAndDestroy(2, db);

    }

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

// CPosTp121::SearchNonExistingL

//

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

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

//

void CPosTp121::SearchNonExistingL(TExecutionMode aExecutionMode)

    {

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

    _LIT(KCategoryName, "NonExistingLandmark");

    CPosLmCategoryCriteria* catSearchCriteria = CPosLmCategoryCriteria::NewLC();

    catSearchCriteria->SetCategoryNameL(KCategoryName);

    SearchL(catSearchCriteria, aExecutionMode);

    ValidateTotalNrOfMatchesL(iMultiDbSearch->TotalNumOfMatches(), 0, KCategoryName);

    ValidateSearchResultsL(NULL, iMultiDbSearch);

    CleanupStack::PopAndDestroy(catSearchCriteria);

    catSearchCriteria = CPosLmCategoryCriteria::NewLC();

    TPosLmGlobalCategory nonExistingId = 56789; 

    catSearchCriteria->SetGlobalCategory(nonExistingId);

    SearchL(catSearchCriteria, aExecutionMode);

    ValidateTotalNrOfMatchesL(iMultiDbSearch->TotalNumOfMatches(), 0, KCategoryName);

    ValidateSearchResultsL(NULL, iMultiDbSearch);

    CleanupStack::PopAndDestroy(catSearchCriteria);

    }

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

// CPosTp121::TestMaximumNrOfMatchesL

//

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

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

//

void CPosTp121::TestMaximumNrOfMatchesL(

    const RPointerArray<CCategoryLandmarkSearchResult>& aSearchResults, 

    TExecutionMode aExecutionMode)

    {

    CPosLmCategoryCriteria* catSearchCriteria = CPosLmCategoryCriteria::NewLC();

    TInt idFromXls = 25; // Use 25 "Läkarna"

    catSearchCriteria->SetCategoryNameL(aSearchResults[idFromXls]->CategoryName());

    iLog->Log(aSearchResults[idFromXls]->CategoryName());

    SearchL(catSearchCriteria, aExecutionMode, aSearchResults[idFromXls]->Redefined());

    ValidateTotalNrOfMatchesL(

    		iMultiDbSearch->TotalNumOfMatches(),

    		(TUint)(aSearchResults[idFromXls]->SearchResult()).Count(), 

    		aSearchResults[idFromXls]->CategoryName());

    ValidateSearchResultsL(aSearchResults[idFromXls], iMultiDbSearch);

    // Set maximum number, first set to more than should be found here 13 in each db must be enough

    iLog->Log(_L("Set to 13 * iNrOfDatabases = 65 matches"));

    TUint maxMatches = 13;

    iMultiDbSearch->SetMaxNumOfMatches(13);

    SearchL(catSearchCriteria, aExecutionMode, ETrue);

    ValidateTotalNrOfMatchesL(

        iMultiDbSearch->TotalNumOfMatches(),

        (TUint)(aSearchResults[idFromXls]->SearchResult()).Count(), 

        aSearchResults[idFromXls]->CategoryName());

    ValidateSearchResultsL(aSearchResults[idFromXls], iMultiDbSearch);

    // Set maximum number here to 3 in each db

    iLog->Log(_L("Set to 3 * iNrOfDatabases = 10 matches"));

    maxMatches = 3;

    const TInt KNrOfDbsWithMatches = 3;

    iMultiDbSearch->SetMaxNumOfMatches(maxMatches);

    SearchL(catSearchCriteria, aExecutionMode, ETrue);

    ValidateTotalNrOfMatchesL(

        iMultiDbSearch->TotalNumOfMatches(),

        maxMatches * KNrOfDbsWithMatches, // only three of the databases contain matches

        aSearchResults[idFromXls]->CategoryName());

    ValidateSearchResultsL(aSearchResults[idFromXls], iMultiDbSearch);

    // Set maximum number here to 1 in each db

    maxMatches = 1;

    iLog->Log(_L("Set to 1 * iNrOfDatabases = 5 matches"));

    iMultiDbSearch->SetMaxNumOfMatches(maxMatches);

    SearchL(catSearchCriteria, aExecutionMode, ETrue);

    ValidateTotalNrOfMatchesL(

        iMultiDbSearch->TotalNumOfMatches(),

        maxMatches * KNrOfDbsWithMatches, 

        aSearchResults[idFromXls]->CategoryName());

    ValidateSearchResultsL(aSearchResults[idFromXls], iMultiDbSearch);

    // Set maximum number here to 2 in each db, however since search is refined only 3 matches should be returned

    maxMatches = 2;

    iLog->Log(_L("Set to 2 * iNrOfDatabases = 10 matches"));

    iMultiDbSearch->SetMaxNumOfMatches(maxMatches);

    SearchL(catSearchCriteria, aExecutionMode, ETrue);

    ValidateTotalNrOfMatchesL(

        iMultiDbSearch->TotalNumOfMatches(),

        1 * KNrOfDbsWithMatches, 

        aSearchResults[idFromXls]->CategoryName());

    ValidateSearchResultsL(aSearchResults[idFromXls], iMultiDbSearch);

    // Same as above but no refined search is made. Should get 2 * 3 matches

    iLog->Log(_L("Set to 2 * iNrOfDatabases = 10 matches"));

    iMultiDbSearch->SetMaxNumOfMatches(maxMatches);

    SearchL(catSearchCriteria, aExecutionMode);

    ValidateTotalNrOfMatchesL(