/*

* 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_CPosTp131.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"

#include <LbsPosition.h>

#include "FT_LandmarkConstants.h"

// CONSTANTS

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

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

// CPosTp131::CloseTest

//

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

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

//

void CPosTp131::CloseTest()

    {

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

    iSearchResults.ResetAndDestroy();

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

    delete iDatabase;

    iDatabase = NULL;

    iLandmarkSearch->UnsetDisplayData();

    delete iDisplayData;

    iDisplayData = NULL;

    delete iLandmarkSearch;

    iLandmarkSearch = NULL;

    }

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

// CPosTp131::StartL

//

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

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

//

void CPosTp131::StartL()

    {

    iErrorsFound = KErrNone;

    // copy test db to the private path

    _LIT(KTestPath, "c:\\system\\test\\testdata\\");

    CFileMan* fileMan = CFileMan::NewL(iFileSession);

    CleanupStack::PushL(fileMan);

    TBuf<150> srcPath;

    srcPath.Append(KTestPath);

    srcPath.Append(KTp131TestDb);

    TInt er = fileMan->Copy(srcPath, KLmTp131DefaultDbPath,

            CFileMan::EOverWrite);

    if (er != KErrNone)

        iLog->Log(_L("Error when copying file"));

    CleanupStack::PopAndDestroy(fileMan);

    CPosLmDatabaseManager* manager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(manager);

    // This db must exist

    manager->SetDefaultDatabaseUriL(KTp131TestDb);

    CleanupStack::PopAndDestroy(manager);

    iDatabase = CPosLandmarkDatabase::OpenL(KTp131TestDb);

    if (iDatabase->IsInitializingNeeded())

        {

        TRAPD( err, ExecuteAndDeleteLD( iDatabase->InitializeL() ) );

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

        }

    iLandmarkSearch = CPosLandmarkSearch::NewL(*iDatabase);

    AppendSearchResultsL();

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

    SearchWithSortOrderL(iSearchResults);

    // Test Partial landmarks

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

	SearchPartialLandmarksL(iSearchResults);

    iLog->Log(_L("Testing reset of DisplayData"));

    CheckResetL(iSearchResults);

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

    CancelTestL(iSearchResults);

    // Test DisplayDataItem, create Landmark type

    TUint dbIndex = 0;

    CPosLandmark* lm = CPosLandmark::NewLC();

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

    CPosLmDisplayItem* item = CPosLmDisplayItem::NewL(lm, dbIndex);

    CleanupStack::PushL(item);

    CPosLmDisplayItem::TDisplayItemType type = item->DisplayItemType();

    AssertTrueSecL(type == CPosLmDisplayItem::ELandmarkItem, _L("Wrong TDisplayItemType"));

    CleanupStack::PopAndDestroy(item);

    CleanupStack::Pop(lm); // lm deleted when deleting displaydata

    // Test DisplayDataItem, create Category type

    CPosLandmarkCategory* category = CPosLandmarkCategory::NewLC();

    category->SetCategoryNameL(_L("Tp131CategoryName"));

    item = CPosLmDisplayItem::NewL(category, dbIndex);

    CleanupStack::PushL(item);

    type = item->DisplayItemType();

    AssertTrueSecL(type == CPosLmDisplayItem::ECategoryItem, _L("Wrong TDisplayItemType"));

    CleanupStack::PopAndDestroy(item);

    CleanupStack::Pop(category); // category deleted when deleting displaydata

    if (iErrorsFound != KErrNone) 

    	{

    	iLog->Log(_L("Errors were found in TP131"));

    	User::Leave(-1);

    	}

    }

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

// CPosTp131::ChechPartialLandmarkL

//

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

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

//

void CPosTp131::CheckPartialLandmarkL(const CPosLandmark& aLandmark, 

                                     const CPosLandmark::TAttributes& aAttr, const RArray<TUint>& aReqFields)

    {

    _LIT(KPartialIdErr, "Incorrect Id when reading from a Partial landmark");

    _LIT(KPartialCategoryInfoErr, "Incorrect Category info when reading from a Partial landmark");

    TPosLmItemId id = aLandmark.LandmarkId();

    AssertTrueSecL(id != 0, KPartialIdErr); 

    AssertTrueSecL(aLandmark.IsPartial(), _L("Landmark is not partial"));

    TInt err;

    TPtrC name;

    err = aLandmark.GetLandmarkName(name);

    // Name is always included

    CheckPartialErrorCodeL(aAttr & CPosLandmark::ELandmarkName, err); 

    TReal32 coverageR;     

    err = aLandmark.GetCoverageRadius(coverageR);

    CheckPartialErrorCodeL(aAttr & CPosLandmark::ECoverageRadius, err);

    TPtrC desc;

    err = aLandmark.GetLandmarkDescription(desc); 

    CheckPartialErrorCodeL(aAttr & CPosLandmark::EDescription, err);

    TPtrC iconName;

    TInt iconIndex;

    TInt iconMaskIndex;

    err = aLandmark.GetIcon(iconName, iconIndex, iconMaskIndex); 

    CheckPartialErrorCodeL(aAttr & CPosLandmark::EIcon, err);

    RArray<TPosLmItemId> categories;

    CleanupClosePushL(categories);

    aLandmark.GetCategoriesL(categories);

    if (aAttr & CPosLandmark::ECategoryInfo)

        {

        AssertTrueSecL(categories.Count() != 0, KPartialCategoryInfoErr);

        }

    else

        {

        AssertTrueSecL(categories.Count() == 0, KPartialCategoryInfoErr);

        }

    CleanupStack::PopAndDestroy(&categories);

    TLocality loc;

    err = aLandmark.GetPosition(loc); 

    CheckPartialErrorCodeL(aAttr & CPosLandmark::EPosition, err);

    // Check PositionFields    

    // Check fields from EPositionFieldCompassCapabilitiesBegin up to EPositionFieldMediaCapabilitiesBegin+100 

    // should be enough to also cover URL

    for (TInt i=EPositionFieldCompassCapabilitiesBegin; i<EPositionFieldMediaCapabilitiesBegin+100; i++) 

     	{

     	TBool avail = aLandmark.IsPositionFieldAvailable((TUint16)i);

     	TInt found = aReqFields.Find(i);

     	if (avail && found != KErrNotFound)

     		{

     		TPtrC value;

     		err = aLandmark.GetPositionField((TUint16)aReqFields[found], value);

     		AssertTrueSecL(err == KErrNone, _L("Could not retrieve positionfield value"), err);

     		iLog->Log(value);

     		}

     	else if (!avail && found != KErrNotFound || avail && found == KErrNotFound)

     		{

			// Fields 405 and 802 are not always set     		

     		if (i!=405 && i!=802)

     			{

		 		TBuf<100> buf;

		 		buf.Format(_L("ERROR: Mismatch in positionfields, id %d were not found"), i);

		 		iLog->Log(buf);

		 		iErrorsFound++;

		 		}

     		}

     	}

    }

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

// CPosTp131::ChechPartialErrorCodeL

//

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

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

//

void CPosTp131::CheckPartialErrorCodeL(const TBool aPartial, const TInt aErr)

    {

    _LIT(KPartialLmErr, "Incorrect error code returned when reading from a Partial landmark");

    if (aPartial)

        {

        AssertTrueSecL(aErr == KErrNone, KPartialLmErr); 

        }

    else

        {

        AssertTrueSecL(aErr == KErrNotFound, KPartialLmErr);

        }

    }

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

// CPosTp131::SearchPartialLandmarksL

//

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

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

//

void CPosTp131::SearchPartialLandmarksL(const RPointerArray<CSearchResult>& aSearchResults)

    {

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

    _LIT(KNumOfMatchesErr2, "No. of display data matches is incorrect");

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

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

    CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

    // Set DisplayData

	iDisplayData = CPosLmDisplayData::NewL();

    iLandmarkSearch->SetDisplayData(*iDisplayData);

	// Only do search for index KWhatToSearchFor in lmDbSearchResult.txt

	// index 11 is MLFW

	TInt KWhatToSearchFor = 11;

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

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

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

    RArray<TUint> reqFields;

    CleanupClosePushL(reqFields);

    iLog->Log(aSearchResults[KWhatToSearchFor]->TextCriteria());

    CPosLmPartialReadParameters* partialParam = CPosLmPartialReadParameters::NewLC();

    CPosLmPartialReadParameters* fakePartialParam = CPosLmPartialReadParameters::NewLC();

    reqFields.Append(EPositionFieldStreet);

    fakePartialParam->SetRequestedPositionFields(reqFields);

    reqFields.Reset();

	// Dont search for all search criteras 

	// takes just too long time on target (approx 1 hour for this test on target)

	// Search for all combinations from 0 - CPosLandmark::EDescription

	// Ex attr=0, attr=1, attr=2, attr=3, .....attr=63,

#ifdef __WINS__	

    TUint max = CPosLandmark::EDescription;

    max <<= 1;

    max -= 1;

#else

    TUint max = CPosLandmark::ECategoryInfo;

    max <<= 1;

    max -= 1;

#endif

    TUint attr=0;

    for (attr=0; attr<=max; attr++)

        {

        partialParam->SetRequestedAttributes(attr);

        reqFields.Reset();

        if (attr == 5)

        	{

        	// Add EPositionFieldCountry

        	iLog->Log(_L("Also cover EPositionFieldCountry"));

        	reqFields.Append(EPositionFieldCountry);

        	}

        else if (attr == 12)

        	{

        	// Add EPositionFieldCity, EPositionFieldStreet, EPositionFieldCountry

        	iLog->Log(_L("Also cover EPositionFieldCity, EPositionFieldStreet, EPositionFieldCountry"));

        	reqFields.Append(EPositionFieldCity);

        	reqFields.Append(EPositionFieldStreet);

        	reqFields.Append(EPositionFieldCountry);

        	}

        else if (attr == 32)

        	{

        	// Add EPositionFieldMediaLinksStart, EPositionFieldDistrict

        	iLog->Log(_L("Also cover EPositionFieldMediaLinksStart, EPositionFieldDistrict"));

        	reqFields.Append(EPositionFieldMediaLinksStart);

        	reqFields.Append(EPositionFieldDistrict);

        	}

		iDisplayData->UnsetPartialReadParameters();

        partialParam->SetRequestedPositionFields(reqFields);

    	iDisplayData->SetPartialReadParametersL(*partialParam);

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

            {

            switch (i)

                {

                case 0:

                	{

                	//**** async

                	//iLog->Log(_L("*****Async, EDescending"));

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

                    iAscendedSorted = EFalse;

                    iOperation = iLandmarkSearch->StartLandmarkSearchL(*textCriteria, sortPref, aSearchResults[KWhatToSearchFor]->Redefined());

                    // Test that if SetPartialReadParametersL is called after search has started it has no affect

                    iDisplayData->SetPartialReadParametersL(*fakePartialParam);

                    ExecuteLmOpL();

                    }

                    break;

                case 1:

                	{

                	partialParam->SetRequestedPositionFields(reqFields);

    				iDisplayData->SetPartialReadParametersL(*partialParam);

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

                    //iLog->Log(_L("*****Async EAscending"));

                    iAscendedSorted = ETrue;

                    iOperation = iLandmarkSearch->StartLandmarkSearchL(*textCriteria, sortPref, aSearchResults[KWhatToSearchFor]->Redefined());

                    ExecuteLmOpL();

                    }

                    break;

                }

            CPosLmItemIterator* iter = iLandmarkSearch->MatchIteratorL();

            CleanupStack::PushL(iter);

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

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

                {

                TBuf<50> buf;

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

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

                iLog->Log(buf);

               iLog->Log(KNumOfMatchesErr);

               User::Leave(-1);

                }

            // Check correct displayData

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

            LandmarksSortL(*searchResults, sortPref);

            TInt ii=0;

            TPosLmItemId id = iter->NextL();

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

                {

                CPosLmDisplayItem& item = iDisplayData->DisplayItem(i);

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

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

                TPtrC sourceName, targetName;

                item.Landmark().GetLandmarkName(sourceName);

                target->GetLandmarkName(targetName);

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

                    {

                    // If found multiple match -> "Mölndal" etc

                    //Check if same name then don't Leave

                    AssertTrueSecL(sourceName.CompareC(targetName) == 0,KSortorderErr, lmId);

                    }

                else

                    {

                    //CompareLandmarksL(item.Landmark(), *target);

                    // Add some check of partial landmarks here

                    AssertTrueSecL(sourceName.CompareC(targetName) == 0,KSortorderErr, lmId);

                    // Landmarkname is always included when sorting

                    CheckPartialLandmarkL(item.Landmark() , attr | CPosLandmark::ELandmarkName, reqFields);

                    }

                    CleanupStack::PopAndDestroy(target);

                id = iter->NextL();

                ++ii;

                }

            CleanupStack::PopAndDestroy(iter);

            iDisplayData->Reset();

            } 

        } 

    iLandmarkSearch->UnsetDisplayData();

    CleanupStack::PopAndDestroy(fakePartialParam);

    CleanupStack::PopAndDestroy(partialParam);

    CleanupStack::PopAndDestroy(&reqFields);

    CleanupStack::PopAndDestroy(textCriteria);

    delete iDisplayData;

    iDisplayData = NULL;

    }

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

// CPosTp131::SearchWithSortOrderL

//

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

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

//

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

    {

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

    _LIT(KNumOfMatchesErr2, "No. of display data matches is incorrect");

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

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

    CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

    // Set DisplayData

	iDisplayData = CPosLmDisplayData::NewL();

    iLandmarkSearch->SetDisplayData(*iDisplayData);

	CPosLmPartialReadParameters* partialParam = CPosLmPartialReadParameters::NewLC();

	RArray<TUint> reqFields;

    CleanupClosePushL(reqFields);

	// Test that UnsetPartialReadParameters works	

	reqFields.Append(EPositionFieldCountry);

	partialParam->SetRequestedPositionFields(reqFields);

    iDisplayData->SetPartialReadParametersL(*partialParam);

    CleanupStack::PopAndDestroy(&reqFields);

    CleanupStack::PopAndDestroy(partialParam);

    iDisplayData->UnsetPartialReadParameters();

	// Dont search for all search criteras (see excel file)

	// takes just too long time on target (approx 1 hour for this test on target)

	// therefore start at j=7

#ifdef __WINS__	

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

#else

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

#endif

        {   

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

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

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

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

        // Dont test sync search

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

            {

            switch (i)

                {

                //**** sync

                case 0:

                	{

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

                    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

                	//iLog->Log(_L("*****Async, EDescending"));

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

                    iAscendedSorted = EFalse;

                    //iLog->Log(_L("Start"));

                    iOperation = iLandmarkSearch->StartLandmarkSearchL(*textCriteria, sortPref, aSearchResults[j]->Redefined());

                    ExecuteLmOpL();

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

                    }

                    break;

                case 3:

                	{

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

                    //iLog->Log(_L("*****Async EAscending"));

                    iAscendedSorted = ETrue;

                    iOperation = iLandmarkSearch->StartLandmarkSearchL(*textCriteria, sortPref, aSearchResults[j]->Redefined());

                    ExecuteLmOpL();

                    }

                    break;

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

                case 4: