/*

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

#include "FT_LandmarkConstants.h"

#include <EPos_CPosLmDisplayData.h>

#include <EPos_CPosLmDisplayItem.h>

#include <e32math.h>

// CONSTANTS

const TInt KMaxFieldLength = 80;

const TInt KDistanceFieldLength = 24;

const TInt KMaxNearestLineLength = 1024;

//const TInt KNrOfDatabases = 5;

_LIT(KLMDB1, "NEARESTLMDB_1.LDB");

_LIT(KLMDB2, "NEARESTLMDB_2.LDB");

_LIT(KLMDB3, "NEARESTLMDB_3.LDB");

_LIT(KLMDB4, "NEARESTLMDB_4.LDB");

_LIT(KLMDB5, "NEARESTLMDB_5.LDB");

_LIT(KNEARESTLMDB, "eposlmnearestsearch.ldb");

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

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

// CPosTp122::CloseTest

//

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

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

//

void CPosTp122::CloseTest()

    {

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

    delete iDatabases;

    if (iMultiDbSearch) iMultiDbSearch->UnsetDisplayData();

    delete iDisplayData;

    iDisplayData = NULL;

    delete iMultiDbSearch;

    iNearestSearchResults.ResetAndDestroy();

    TRAPD(err, RemoveAllLmDatabasesL());

    if (err != KErrNone) iLog->Log(_L("Error when RemoveAllLmDatabasesL"));

    }

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

// CPosTp122::InitTestL

//

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

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

//

void CPosTp122::InitTestL()

    {

    CLandmarkTestProcedureBase::InitTestL();

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

    RemoveAllLmDatabasesL();

    // PrepareDatabases

    PrepareDatabasesL();

	SetupLimits();

    iNrOfDatabases = 5;

    CPosLmDatabaseManager* dbManager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

    iDatabases = dbManager->ListDatabasesLC();

    CleanupStack::Pop(iDatabases);

    iDatabases->Sort(); // Not really necessary...

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

    iLog->Log( _L("List sorted"));

    iMultiDbSearch = CPosLmMultiDbSearch::NewL(*iDatabases);

    CleanupStack::PopAndDestroy(dbManager);

    iLog->Log( _L("multi search"));

    // Copy db file, used by CNearestSearchResult

    CopyTestDbFileL(KNEARESTLMDB);

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

    // Initiallize iNearestSearchResults

    AppendNearestSearchResultsL();

    }

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

// CPosTp122::SetupLimits()

//

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

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

void CPosTp122::SetupLimits()

	{

    iIdDb1Min = 1;

    iIdDb1Max = 50;

    iIdDb2Min = 51;

    iIdDb2Max = 100;

    iIdDb3Min = 101;

    iIdDb3Max = 150;

    iIdDb4Min = 151;

    iIdDb4Max = 200;

    iIdDb5Min = 201;

    iIdDb5Max = 254;

	}

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

// CPosTp122::AppendNearestSearchResultsL()

//

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

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

void CPosTp122::AppendNearestSearchResultsL()

    {

    iNearestSearchResults.ResetAndDestroy();

     _LIT(KFileTestValues, "c:\\system\\test\\testdata\\lmDbNearestSearchResult.txt");

    RFile file;

    CleanupClosePushL(file);

    User::LeaveIfError(file.Open(iFileSession, KFileTestValues,  EFileRead));

    TInt row=0;

    TBuf<KMaxNearestLineLength> line;

    while (ReadLn(file, line) != KErrEof)

        {

        TLex lex(line);

        if (lex.Peek() != '#' && lex.Peek() != '\t')

            {

            ++row;

            //iLog->Log(_L("Nearest search result in progress"));

            CNearestSearchResult* searchResult = CNearestSearchResult::NewL(line, row, iFileSession);

            CleanupStack::PushL(searchResult);

            User::LeaveIfError(iNearestSearchResults.Append(searchResult));

            CleanupStack::Pop(searchResult);

            //iLog->Log(_L("Nearest search result added"));

            }

        }

    CleanupStack::PopAndDestroy(&file);

    }

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

// CPosTp122::PrepareDatabasesL

//

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

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

//

void CPosTp122::PrepareDatabasesL()

	{

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

	// Copy eposlmnearestsearch.ldb into five dbs

    _LIT(KDbFile, "c:\\system\\test\\testdata\\eposlmnearestsearch.ldb");

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

    CleanupStack::PushL(fileMan);

    TBuf<100> path;

    path.Zero();

    path.Append(KLmDbPath);

    path.Append(KLMDB1);

    User::LeaveIfError(fileMan->Copy(KDbFile, path, CFileMan::EOverWrite));

    path.Zero();

    path.Append(KLmDbPath);

    path.Append(KLMDB2);

    User::LeaveIfError(fileMan->Copy(KDbFile, path, CFileMan::EOverWrite));

    path.Zero();

    path.Append(KLmDbPath);

    path.Append(KLMDB3);

    User::LeaveIfError(fileMan->Copy(KDbFile, path, CFileMan::EOverWrite));

    path.Zero();

    path.Append(KLmDbPath);

    path.Append(KLMDB4);

    User::LeaveIfError(fileMan->Copy(KDbFile, path, CFileMan::EOverWrite));

    path.Zero();

    path.Append(KLmDbPath);

    path.Append(KLMDB5);

    User::LeaveIfError(fileMan->Copy(KDbFile, path, CFileMan::EOverWrite));

    CleanupStack::PopAndDestroy(fileMan);

    // Now adjust dbs according to following:

    // First db-> Keep landmarks 1-50

    // Second db-> Keep landmarks 51-100

    // Third db-> Keep landmarks 101-150

    // Fourth db-> Keep landmarks 151-200

    // Fifth db-> Keep landmarks 201-254

    RArray<TPosLmItemId> array;

    CleanupClosePushL(array);

    CPosLandmarkDatabase* lmd = CPosLandmarkDatabase::OpenL(KLMDB1);

    CleanupStack::PushL(lmd);

    TBool debug = EFalse;

    TInt index=0;

    TInt max=254;

   	for (index=50;index<max;index++) array.Append(index+1);

    if (lmd->IsInitializingNeeded()) ExecuteAndDeleteLD(lmd->InitializeL());

    ExecuteAndDeleteLD(lmd->RemoveLandmarksL(array));

    array.Reset();

    if (debug) PrintLm(lmd);

    CleanupStack::PopAndDestroy(lmd);

	lmd = CPosLandmarkDatabase::OpenL(KLMDB2);

    CleanupStack::PushL(lmd);

   	for (index=0;index<50;index++) array.Append(index+1);

   	for (index=100;index<max;index++) array.Append(index+1);

    if (lmd->IsInitializingNeeded()) ExecuteAndDeleteLD(lmd->InitializeL());

    ExecuteAndDeleteLD(lmd->RemoveLandmarksL(array));

    array.Reset();

	if (debug) PrintLm(lmd);

    CleanupStack::PopAndDestroy(lmd);

	lmd = CPosLandmarkDatabase::OpenL(KLMDB3);

    CleanupStack::PushL(lmd);

   	for (index=0;index<100;index++) array.Append(index+1);

   	for (index=150;index<max;index++) array.Append(index+1);

    if (lmd->IsInitializingNeeded()) ExecuteAndDeleteLD(lmd->InitializeL());

    ExecuteAndDeleteLD(lmd->RemoveLandmarksL(array));

    array.Reset();

	if (debug) PrintLm(lmd);

    CleanupStack::PopAndDestroy(lmd);

	lmd = CPosLandmarkDatabase::OpenL(KLMDB4);

    CleanupStack::PushL(lmd);

   	for (index=0;index<150;index++) array.Append(index+1);

   	for (index=200;index<max;index++) array.Append(index+1);

    if (lmd->IsInitializingNeeded()) ExecuteAndDeleteLD(lmd->InitializeL());

    ExecuteAndDeleteLD(lmd->RemoveLandmarksL(array));

    array.Reset();

	if (debug) PrintLm(lmd);

    CleanupStack::PopAndDestroy(lmd);

	lmd = CPosLandmarkDatabase::OpenL(KLMDB5);

    CleanupStack::PushL(lmd);

	for (index=0;index<200;index++) array.Append(index+1);

    if (lmd->IsInitializingNeeded()) ExecuteAndDeleteLD(lmd->InitializeL());

    ExecuteAndDeleteLD(lmd->RemoveLandmarksL(array));

    array.Reset();

	if (debug) PrintLm(lmd);

    CleanupStack::PopAndDestroy(lmd);

    CleanupStack::PopAndDestroy(&array);

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

	}

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

// CPosTp122::PrintLm

//

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

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

//

void CPosTp122::PrintLm(CPosLandmarkDatabase* db)

	{

	CPosLmItemIterator* iter = db->LandmarkIteratorL();

	CleanupStack::PushL(iter);

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

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

	TPosLmItemId id = iter->NextL();

	TBuf<100> buf;

	while (id != KPosLmNullItemId)

		{

		CPosLandmark* lm = db->ReadLandmarkLC(id);

		TPtrC name;

		lm->GetLandmarkName(name);

		iLog->Log(_L("Found LM '%S' "), &name);

		TInt idde = lm->LandmarkId();

		id = iter->NextL();

		CleanupStack::PopAndDestroy(lm);

		}

	CleanupStack::PopAndDestroy(iter);

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

	}

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

// CPosTp122::StartL

//

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

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

//

void CPosTp122::StartL()

    {

	TInt KNrOfSearch = 0;

	iErrorsFound= KErrNone;

	iDisplayData = CPosLmDisplayData::NewL();

	iMultiDbSearch->SetDisplayData(*iDisplayData);

    iLog->Log(_L(">>>>>Search Synchronous with ascending sort order"));

    StartSearchOperationL(iNearestSearchResults, ESynchronous, ESortAscending, KNrOfSearch);

    iLog->Log(_L(">>>>>Search Synchronous with descending sort order"));

    StartSearchOperationL(iNearestSearchResults, ESynchronous, ESortDescending, KNrOfSearch);

    iLog->Log(_L(">>>>>Search Asynchronous with ascending sort order"));

    StartSearchOperationL(iNearestSearchResults, EAsynchronous, ESortAscending, KNrOfSearch);

    iLog->Log(_L(">>>>>Search Asynchronous with descending sort order"));

    StartSearchOperationL(iNearestSearchResults, EAsynchronous, ESortDescending, KNrOfSearch);

    iLog->Log(_L(">>>>>Search Synchronous with no sort order (therefore sorted by distance)"));

    StartSearchOperationL(iNearestSearchResults, ESynchronous, ESortNone);

	iLog->Log(_L(">>>>>Search Asynchronous with no sort order (therefore sorted by distance)"));

    StartSearchOperationL(iNearestSearchResults, EAsynchronous, ESortNone);

    iLog->Log(_L(">>>>>Search Synchronous with no sort order, partial (therefore sorted by distance)"));

    iPartial = ETrue;

    StartSearchOperationL(iNearestSearchResults, ESynchronous, ESortNone);

    iPartial = EFalse;

    iDisplayData->UnsetPartialReadParameters();

    iLog->Log(_L("Test with maximum searches"));

    TestMaximumNrOfMatchesL(iNearestSearchResults, EAsynchronous, ESortNone);

    TestMaximumNrOfMatchesL(iNearestSearchResults, ESynchronous, ESortNone);

    TestMaximumNrOfMatchesL(iNearestSearchResults, EAsynchronous, ESortDescending);

    TestMaximumNrOfMatchesL(iNearestSearchResults, EAsynchronous, ESortAscending);

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

    TestOnTheFlySearchL(iNearestSearchResults);

    // Since TestOnTheFlySearchL is changing displadata

    iMultiDbSearch->UnsetDisplayData();

    delete iDisplayData;

    iDisplayData = NULL;

    iDisplayData = CPosLmDisplayData::NewL();

	iMultiDbSearch->SetDisplayData(*iDisplayData);

    iLog->Log(_L("Test Leave codes for nearest search"));

    TestLeaveCodesL();

    // TC Step 6 "A new array of databases is set to be searched"

    iLog->Log(_L("Test refined search, test different search dbs"));

    DoLastTestPartL(iNearestSearchResults);

    iLog->Log(_L("Testing cancel immediately"));

    CancelTestL(iNearestSearchResults, EFalse);

	// XXX Hangs client

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

    CancelTestL(iNearestSearchResults, ETrue);

    if (iErrorsFound != KErrNone)

    	{

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

    	User::Leave(-1);

    	}

    else iLog->Log(_L("TP122 successfully completed"));

    }

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

// CPosTp122::StartSearchOperationL

//

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

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

//

void CPosTp122::StartSearchOperationL(

    const RPointerArray<CNearestSearchResult>& aSearchResults,

    TExecutionMode aExecutionMode,

    TTp122SortOrder aSortOrder,

    TInt aNrOfSearches)

    {

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

    iMultiDbSearch->SetMaxNumOfMatches(1);

    iMultiDbSearch->SetMaxNumOfMatches();

    TBuf<100> buf;

    TInt maxSearches = 0;

    if (aNrOfSearches == 0) maxSearches = aSearchResults.Count();

    else maxSearches = aNrOfSearches;

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

        {

        TCoordinate coord(aSearchResults[i]->iLatitude, aSearchResults[i]->iLongitude);

        CPosLmNearestCriteria* nearestCriteria = CPosLmNearestCriteria::NewLC(coord, aSearchResults[i]->iUseCoverageRadius);

        nearestCriteria->SetMaxDistance(aSearchResults[i]->iMaxDistance);

		buf.Format(_L("StartSearchOperationL: Searching for Lat %f Long %f"), aSearchResults[i]->iLatitude, aSearchResults[i]->iLongitude);

		//iLog->Log(buf);

        if (aSearchResults[i]->iMaxSearchResult > 0)

            {

            // Does not work anymore

            //iMultiDbSearch->SetMaxNumOfMatches(aSearchResults[i]->iMaxSearchResult);

            }

        else

            {

            iMultiDbSearch->SetMaxNumOfMatches(KPosLmMaxNumOfMatchesUnlimited);

            }

        if (iNearestSearchResults[i]->Redefined() && i > 0)

            {

            // Remove distances that are not present in the previous

            for (TInt j=0; j<iNearestSearchResults[i]->iDistances.Count(); j++)

                {

                TBool found = EFalse;

                TInt id = 0;

                TPosLmItemId idde;

                id = j;

                idde = iNearestSearchResults[i]->iDistances[j].Id();

                TBuf<100> debug;

                debug.Format(_L("Looking for id %d or id: %d "), idde, id);

                //iLog->Log(debug);

                for (TInt p=0;p<iNearestSearchResults[i-1]->iDistances.Count();p++)

                    {

                    if (iNearestSearchResults[i]->iDistances[j].Id() == iNearestSearchResults[i-1]->iDistances[p].Id())

                        {

                        found = ETrue;

                        TBuf<100> buf;

                        buf.Format(_L("Found id %d or id: %d "), idde, id);

                        //iLog->Log(buf);

                        }

                    }

                if (!found)

                    {

                    // Remove since not found, only keep ids that was found in previous search

                    TBuf<100> buf;

                    buf.Format(_L("Removing lm Id %d from index %d"), idde, id);

                    //iLog->Log(buf);

                    iNearestSearchResults[i]->iDistances.Remove(id);

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

                    j--;

                    }

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

                }

            }

        TTime iStart;

     	TTime iStop;

     	iStart.UniversalTime();

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

    	iStop.UniversalTime();

    	TInt64 msec = (iStop.Int64() - iStart.Int64())/1000;

		buf.Format(_L("Search op nr %d took %d msec"), i, msec);

		iLog->Log(buf);

    	AssertTrueSecL(NrOfSearchErrors(iMultiDbSearch) == 0, _L("Found search errors!"));

    	// Add check of result here

    	CheckSearchResultL(*aSearchResults[i], aSortOrder);

    	CleanupStack::PopAndDestroy(nearestCriteria);

    	iDisplayData->Reset();

        }

    }

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

// CPosTp122::SearchL

//

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

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

//

void CPosTp122::SearchL(

    CPosLmNearestCriteria* aNearestSearchCriteria,

    TExecutionMode aExecutionMode,

    TBool aRefinedSearch,

    TTp122SortOrder aSortOrder)

    {

    if (iPartial)

        {

        RArray<TUint> reqFields;

        CleanupClosePushL(reqFields);

        reqFields.Append(EPositionFieldStreet);

        reqFields.Append(EPositionFieldBuildingFloor);

        CPosLmPartialReadParameters* partialParam = CPosLmPartialReadParameters::NewLC();

        partialParam->SetRequestedPositionFields(reqFields);

        iDisplayData->SetPartialReadParametersL(*partialParam);

        CleanupStack::PopAndDestroy(2);

        }

    switch (aSortOrder)

        {

        case ESortNone:

        	{

            iOperation = iMultiDbSearch->StartLandmarkSearchL(*aNearestSearchCriteria, aRefinedSearch);