/*

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

#include <EPos_CPosLandmarkDatabase.h> 

#include <EPos_CPosLmCompositeCriteria.h>

#include <EPos_CPosLmCategoryCriteria.h>

#include <EPos_CPosLmCatNameCriteria.h>

#include <EPos_CPosLmNearestCriteria.h>

#include <EPos_CPosLmAreaCriteria.h>

#include <EPos_CPosLmTextCriteria.h>

#include <EPos_CPosLmIdListCriteria.h>

#include "FT_LandmarkConstants.h" 

#include "FT_CCompositeSearchResult.h"

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

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

// CPosTp38::CloseTest

//

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

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

//

void CPosTp38::CloseTest()

    {

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

    delete iDatabase;

    iDatabase=NULL;

    delete iLandmarkSearch;

    iLandmarkSearch = NULL;

    }

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

// CPosTp38::StartL

//

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

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

//

void CPosTp38::StartL()

    {

    TTime startTime;

    TTime stopTime;

    startTime.UniversalTime();

    iDatabase = UseCompositeLandmarksDbFileL();

    if (iDatabase->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(iDatabase->InitializeL());

       }

    StartLandmarksCompositeTestL();

    TestCompositeInCompositeL();

    TestSeveralTextArgumentsL();

    TestSeveralTextArgumentsWithORL();

	TestSortOrderWithORL();

    TestWithSortOrderLandmarksL();

    TestWithSortOrderNearestL();

    TestTwoLmCategoryCriteriaL();

    TestAddAndRemoveL();

    TInt err = KErrNone;

    TRAP(err, TestWithNoPreviousResultL(0));

    if (err != KErrArgument) 

    {

    	iLog->Log(_L("Searching with no previous result should cause StartLandmarkL to leave with KErrArgument"));

    	User::Leave(err);

    }

    delete iLandmarkSearch;

    iLandmarkSearch = NULL;

    SearchAndCancelL(EFalse);

    SearchAndCancelL(ETrue);

    // Since category and composite is no longer allowed, no need to test this

    //TestWithSortOrderCategoriesL();

    //TestCategoryCompositeSearchL();

    stopTime.UniversalTime();

    TTimeIntervalMicroSeconds executionTime = 

        stopTime.MicroSecondsFrom(startTime);

    TInt resse = executionTime.Int64()/1000000;

    TBuf<100> buf;

    buf.Format(_L("TP38 took %d seconds"), resse);

    iLog->Log(buf);

	}

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

// CPosTp38::TestWithSortOrderCategoriesL

//

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

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

//

void CPosTp38::TestWithSortOrderCategoriesL()

	{

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

	iLandmarkSearch = CPosLandmarkSearch::NewL(*iDatabase);

    CPosLmCompositeCriteria* composite = CPosLmCompositeCriteria::NewLC(CPosLmCompositeCriteria::ECompositionAND);

    CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();

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

    TInt err = composite->AddArgument(nameCriteria);

    if (err != KErrNone) 

    {

    	iLog->Log(_L("Error from AddArgument(nameCriteria)"));

    	User::Leave(err);

    }

    CleanupStack::Pop(nameCriteria);

    CPosLmCategoryManager::TCategorySortPref sortPref;

    sortPref = CPosLmCategoryManager::ECategorySortOrderNameAscending;

	TInt i=0;

	TInt j=0;    

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

    	{

	  	if (j==0) 

	    	{

	    	iLog->Log(_L("Sorting Ascending"));

	    	sortPref = CPosLmCategoryManager::ECategorySortOrderNameAscending;

	    	}

	    else 

	    	{

	    	iLog->Log(_L("Sorting Descending"));

	    	sortPref = CPosLmCategoryManager::ECategorySortOrderNameDescending;

	    	}

    	iLog->Log(_L("iLandmarkSearch->StartCategorySearchL"));

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

    	ExecuteAndDeleteLD(iOperation);

    	CPosLmItemIterator* iter = iLandmarkSearch->MatchIteratorL();

    	CleanupStack::PushL(iter);

        // Create a sorted list out of the search result

        RArray<TPosLmItemId> searchResults;

        CleanupClosePushL(searchResults);

        for (i=1;i<27;i++) {searchResults.Append(i);}

        CategoriesSortL(searchResults, sortPref);

        TPosLmItemId id = iter->NextL();

        TInt counter=0;

        while (id != KPosLmNullItemId)

            {

            // Check that sort order is correct

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

            id = iter->NextL();

            counter++;

            }

        CleanupStack::PopAndDestroy(&searchResults);

        CleanupStack::PopAndDestroy(iter);

		}          

    CleanupStack::PopAndDestroy(composite);

    delete iLandmarkSearch;

    iLandmarkSearch = NULL;

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

	}

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

// CPosTp38::TestWithSortOrderNearestL

//

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

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

//

void CPosTp38::TestWithSortOrderNearestL()

	{

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

	iLandmarkSearch = CPosLandmarkSearch::NewL(*iDatabase);

    CPosLmCompositeCriteria* composite = CPosLmCompositeCriteria::NewLC(CPosLmCompositeCriteria::ECompositionAND);

    // First create a textcriteria

    CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();   

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

    TInt err = composite->AddArgument(textCriteria);

    if (err != KErrNone)

    {

    iLog->Log(_L("Error when adding argument1"));

    User::Leave(err);

    }

    CleanupStack::Pop(textCriteria);

    // Then create a nearest criteria same coordinate as landmark itemid=3 God

    TCoordinate coord(45, 45);

    CPosLmNearestCriteria* nearestCriteria = CPosLmNearestCriteria::NewLC(coord, EFalse);

    err = composite->AddArgument(nearestCriteria);

    if (err != KErrNone)

    {

    	iLog->Log(_L("Error when adding argument2"));

    	User::Leave(err);

    }

    CleanupStack::Pop(nearestCriteria);

    // Then add an IdList

    CPosLmIdListCriteria* idList = CPosLmIdListCriteria::NewLC();

    RArray<TPosLmItemId> list;

    CleanupClosePushL(list);

    // Use these four landmarks

    list.Append(6);

    list.Append(7);

    list.Append(3);

    list.Append(10);

    idList->SetLandmarkIdsL(list);

    err = composite->AddArgument(idList);

    if (err != KErrNone) 

    {

    	iLog->Log(_L("Error when adding argument3"));

    	User::Leave(err);

    }

    CleanupStack::PopAndDestroy(&list);

    CleanupStack::Pop(idList);

    // Create search result

   	RArray<TPosLmItemId> searchResults;

	CleanupClosePushL(searchResults);

	// This is the correct distance sorted array	

	searchResults.Append(3);

	searchResults.Append(7);

	searchResults.Append(6);

	searchResults.Append(10);

    iOperation = iLandmarkSearch->StartLandmarkSearchL(*composite, EFalse);

    ExecuteAndDeleteLD(iOperation);

    CPosLmItemIterator* iter = iLandmarkSearch->MatchIteratorL();

    CleanupStack::PushL(iter);

    TInt ii=0;

    TPosLmItemId id = iter->NextL();

    while (id != KPosLmNullItemId)

    	{

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

        	{

            // Check if same name then don't leave, there are three landmarks with same name, Mölndal

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

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

            TPtrC sourceName, targetName;

            source->GetLandmarkName(sourceName);

            TInt sourceId = source->LandmarkId();

            target->GetLandmarkName(targetName);

            TInt targetId = target->LandmarkId();

            AssertTrueSecL(sourceName.CompareC(targetName) == KErrNone,_L("Wrong sortorder"), id);

            CleanupStack::PopAndDestroy(2, source);

            }

        id = iter->NextL();

        ++ii;

		}

	CleanupStack::PopAndDestroy(iter);	      	

    CleanupStack::PopAndDestroy(&searchResults);

    CleanupStack::PopAndDestroy(composite);

    delete iLandmarkSearch;

    iLandmarkSearch = NULL;

	}

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

// CPosTp38::TestTwoLmCategoryCriteriaL

//

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

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

//

void CPosTp38::TestTwoLmCategoryCriteriaL()

	{

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

	iLandmarkSearch = CPosLandmarkSearch::NewL(*iDatabase);

    CPosLmCompositeCriteria* composite = CPosLmCompositeCriteria::NewLC(CPosLmCompositeCriteria::ECompositionAND);

    // First create a textcriteria

    CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();   

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

    TInt err = composite->AddArgument(textCriteria);

    if (err != KErrNone)

    {

    	iLog->Log(_L("Error when adding argument1"));

    	User::Leave(err);

     }

    CleanupStack::Pop(textCriteria);

	// Create a cat search criteria

	CPosLmCategoryCriteria* catSearchCriteria = CPosLmCategoryCriteria::NewLC();

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

    catSearchCriteria->SetCategoryItemId(14);

    composite->AddArgument(catSearchCriteria);

    CleanupStack::Pop(catSearchCriteria);

   	// Create another cat search criteria

	CPosLmCategoryCriteria* catSearchCriteria2 = CPosLmCategoryCriteria::NewLC();

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

    catSearchCriteria2->SetCategoryNameL(_L("McDonalds"));

    composite->AddArgument(catSearchCriteria2);

    CleanupStack::Pop(catSearchCriteria2);

    // Should find id7=Billigt and id27=LOG9

    iOperation = iLandmarkSearch->StartLandmarkSearchL(*composite, EFalse);

    ExecuteAndDeleteLD(iOperation);

	// Create search result

   	RArray<TPosLmItemId> searchResults;

	CleanupClosePushL(searchResults);

    CPosLmItemIterator* iter = iLandmarkSearch->MatchIteratorL();

    CleanupStack::PushL(iter);

    // This is the correct result list    

	searchResults.Append(27);

	searchResults.Append(7);

	TInt size = iter->NumOfItemsL();

	if (size != searchResults.Count()) 

	{

		iLog->Log(_L("Wrong result returned from iterator"));

    	User::Leave(-1);

	}

	TInt found = 0;

	TInt ii=0;

    TPosLmItemId id = iter->NextL();

    while (id != KPosLmNullItemId)

    	{

    	for (ii=0;ii<size;ii++)

    		{

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

        		{

	            found++;

	            }

	       	}

        	id = iter->NextL();

		}

		if (found != searchResults.Count()) 

		{

			iLog->Log(_L("Wrong result returned from iterator1"));

    		User::Leave(-1);

		}

	// Now refine search with another CPosLmCategoryCriteria

	// Create another cat search criteria 

	CPosLmCategoryCriteria* catSearchCriteria3 = CPosLmCategoryCriteria::NewLC();

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

    catSearchCriteria3->SetCategoryItemId(11);

    composite->AddArgument(catSearchCriteria3);

    CleanupStack::Pop(catSearchCriteria3);

    // Should find id27=LOG9

	iOperation = iLandmarkSearch->StartLandmarkSearchL(*composite, ETrue);

    ExecuteAndDeleteLD(iOperation);

    iter->Reset();

    CleanupStack::PopAndDestroy(iter);

    iter = iLandmarkSearch->MatchIteratorL();

    CleanupStack::PushL(iter);

    searchResults.Reset();

    searchResults.Append(27);

    found=0;

    size = iter->NumOfItemsL();

    id = iter->NextL();

	if (size != searchResults.Count()) 

	{

			iLog->Log(_L("Wrong result returned from iterator"));

    		User::Leave(-1);

	}

        while (id != KPosLmNullItemId)

    	{

    	for (ii=0;ii<size;ii++)

    		{

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

        		{

	            found++;

	            }

	       	}

        	id = iter->NextL();

		}

	if (found != searchResults.Count())

	{

	iLog->Log(_L("Wrong items returned from iterator2"));

    User::Leave(-1);

    }

	CleanupStack::PopAndDestroy(iter);

	CleanupStack::PopAndDestroy(&searchResults);    

    CleanupStack::PopAndDestroy(composite);

    delete iLandmarkSearch;

    iLandmarkSearch = NULL;

	}

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

// CPosTp38::TestWithSortOrderLandmarksL

//

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

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

//

void CPosTp38::TestWithSortOrderLandmarksL()

	{

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

    iLandmarkSearch = CPosLandmarkSearch::NewL(*iDatabase);

    CPosLmCompositeCriteria* composite = CPosLmCompositeCriteria::NewLC(CPosLmCompositeCriteria::ECompositionAND);

	TInt i=0;

	TInt j=0;

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

    // First create a textcriteria

    CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();   

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

    TInt err = composite->AddArgument(textCriteria);

    if (err != KErrNone)

    {

    	iLog->Log(_L("Error when adding argument1"));

    	User::Leave(err);

    }

    CleanupStack::Pop(textCriteria);

    // Then create a nearest criteria

    TCoordinate coord(12.123, -20,123);

    CPosLmNearestCriteria* nearestCriteria = CPosLmNearestCriteria::NewLC(coord, EFalse);

    err = composite->AddArgument(nearestCriteria);

    if (err != KErrNone) 

    {

    	iLog->Log(_L("Error when adding argument2"));

    	User::Leave(err);

    }

    CleanupStack::Pop(nearestCriteria);

    // Then add an IdList

    CPosLmIdListCriteria* idList = CPosLmIdListCriteria::NewLC();

    RArray<TPosLmItemId> list;

    CleanupClosePushL(list);

    for (i=1;i<106;i++) {list.Append(i);}

    idList->SetLandmarkIdsL(list);

    err = composite->AddArgument(idList);

    if (err != KErrNone) 

    {

    	iLog->Log(_L("Error when adding argument3"));

    	User::Leave(err);

    }

    CleanupStack::PopAndDestroy(&list);

    CleanupStack::Pop(idList);

    // Create search result of all landmark ids: 1-105

   	RArray<TPosLmItemId> searchResults;

	CleanupClosePushL(searchResults);

	for (i=1;i<106;i++) {searchResults.Append(i);}

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

	    {

	    if (j==0) 

	    	{

	    	iLog->Log(_L("Sorting Ascending"));

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

	    	}

	    else 

	    	{

	    	iLog->Log(_L("Sorting Descending"));

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

	    	}

	    iOperation = iLandmarkSearch->StartLandmarkSearchL(*composite, sortPref, EFalse);

	    ExecuteAndDeleteLD(iOperation);

	    CPosLmItemIterator* iter = iLandmarkSearch->MatchIteratorL();

	    CleanupStack::PushL(iter);

	    TInt size = iter->NumOfItemsL();

	  	LandmarksSortL(searchResults, sortPref);

	    TInt ii=0;

	    TPosLmItemId id = iter->NextL();