/*

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

#include "FT_LandmarkConstants.h"

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLmCategoryManager.h>

#include <EPos_CPosLmAreaCriteria.h>

#include <EPos_CPosLMItemIterator.h>    

#include <EPos_TPosLMSortPref.h>

// CONSTANTS  

const TInt KNrOfDbs = 5;

const TInt KLmPerDb = 20;

const TInt KTotLms = 105;

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

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

// CPosTp120::CloseTest

//

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

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

//

void CPosTp120::CloseTest()

    {

    delete iDatabase;

    iDatabase = NULL;

    delete iDbArray;

    delete iLmMultiSearch;

    iLmMultiSearch = NULL;

    iAreaSearchResults.ResetAndDestroy();

    REComSession::FinalClose();

    }

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

// CPosTp120::StartL

//

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

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

//

void CPosTp120::StartL()

    {

    // Split databases, NrOfDBs db, LmPerDb lm in each, TotLms is last lm id from original db.

    // Last param is to enable/disable debug

    iDbArray = CreateDatabasesL(KNrOfDbs, KLmPerDb, KTotLms); //, ETrue);    

    // Constructing a lm multi search 

    iLmMultiSearch = CPosLmMultiDbSearch::NewL(*iDbArray);

    AppendAreaSearchResultsL();

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

    SearchL(iAreaSearchResults, ESynchronous);

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

    SearchL(iAreaSearchResults, EAsynchronous);

    iLog->Log(_L("Testing search with a defined sortorder"));

    SearchWithSortOrderL(iAreaSearchResults);   

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

    SearchAndCancelL();

    iLog->Log(_L("Testing maximum number of matches"));

    SearchWithMaximumL();

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

    OnTheFlySearchL();  

    iLog->Log(_L("Testing a redefined search after landmarks have been renamed"));

    SearchAndRenameL();

    iLog->Log(_L("Testing a redefined search after a landmark has been removed"));

    SearchAndDeleteL();

    }

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

// CPosTp120::AreaCriteriaL

//

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

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

//

CPosLmAreaCriteria* CPosTp120::AreaCriteriaL(const TReal64 &aSouthLat, 

                                             const TReal64 &aNorthLat,

                                             const TReal64 &aWestLong, 

                                             const TReal64 &aEastLong) 

    {

    CPosLmAreaCriteria* areaCriteria = CPosLmAreaCriteria::NewLC(aSouthLat, 

                                                                aNorthLat, 

                                                                aWestLong, 

                                                                aEastLong);

    CleanupStack::Pop();

    return areaCriteria;

    }

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

// CPosTp120::CheckDatabasesL

//

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

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

//

void CPosTp120::CheckDatabasesL(

    CDesCArray* aExpectedLmUris,

    TUint aExpectedMaxMatches)

    {

    CDesCArray* dbToSearch = iLmMultiSearch->DatabasesToSearchL();

    CleanupStack::PushL(dbToSearch);

    _LIT(KWrongNrDatabases, "Wrong number of databases to search!");

    AssertTrueSecL(aExpectedLmUris != dbToSearch, KWrongNrDatabases);

    AssertTrueSecL(aExpectedLmUris->Count() == dbToSearch->Count(), KWrongNrDatabases);

    CleanupStack::PopAndDestroy(dbToSearch);

    AssertTrueSecL(aExpectedLmUris->Count() == iLmMultiSearch->NumOfDatabasesToSearch(), 

        KWrongNrDatabases);

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

        {

        AssertTrueSecL(aExpectedLmUris->MdcaPoint(i) == iLmMultiSearch->DatabaseUriPtr(i), 

            KWrongNrDatabases);        

        }

    _LIT(KWrongNrMatches, "Wrong number of max matches!");

    AssertTrueSecL(iLmMultiSearch->MaxNumOfMatches() == aExpectedMaxMatches, 

        KWrongNrMatches);        

    }

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

// CPosTp120::GetLmIdsL

//

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

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

//

void CPosTp120::GetLmIdsL(

    TInt aDbId, 

    RArray<TPosLmItemId> aSearchResults,

    RArray<TPosLmItemId>& aLmIdForADb)

    {

    TInt startId = aDbId * KLmPerDb + 1;

    TInt stopId = 0;

    if (aDbId == KNrOfDbs - 1)

        {

        stopId = KTotLms;            

        }

    else 

        {

        stopId = (aDbId+1) * KLmPerDb;            

        }

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

        {

        if (aSearchResults[i] >= startId && aSearchResults[i] <= stopId)

            {

            User::LeaveIfError(aLmIdForADb.Append(aSearchResults[i]));

            }

        }

    }

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

// CPosTp120::CheckEqualsLmsL

//

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

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

//

void CPosTp120::CheckEqualsLmsL(

    TPosLmItemId aSource, 

    TPosLmItemId aTarget)

    {

    _LIT(KSortorderErr, "The sortorder is incorrect");

    if (aSource != aTarget)

        {                

        // Check if same name then don't Leave

        CPosLandmark* source = iDatabase->ReadLandmarkLC(aSource);

        CPosLandmark* target = iDatabase->ReadLandmarkLC(aTarget);

        TPtrC sourceName, targetName;

        source->GetLandmarkName(sourceName);

        target->GetLandmarkName(targetName);

        if (EFalse)

            {

            // For debugging purposes

            TBuf<100> buf;

            buf.Append(_L("Name:"));

            buf.Append(sourceName);

            buf.Append(targetName);

            iLog->Log(buf);

            }

        AssertTrueSecL(!sourceName.CompareC(targetName), KSortorderErr, aSource);

        CleanupStack::PopAndDestroy(2, source); // target, source

        }

    }

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

// CPosTp120::SearchL

//

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

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

//

void CPosTp120::SearchL(

    const RPointerArray<CAreaSearchResult>& 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");

    TBuf<255> info;

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

        {   

        CPosLmAreaCriteria* areaCriteria = NULL;

        TRAPD(err, areaCriteria = CPosTp120::AreaCriteriaL(aSearchResults[i]->SouthLat(),

                                                aSearchResults[i]->NorthLat(),

                                                aSearchResults[i]->WestLong(),

                                                aSearchResults[i]->EastLong()));

        CleanupStack::PushL(areaCriteria);

        if (err != aSearchResults[i]->ErrorCode())

            {

            iLog->Log(_L("Unexpected error code returned"));    

            iLog->Log(_L("Area Search result read from file:"));

            aSearchResults[i]->Print(info);

            iLog->Log(info);

            _LIT(KReturned, "Search returned errorCode = %d");

            info.Format(KReturned, err);

            iLog->Log(info);

            User::Leave(KErrGeneral);

            }

        if (!err)

            {

            CPosLmOperation* operation = 

                iLmMultiSearch->StartLandmarkSearchL(*areaCriteria, aSearchResults[i]->Redefined());

            CleanupStack::PushL(operation);

             switch (aExecutionMode)

                {

                case ESynchronous:

                    ExecuteAndDeleteLD(operation);

                    CleanupStack::Pop(operation);

                    break;

                case EAsynchronous:

                    RunAsyncOperationLD(operation);

                    CleanupStack::Pop(operation);

                    break;

                case EWaitForRequest:

                    RunAsyncOperationByWaitForReqL(operation);

                    CleanupStack::PopAndDestroy(operation);                

                    break;

                }

            // Check database array

            CheckDatabasesL(iDbArray);

            // Check for errors        

            AssertTrueSecL(iLmMultiSearch->NumOfSearchErrors() == 0, 

                _L("Error(s) found during multi search."));

            // Check total number of matches       

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

                iLmMultiSearch->TotalNumOfMatches())

                {

                _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, iLmMultiSearch->TotalNumOfMatches());

                iLog->Log(info);

                iLog->Log(KNumOfMatchesErr);

                User::Leave(-1);

                }

            RArray<TPosLmItemId> lmids;

            CleanupClosePushL(lmids);

            for (TInt j=0; j<iLmMultiSearch->NumOfDatabasesToSearch(); j++) 

                {

                CPosLmItemIterator* iter = iLmMultiSearch->MatchIteratorL(j);

                // Check if there are any matches = iteration exists.

                if (iter) 

                    {

                    CleanupStack::PushL(iter);

                    TPosLmItemId id = iter->NextL();    

                    while (id != KPosLmNullItemId)

                        {

                        // Check that found id is expected

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

                        User::LeaveIfError(lmids.Append(id));                              

                        id = iter->NextL();

                        }

                    CleanupStack::PopAndDestroy(iter);                

                    }

                else 

                    {

                    _LIT(KIterNull, "MatchIterator returned null for a db");

                    iLog->Log(KIterNull);

                    }

                }

            AssertTrueSecL(aSearchResults[i]->SearchResult().Count() == lmids.Count(), 

                _L("Expected number of hits and found hits don't match"));

            for (TInt k=0; k<lmids.Count(); k++)

                {

                // Check that found id is expected from all ids

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

                }

            CleanupStack::PopAndDestroy(&lmids); // lmids

            }

        CleanupStack::PopAndDestroy(areaCriteria);

        _LIT(KSearchNr, "Multi search test index #%d executed ok.");

        TBuf<100> buf;

        buf.Format(KSearchNr, i);        

        iLog->Log(buf);

        }

    }

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

// CPosTp120::SearchWithSortOrderL

//

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

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

//

void CPosTp120::SearchWithSortOrderL(const RPointerArray<CAreaSearchResult>& aSearchResults)

    {

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

    TPosLmSortPref sortPref(CPosLandmark::ELandmarkName, TPosLmSortPref::EAscending);  

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

        {   

        CPosLmAreaCriteria* areaCriteria = NULL;

        TRAPD(err, areaCriteria = AreaCriteriaL(

                    iAreaSearchResults[j]->SouthLat(),

                    iAreaSearchResults[j]->NorthLat(),

                    iAreaSearchResults[j]->WestLong(),

                    iAreaSearchResults[j]->EastLong()));

        CleanupStack::PushL(areaCriteria);

        if (err != KErrNone)

            {

            CleanupStack::PopAndDestroy(areaCriteria);

            continue;

            }

        // 5 and 6 is using WaitForRequest

        for (TInt i=0; i<4; i++)

            {

            switch (i)

                {

                //**** sync

                case 0:

                    ExecuteAndDeleteLD(iLmMultiSearch->StartLandmarkSearchL(

                        *areaCriteria, 

                        sortPref, 

                        aSearchResults[j]->Redefined()));

                    break;

                case 1:

                    sortPref.SetSortByLandmarkAttribute(CPosLandmark::ELandmarkName, TPosLmSortPref::EDescending);

                    ExecuteAndDeleteLD(iLmMultiSearch->StartLandmarkSearchL(

                        *areaCriteria, 

                        sortPref, 

                        aSearchResults[j]->Redefined()));

                    break;

                case 2:

                //**** async

                    RunAsyncOperationLD(iLmMultiSearch->StartLandmarkSearchL(

                        *areaCriteria, 

                        sortPref, 

                        aSearchResults[j]->Redefined()));

                    break;

                case 3:

                    sortPref.SetSortByLandmarkAttribute(CPosLandmark::ELandmarkName, TPosLmSortPref::EAscending);

                    RunAsyncOperationLD(iLmMultiSearch->StartLandmarkSearchL(

                        *areaCriteria, 

                        sortPref, 

                        aSearchResults[j]->Redefined()));

                    break;

                //**** asych with User::WaitForRequest()

                case 4:

                    {

                    CPosLmOperation* op = iLmMultiSearch->StartLandmarkSearchL(

                        *areaCriteria, 

                        sortPref, 

                        aSearchResults[j]->Redefined());

                    CleanupStack::PushL(op);

                    RunAsyncOperationByWaitForReqL(op);

                    CleanupStack::PopAndDestroy(op);

                    }

                    break;

                case 5:

                    {

                    sortPref.SetSortByLandmarkAttribute(CPosLandmark::ELandmarkName, TPosLmSortPref::EAscending);

                    CPosLmOperation* op = iLmMultiSearch->StartLandmarkSearchL(

                        *areaCriteria, 

                        sortPref, 

                        aSearchResults[j]->Redefined());

                    CleanupStack::PushL(op);

                    RunAsyncOperationByWaitForReqL(op);

                    CleanupStack::PopAndDestroy(op);

                    }

                    break;

                }

            }

        // Check database array

        CheckDatabasesL(iDbArray);

        // Check for errors        

        AssertTrueSecL(iLmMultiSearch->NumOfSearchErrors() == 0, 

            _L("Error(s) found during multi search."));

        // Check total number of matches       

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

            iLmMultiSearch->TotalNumOfMatches())

            {

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

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

            TBuf<100> info;

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

            iLog->Log(info);

            info.Format(KReturned, iLmMultiSearch->TotalNumOfMatches());

            iLog->Log(info);

            iLog->Log(KNumOfMatchesErr);

            User::Leave(-1);

            }

        RArray<TPosLmItemId>* searchResults = &aSearchResults[j]->SearchResult();        

        for (TInt n=0; n<iLmMultiSearch->NumOfDatabasesToSearch(); n++) 

            {

            RArray<TPosLmItemId> lmids;

            CleanupClosePushL(lmids);

            GetLmIdsL(n, *searchResults, lmids);            

            iDatabase = CPosLandmarkDatabase::OpenL(iLmMultiSearch->DatabaseUriPtr(n));

            if (iDatabase->IsInitializingNeeded())

           {

           ExecuteAndDeleteLD(iDatabase->InitializeL());

           }

            LandmarksSortL(lmids, sortPref);

            CPosLmItemIterator* iter = iLmMultiSearch->MatchIteratorL(n);

            // Check if there are any matches = iteration exists.

            if (iter) 

                {

                CleanupStack::PushL(iter);

                TInt lmid = 0;

                TPosLmItemId id = iter->NextL();

                while (id != KPosLmNullItemId)

                    {

                    CheckEqualsLmsL(id, lmids[lmid]);

                    id = iter->NextL();

                    ++lmid;

                    }

                CleanupStack::PopAndDestroy(iter);

                }

            else 

                {

                _LIT(KIterNull, "MatchIterator returned null for a db");

                iLog->Log(KIterNull);

                }

            delete iDatabase;

            iDatabase = NULL;

            CleanupStack::PopAndDestroy(&lmids);

            }

        CleanupStack::PopAndDestroy(areaCriteria);

        _LIT(KSearchNr, "Multi search test index #%d executed ok.");

        TBuf<100> buf;

        buf.Format(KSearchNr, j);        

        iLog->Log(buf);

        }

    }

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

// CPosTp120::OnTheFlySearchL

//

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

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

//

void CPosTp120::OnTheFlySearchL()

    {

    const TInt KTestIndex = 4;

   _LIT(KTestNr, "Multi search test, using test index %d.");

    TBuf<100> buf;

    buf.Format(KTestNr, KTestIndex);

    iLog->Log(buf);