/*

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

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLandmarkSearch.h>

#include <EPos_CPosLmTextCriteria.h>

#include <EPos_CPosLMItemIterator.h>

#include <EPos_CPosLmDisplayData.h>

#include <EPos_CPosLmDisplayItem.h>

#include <EPos_TPosLMSortPref.h>

#include "FT_CSearchResult.h"

// CONSTANTS

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

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

// CPosTp23::CloseTest

//

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

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

//

void CPosTp23::CloseTest()

    {

    //CHECK TR   Delete of landmarks search - ESLI-5WNG9N

    delete iDatabase;

    iDatabase = NULL;

    delete iLandmarkSearch;

    iLandmarkSearch = NULL;

    iSearchResults.ResetAndDestroy();

    }

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

// CPosTp23::StartL

//

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

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

//

void CPosTp23::StartL()

    {

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

    iDatabase = UseGeneratedDbFileL();

    if (iDatabase->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(iDatabase->InitializeL());

       }

    iLandmarkSearch = CPosLandmarkSearch::NewL(*iDatabase);

    TestInvalidPositionFieldsL();

    // Check iterator before search has started (in multidb search all iterators are empty thus NOT NULL)

    CPosLmItemIterator* iter = iLandmarkSearch->MatchIteratorL();

    if (iter)

    	{

    	CleanupStack::PushL(iter);

    	AssertTrueSecL(iter->NumOfItemsL() == 0, _L("Iterator should be empty"));

    	CleanupStack::PopAndDestroy(iter);

    	}

    else

    	{

    	iLog->Log(_L("Iterator should NOT be NULL"));

    	User::Leave(-1);	

    	}

    TUint attr = CPosLandmark::ELandmarkName | CPosLandmark::EDescription;

    CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

    textCriteria->SetAttributesToSearch(attr);

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

    TRAPD(err, iLandmarkSearch->StartLandmarkSearchL(*textCriteria));

    AssertTrueSecL(err == KErrArgument, KEmptyTextCriteriaErr);

    CleanupStack::PopAndDestroy(textCriteria);

    AppendSearchResultsL();

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

    SearchL(iSearchResults, ESynchronous);

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

    SearchL(SearchResults(), EAsynchronous);

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

    SearchL(SearchResults(), EWaitForRequest);

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

    SearchWithSortOrderL(iSearchResults);   

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

    SearchAndCancelL();

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

    SearchAndCancelL(ETrue);

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

    SearchAndDeleteL(iSearchResults);

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

    SearchAndRenameL(iSearchResults);

    iLog->Log(_L("Test max length for SetTextL"));

    TestMaxLengthL();

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

    }

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

// CPosTp23::SearchL

//

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

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

//

void CPosTp23::SearchL(

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

    // Set DisplayData

	CPosLmDisplayData* displayData = CPosLmDisplayData::NewL();

	CleanupStack::PushL(displayData);

	iLandmarkSearch->SetDisplayData(*displayData);

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

        {

        CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

        textCriteria->SetTextL(aSearchResults[i]->TextCriteria());

        textCriteria->SetAttributesToSearch(aSearchResults[i]->Attributes());

        textCriteria->SetPositionFieldsToSearchL(aSearchResults[i]->PositionFields()); 

        CPosLmOperation* operation = 

            iLandmarkSearch->StartLandmarkSearchL(*textCriteria, 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;

            }

        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("Search criteria: "));

            iLog->Log(textCriteria->Text());

            iLog->Log(KNumOfMatchesErr);

            User::Leave(-1);

            }

		//Check displaydata        

        AssertTrueSecL(iter->NumOfItemsL() == displayData->Count(), _L("Wrong number of DisplayData matches"));

       	TInt itemId = displayData->NewItemIndex();

        while (itemId != KPosLmNoNewItems)

            {

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

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

            	{

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

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

            	User::Leave(-1);

            	}

            if (item.DatabaseIndex() != 0)

            	{

            	// When single search, index should always be 0

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

            	User::Leave(-1);

            	}

				TInt lmId = item.Landmark().LandmarkId();

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

            itemId = displayData->NewItemIndex();

           	}

        TPosLmItemId id = iter->NextL();

        while (id != KPosLmNullItemId)

            {

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

            id = iter->NextL();

            }

        CleanupStack::PopAndDestroy(iter);

        CleanupStack::PopAndDestroy(textCriteria);

        }

        iLandmarkSearch->UnsetDisplayData();

        CleanupStack::PopAndDestroy(displayData);

    }

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

// CPosTp23::VerifySortOrderL

//

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

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

//

void CPosTp23::VerifySortOrderL()

    {

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

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

    _LIT(KNumOfMatchesErr2, "No. of matches in DisplayData is incorrect");

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

    _LIT(KNameMatchError, "The landmark names does not match");

    _LIT(KNameMatchError2, "The landmark name in DisplayData does not match");

    // Just in case, add some landmarks

    CPosLandmark* landmark = CPosLandmark::NewLC();

    landmark->SetLandmarkNameL(_L("CategoryA")); 

    TPosLmItemId id1 = iDatabase->AddLandmarkL(*landmark);

    CleanupStack::PopAndDestroy(landmark);

    landmark = CPosLandmark::NewLC();

    landmark->SetLandmarkNameL(_L("Categorya")); 

    TPosLmItemId id2 = iDatabase->AddLandmarkL(*landmark);

    CleanupStack::PopAndDestroy(landmark);

    landmark = CPosLandmark::NewLC();

    landmark->SetLandmarkNameL(_L("AA")); 

    TPosLmItemId id3 = iDatabase->AddLandmarkL(*landmark);

    CleanupStack::PopAndDestroy(landmark);

    landmark = CPosLandmark::NewLC();

    landmark->SetLandmarkNameL(_L("aa")); 

    TPosLmItemId id4 = iDatabase->AddLandmarkL(*landmark);

    CleanupStack::PopAndDestroy(landmark);

    TPosLmSortPref sortDesc(CPosLandmark::ELandmarkName, TPosLmSortPref::EDescending);

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

    CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

    // Search pattern "*" should match all existing landmarks -> it is possible to compare

    // sort order of CPosLandmarkSearch::MatchIteratorL with CPosLandmarkDatabase::LandmarkIteratorL

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

    // Set DisplayData

    CPosLmDisplayData* displayData = CPosLmDisplayData::NewL();

	CleanupStack::PushL(displayData);

    iLandmarkSearch->SetDisplayData(*displayData);

    CPosLmItemIterator* lmDbIter = NULL;

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

        {

        if(i==0)

            {

            // Sorted ascending

            lmDbIter = iDatabase->LandmarkIteratorL(sortAsc);

            CleanupStack::PushL(lmDbIter);

            ExecuteAndDeleteLD(iLandmarkSearch->StartLandmarkSearchL(

                *textCriteria, sortAsc, EFalse));

            }

        else if (i==1)

            {

            // Sorted descending

            lmDbIter = iDatabase->LandmarkIteratorL(sortDesc);

            CleanupStack::PushL(lmDbIter);

            ExecuteAndDeleteLD(iLandmarkSearch->StartLandmarkSearchL(

                *textCriteria, sortDesc, EFalse));

            }

        else if (i==2)

            {

            //**** Async search, sorted ascending

            lmDbIter = iDatabase->LandmarkIteratorL(sortAsc);

            CleanupStack::PushL(lmDbIter);

            RunAsyncOperationLD(iLandmarkSearch->StartLandmarkSearchL(

                *textCriteria, sortAsc, EFalse));

            }

        else if (i==3)

            {

            //**** Async search, sorted descending

            lmDbIter = iDatabase->LandmarkIteratorL(sortDesc);

            CleanupStack::PushL(lmDbIter);

            RunAsyncOperationLD(iLandmarkSearch->StartLandmarkSearchL(

                *textCriteria, sortDesc, EFalse));

            }

        else if (i==4)

            {

            //**** Async search with User::WaitForRequest(), sorted ascending

            lmDbIter = iDatabase->LandmarkIteratorL(sortAsc);

            CleanupStack::PushL(lmDbIter);

            CPosLmOperation* op = iLandmarkSearch->StartLandmarkSearchL(

                *textCriteria, sortAsc, EFalse);

            CleanupStack::PushL(op);

            RunAsyncOperationByWaitForReqL(op);

            CleanupStack::PopAndDestroy(op);

            }

        else if (i==5)

            {

            //**** Async search with User::WaitForRequest(), sorted descending

            lmDbIter = iDatabase->LandmarkIteratorL(sortDesc);

            CleanupStack::PushL(lmDbIter);

            CPosLmOperation* op = iLandmarkSearch->StartLandmarkSearchL(

                *textCriteria, sortDesc, EFalse);

            CleanupStack::PushL(op);

            RunAsyncOperationByWaitForReqL(op);

            CleanupStack::PopAndDestroy(op);

            }

        CPosLmItemIterator* iter = iLandmarkSearch->MatchIteratorL();

        CleanupStack::PushL(iter);

        AssertTrueSecL(iter->NumOfItemsL() == lmDbIter->NumOfItemsL(), KNumOfMatchesErr);

        // Check correct displayData

        AssertTrueSecL(iter->NumOfItemsL() == displayData->Count(), KNumOfMatchesErr2);

		TInt itemId = displayData->NewItemIndex();

        TPosLmItemId id = iter->NextL();

        TPosLmItemId lmDbId = lmDbIter->NextL();

        // check that the two iterators are sorted identically

        while (id != KPosLmNullItemId)

            {

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

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

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

			TPtrC lmName;

			item.Landmark().GetLandmarkName(lmName);

            TPtrC sourceName, targetName;

            source->GetLandmarkName(sourceName);

            target->GetLandmarkName(targetName);

            // For debugging purposes

            TBuf<150> buf;

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

            buf.Append(sourceName);

            buf.Append(_L("<->"));

            buf.Append(targetName);

            buf.Append(_L("<->"));

            buf.Append(lmName);

            //iLog->Log(buf);

            if (id != lmDbId) iLog->Log(_L("ids are not identical, therefore check name"));

            // Should always be the same

            AssertTrueSecL(sourceName.Compare(targetName) == KErrNone, KNameMatchError);

            AssertTrueSecL(sourceName.Compare(lmName) == KErrNone, KNameMatchError2);

            CleanupStack::PopAndDestroy(target);

            CleanupStack::PopAndDestroy(source);

            id = iter->NextL();

            lmDbId = lmDbIter->NextL();

            itemId = displayData->NewItemIndex();

            }

        CleanupStack::PopAndDestroy(iter);

        CleanupStack::PopAndDestroy(lmDbIter);

        }

    // Unset displayData before deleting

    iLandmarkSearch->UnsetDisplayData();

	CleanupStack::PopAndDestroy(displayData);

    CleanupStack::PopAndDestroy(textCriteria);

    //Remove landmarks created in this part

    iDatabase->RemoveLandmarkL(id1);

    iDatabase->RemoveLandmarkL(id2);

    iDatabase->RemoveLandmarkL(id3);

    iDatabase->RemoveLandmarkL(id4);

    iLog->Log(_L("VerifySortOrderL Done"));

    }

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

// CPosTp23::SearchWithSortOrderL

//

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

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

//

void CPosTp23::SearchWithSortOrderL(const RPointerArray<CSearchResult>& aSearchResults)

    {

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

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

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

    CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

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

        {   

        textCriteria->SetTextL(aSearchResults[j]->TextCriteria());

        textCriteria->SetAttributesToSearch(aSearchResults[j]->Attributes());

        textCriteria->SetPositionFieldsToSearchL(aSearchResults[j]->PositionFields()); 

        //iLog->Log(aSearchResults[j]->TextCriteria());

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

            {

            switch (i)

                {

                //**** sync

                case 0:

                    ExecuteAndDeleteLD(iLandmarkSearch->StartLandmarkSearchL(

                        *textCriteria, 

                        sortPref, 

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

                    break;

                case 1:

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

                    ExecuteAndDeleteLD(iLandmarkSearch->StartLandmarkSearchL(

                        *textCriteria, 

                        sortPref, 

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

                    break;

                case 2:

                //**** async

                    RunAsyncOperationLD(iLandmarkSearch->StartLandmarkSearchL(

                        *textCriteria, 

                        sortPref, 

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

                    break;

                case 3:

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

                    RunAsyncOperationLD(iLandmarkSearch->StartLandmarkSearchL(

                        *textCriteria, 

                        sortPref, 

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

                    break;

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

                case 4:

                    {

                    CPosLmOperation* op = iLandmarkSearch->StartLandmarkSearchL(

                        *textCriteria, 

                        sortPref, 

                        aSearchResults[j]->Redefined());

                    CleanupStack::PushL(op);

                    RunAsyncOperationByWaitForReqL(op);

                    CleanupStack::PopAndDestroy(op);

                    }

                    break;

                case 5:

                    {

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

                    CPosLmOperation* op = iLandmarkSearch->StartLandmarkSearchL(

                        *textCriteria, 

                        sortPref, 

                        aSearchResults[j]->Redefined());

                    CleanupStack::PushL(op);

                    RunAsyncOperationByWaitForReqL(op);

                    CleanupStack::PopAndDestroy(op);

                    }

                    break;

                }

        CPosLmItemIterator* iter = iLandmarkSearch->MatchIteratorL();

        CleanupStack::PushL(iter);

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

        if ((TUint)searchResults->Count() != iLandmarkSearch->NumOfMatches())

            {

            TBuf<50> buf;

            buf.Append(_L("KNumOfMatchesError when searching for "));

            buf.Append(aSearchResults[j]->TextCriteria());

            iLog->Log(buf);

            iLog->Log(KNumOfMatchesErr);

            User::Leave(-1);

            }

        LandmarksSortL(*searchResults, sortPref);

        TInt ii=0;

        TPosLmItemId id = iter->NextL();

        while (id != KPosLmNullItemId)

            {  

            if (id != (*searchResults)[ii])

                {

                //Check if same name then don't Leave

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

                CPosLandmark* target = iDatabase->ReadLandmarkLC((*searchResults)[ii]);

                TPtrC sourceName, targetName;

                source->GetLandmarkName(sourceName);

                target->GetLandmarkName(targetName);

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

                CleanupStack::PopAndDestroy(2, source);