/*

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

#include <EPos_CPosLmDisplayData.h>

#include <EPos_CPosLmDisplayItem.h>

#include <EPos_CPosLMItemIterator.h>    

#include <EPos_CPosLmMultiDbSearch.h>    

#include <EPos_CPosLmDatabaseManager.h>

#include <e32math.h>

// CONSTANTS

_LIT(KLMDB1, "COMPOSITELMDB_1.LDB");

_LIT(KLMDB2, "COMPOSITELMDB_2.LDB");

_LIT(KLMDB3, "COMPOSITELMDB_3.LDB");

_LIT(KLMDB4, "COMPOSITELMDB_4.LDB");

_LIT(KLMDB5, "COMPOSITELMDB_5.LDB");

_LIT(KLMDB1Path,"file://C:COMPOSITELMDB_1.LDB");

_LIT(KLMDB2Path,"file://C:COMPOSITELMDB_2.LDB");

_LIT(KLMDB3Path,"file://C:COMPOSITELMDB_3.LDB");

_LIT(KLMDB4Path,"file://C:COMPOSITELMDB_4.LDB");

_LIT(KLMDB5Path,"file://C:COMPOSITELMDB_5.LDB");

//_LIT(KCOMPOSITELMDB, "compositeeposlm.ldb");

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

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

// CPosTp124::CloseTest

//

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

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

//

void CPosTp124::CloseTest()

    {

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

    delete iDatabase;

    iDatabase=NULL;

    delete iDatabases;

    if (iMultiDbSearch) iMultiDbSearch->UnsetDisplayData();

    delete iDisplayData;

    iDisplayData = NULL;

    delete iMultiDbSearch;

    TRAPD(err, RemoveAllLmDatabasesL());

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

    }

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

// CPosTp124::InitTestL

//

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

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

//

void CPosTp124::InitTestL()

    {

    CLandmarkTestProcedureBase::InitTestL();

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

    RemoveAllLmDatabasesL();

    CPosLmDatabaseManager* dbManager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

    // check the count of databases that could not be delted since they were in use

    iDatabases = dbManager->ListDatabasesLC();

    CleanupStack::Pop(iDatabases);

    iDbCount = iDatabases->Count();

    // PrepareDatabases

    PrepareDatabasesL();

	SetupLimits();

    iDatabases = dbManager->ListDatabasesLC();

    CleanupStack::Pop(iDatabases);

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

    // database count is equal to ones added plus ones not been able to delte since they were in use

    TInt dbCount = iDatabases->Count();

    iNrOfDatabases = iDbCount + 5;

    iMultiDbSearch = CPosLmMultiDbSearch::NewL(*iDatabases);

    CleanupStack::PopAndDestroy(dbManager);

    iDisplayData = CPosLmDisplayData::NewL();

	iMultiDbSearch->SetDisplayData(*iDisplayData);

    }

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

// CPosTp124::StartL

//

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

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

//

void CPosTp124::StartL()

    {

    TTime startTime;

    TTime stopTime;

    startTime.UniversalTime();

    MakeSurePanicDebugFileExistsL();

    iDatabase = UseCompositeLandmarksDbFileL();

    if (iDatabase->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(iDatabase->InitializeL());

       }

	// TC_Part 1

	// ASynchronous, Sort ascending

    StartLandmarksCompositeTestL(EAsynchronous, ESortAscending);

    // Synchronous, Sort descending

    StartLandmarksCompositeTestL(EAsynchronous, ESortDescending);

    // ASynchronous, Sort ascending

    TestWithSortOrderLandmarksL(EAsynchronous, ESortAscending);

    TestWithSortOrderNearestL(EAsynchronous, ESortAscending);

    TestWithSortOrderNearestL(ESynchronous, ESortNone);

    TestWithSortOrderNearestL(EAsynchronous, ESortDescending);

    TestWithSortOrderNearestL(EAsynchronous, ESortDistance);

    // TC Part 2_3 Test with several text criterias

    TestSeveralTextArgumentsL();

	// TC Part 4-5 Test add and remove from composite object

    TestAddAndRemoveL();

   	// TC Part 6

	// Cancel immediately

    CancelTestL(EFalse);

    // Cancel in callback

    CancelTestL(ETrue);

	// TC Part 7

    TestOnTheFlySearchL();

    // Since TestOnTheFlySearchL is changing displadata

    iMultiDbSearch->UnsetDisplayData();

    delete iDisplayData;

    iDisplayData = NULL;

    iDisplayData = CPosLmDisplayData::NewL();

	iMultiDbSearch->SetDisplayData(*iDisplayData);

    // TC Part 8-11

  //  TestLessDbsToSearchL();

    // TC Part 12 

    // It is not possible to use Composite in a composite object in multi search

    TestCompositeInCompositeL();

    // TC Part 13

    // It is not possible to use IdList in a composite object in multi search

    TestWithIdListAndCompositeL();

    // TC Part 14

    // It is not possible to use CPosLmCatNameCriteria in a composite object in multi search

    TestCategoryCompositeSearchL();

    // TC Part 15

    // Test with no previous result but try to refine search anyway

	TestWithNoPreviousResultL();

	TInt KNrOfObjectsInComposite = 100;

    TInt KStartIndex = 90;

    CompositeStressTestL(KStartIndex, KNrOfObjectsInComposite);

    stopTime.UniversalTime();

    TTimeIntervalMicroSeconds executionTime = 

        stopTime.MicroSecondsFrom(startTime);

    TInt resse = executionTime.Int64()/1000000;

    TBuf<100> buf;

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

    iLog->Log(buf);

    if (iErrorsFound != KErrNone) 

    	{

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

    	User::Leave(-1);

    	}

	}

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

// CPosTp124::SetupLimits()

//

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

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

void CPosTp124::SetupLimits()

	{

	// First db-> Keep landmarks 1-20

    // Second db-> Keep landmarks 21-40

    // Third db-> Keep landmarks 41-60

    // Fourth db-> Keep landmarks 61-80

    // Fifth db-> Keep landmarks 81-105

    iIdDb1Min = 1;

    iIdDb1Max = 20;

    iIdDb2Min = 21;

    iIdDb2Max = 40;

    iIdDb3Min = 41;

    iIdDb3Max = 60;

    iIdDb4Min = 61;

    iIdDb4Max = 80;

    iIdDb5Min = 81;

    iIdDb5Max = 105;

	}

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

// CPosTp124::ValidateIdL

//

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

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

//

void CPosTp124::ValidateIdL(TPosLmItemId aId, TInt aDbIndex)

    {

    TBool condition = EFalse;

    switch (aDbIndex)

        {        

        case 0:

            // Db 1 contains landmarks with id = 1-20

            condition = aId >= iIdDb1Min && aId <= iIdDb1Max;

            break;

        case 1:

            // Db 2 contains landmarks with id = 21-40

            condition = aId >= iIdDb2Min && aId <= iIdDb2Max;

            break;

        case 2:

            // Db 3 contains landmarks with id = 41-60

            condition = aId >= iIdDb3Min && aId <= iIdDb3Max;

            break;

        case 3:

            // Db 4 contains landmarks with id = 61-80

            condition = aId >= iIdDb4Min && aId <= iIdDb4Max;

            break;

        case 4:

            // Db 5 contains landmarks with id = 81-105

            condition = aId >= iIdDb5Min && aId <= iIdDb5Max;

            break;

        }

    if (!condition) 

    	{

    	iErrorsFound++;

    	TBuf<150> buf;

    	buf.Format(_L("ERROR: Invalid match from database reported, index %d in db %d"), aId, aDbIndex);

    	iLog->Log(buf);

    	}

    }

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

// CPosTp124::PrepareDatabasesL

//

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

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

//

void CPosTp124::PrepareDatabasesL()

	{

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

	// Copy eposlmnearestsearch.ldb into five dbs

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

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

    CleanupStack::PushL(fileMan);

    // Create five copies of testdata\\compositeeposlm.ldb

    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-20

    // Second db-> Keep landmarks 21-40

    // Third db-> Keep landmarks 41-60

    // Fourth db-> Keep landmarks 61-80

    // Fifth db-> Keep landmarks 81-105

    RArray<TPosLmItemId> array;

    CleanupClosePushL(array);

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

    CleanupStack::PushL(lmd);

    TBool debug = EFalse;

    TInt index=0;

    TInt max=105;

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

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

    ExecuteAndDeleteLD(lmd->RemoveLandmarksL(array));

    User::After(200000);

    ExecuteAndDeleteLD(lmd->CompactL());

    array.Reset();

    if (debug) PrintLm(lmd);

    CleanupStack::PopAndDestroy(lmd);

	lmd = CPosLandmarkDatabase::OpenL(KLMDB2);

    CleanupStack::PushL(lmd);

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

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

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

    ExecuteAndDeleteLD(lmd->RemoveLandmarksL(array));

    User::After(200000);

    ExecuteAndDeleteLD(lmd->CompactL());

    array.Reset();

	if (debug) PrintLm(lmd);

    CleanupStack::PopAndDestroy(lmd);

	lmd = CPosLandmarkDatabase::OpenL(KLMDB3);

    CleanupStack::PushL(lmd);

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

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

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

    ExecuteAndDeleteLD(lmd->RemoveLandmarksL(array));

    User::After(200000);

    ExecuteAndDeleteLD(lmd->CompactL());

    array.Reset();

	if (debug) PrintLm(lmd);

    CleanupStack::PopAndDestroy(lmd);

	lmd = CPosLandmarkDatabase::OpenL(KLMDB4);

    CleanupStack::PushL(lmd);

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

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

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

    ExecuteAndDeleteLD(lmd->RemoveLandmarksL(array));

    User::After(200000);

    ExecuteAndDeleteLD(lmd->CompactL());

    array.Reset();

	if (debug) PrintLm(lmd);

    CleanupStack::PopAndDestroy(lmd);            

	lmd = CPosLandmarkDatabase::OpenL(KLMDB5);

    CleanupStack::PushL(lmd);

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

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

    ExecuteAndDeleteLD(lmd->RemoveLandmarksL(array));

    User::After(200000);

    ExecuteAndDeleteLD(lmd->CompactL());

    array.Reset();

	if (debug) PrintLm(lmd);

    CleanupStack::PopAndDestroy(lmd);    

    CleanupStack::PopAndDestroy(&array);

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

	}

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

// CPosTp124::PrintLm

//

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

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

//

void CPosTp124::PrintLm(CPosLandmarkDatabase* db)

	{

	CPosLmItemIterator* iter = db->LandmarkIteratorL();

	CleanupStack::PushL(iter);

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

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

		iLog->Log(name);

		TInt idde = lm->LandmarkId();

		id = iter->NextL();

		CleanupStack::PopAndDestroy(lm);

		}

	CleanupStack::PopAndDestroy(iter);

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

	}

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

// CPosTp124::TestOnTheFlySearchL

//

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

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

//

void CPosTp124::TestOnTheFlySearchL()

    {

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

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

    CCompositeSearchResult* res = CCompositeSearchResult::NewL(iLog);

    CleanupStack::PushL(res);

    while (!res->GetCompositeSearchResultsL(*composite))

        {

        // Check if IdList is included in composite, if so dont 

        // use this search since IdList is not possible to use in multiple db seach

        if (!CheckCompositeForIdListL(composite))

        	{

        	PrintCompositeInfo(composite);

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

			TBuf<150> buf;

    		COnTheFlyTester* onTheFlyTester = COnTheFlyTester::NewLC();

    		onTheFlyTester->StartSearchCampaignL(iMultiDbSearch, res->iResultIds, composite);

    		TInt result = onTheFlyTester->Err();

    		if (result != KErrNone)

		        {

		        TPtrC msg;

		        onTheFlyTester->GetErrMsg(msg);

		        iLog->Log(msg);

    			User::Leave(result);

		        }

    		CleanupStack::PopAndDestroy(onTheFlyTester);

			}

    }

    CleanupStack::PopAndDestroy(res);

    CleanupStack::PopAndDestroy(composite);

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

    }

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

// CPosTp124::TestLessDbsToSearchL

//

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

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

//

void CPosTp124::TestLessDbsToSearchL()

	{

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

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

	TBuf<100> buf;

    // First create a textcriteria

    CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();   

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

    User::LeaveIfError(composite->AddArgument(textCriteria));

    CleanupStack::Pop(textCriteria);

    // Create search result

   	RArray<TPosLmItemId> searchResults;

	CleanupClosePushL(searchResults);

	// Will find:

	searchResults.Append(1);

	searchResults.Append(2);

	searchResults.Append(20);

	searchResults.Append(21);

	searchResults.Append(22);

	searchResults.Append(23);

	searchResults.Append(24);

	searchResults.Append(26);

	searchResults.Append(27);

	searchResults.Append(28);