/*
* 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_CPosTp11.h"
#include <EPos_CPosLandmarkDatabase.h> 
#include <EPos_CPosLMItemIterator.h> 
#include <EPos_CPosLandmark.h>
#include <EPos_TPosLMSortPref.h> 

//CONSTANTS
const TInt KNoCategoriesTp11  = 100;
const TInt KNoLandmarksTp11 = 100;     

_LIT(KCategoryIteratorNumOfItemsErr, "The iterator returns incorrect number of items");
_LIT(KCategoryIteratorIdErr, "A category id not in the database returned from the iterator");         

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

// ---------------------------------------------------------
// CPosTp11::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp11::StartL()
    {  
    iLog->Log(_L("***** Testing CPosCategoryManager::CategoryIteratorL() and CPosCategoryManager::ReferencedCategoryIteratorL()***** "));
    
    RemoveDefaultDbL();
    RemoveAllLmDatabasesL();              
    
    iDatabase = CPosLandmarkDatabase::OpenL();        
    if (iDatabase->IsInitializingNeeded())
       {
        iLog->Log(_L("ExecuteAndDeleteLD(iDatabase->InitializeL())"));
       ExecuteAndDeleteLD(iDatabase->InitializeL());
       } 
       
    iLog->Log(_L("Default database opened and initialized "));       
               
    iCategoryManager = CPosLmCategoryManager::NewL(*iDatabase);
    ExecuteAndDeleteLD(iDatabase->CompactL());          
    
    MakeEmptyLmDatabaseL( *iDatabase, *iCategoryManager);        
    
    iLog->Log(_L("Deleting all landmarks and categories to create empty database Done"));
    
    AddCategoriesL();
    AddLandmarksL();   

    iLog->Log(_L("** 1: Testing CPosCategoryManager::CategoryIteratorL() (Iteration of categories)"));
    IterateCategoriesL();
    
    iLog->Log(_L("** 2: Testing CPosCategoryManager::ReferencedCategoryIteratorL() (Iteration of referenced categories)"));   
    
    IterateReferencedCategoriesL();

    iLog->Log(_L("** 3: Testing CPosCategoryManager::CategoryIteratorL() (Iteration of categories)"));    
    IterateSetOfCategoriesL();
	
	iLog->Log(_L("** 4: Testing CPosCategoryManager::CategoryIteratorL() (Iteration of Sorted categories)"));    
    IterateSortedCategoriesL();    
    
    iLog->Log(_L("** 5: Testing CPosCategoryManager::ReferencedCategoryIteratorL() (Iteration of Sorted referenced categories)"));    
    IterateReferencedSortedCategoriesL();    

    delete iDatabase;
    iDatabase = NULL;

    // Remove lm db
    RemoveDefaultDbL();    
    }

// ---------------------------------------------------------
// CPosTp11::CloseTest
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp11::CloseTest()
    {
    iLog->Log(_L("CloseTest"));
    iCategories.ResetAndDestroy();
    iCategories.Close();
    
    iReferencedCategories.Close();
    iLandmarks.ResetAndDestroy();
    iLandmarks.Close();
    
    delete iDatabase;
    iDatabase = NULL;
    
    delete iCategoryManager; 
    iCategoryManager = NULL;      
    }
    

// ---------------------------------------------------------
// CPosTp11::AddCategoriesL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp11::AddCategoriesL()
    {    
    _LIT(KName, "CategoryTP11 - %d");
    TInt err=KErrLocked;
    for (TInt i=0; i<KNoCategoriesTp11; i++)
        {
        TBuf<100> categoryName;
        categoryName.Format(KName,i);
       
        CPosLandmarkCategory* lmc = CPosLandmarkCategory::NewLC();
        lmc->SetCategoryNameL(categoryName);
        err = KErrLocked;
        while (err == KErrLocked)
            {
            TRAP(err, iCategoryManager->AddCategoryL(*lmc));
            }
    
        iCategories.Append(lmc);       
        CleanupStack::Pop(lmc);
        }    
    iLog->Log(_L("Adding categories to database done "));
    }

// ---------------------------------------------------------
// CPosTp11::AddLandmarksL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp11::AddLandmarksL()
    {
    _LIT(KLmName, "LmTP11 - %d");
    TInt err = KErrLocked;
    for (TInt i=0; i<KNoLandmarksTp11; i++)
        {
        TBuf<100> lmName;
        lmName.Format(KLmName,i);
       
        CPosLandmark* landmark = CPosLandmark::NewLC();
        landmark->SetLandmarkNameL(lmName); 

        if (i % 2)
            {
            landmark->AddCategoryL(iCategories[i]->CategoryId());
            iReferencedCategories.Append(*iCategories[i]);
            }

        err = KErrLocked;
        while (err == KErrLocked)
            {
            TRAP(err, iDatabase->AddLandmarkL(*landmark));
            }
        iLandmarks.Append(landmark);
        CleanupStack::Pop(landmark);
        }
    iLog->Log(_L("Adding categories to landmarks and adding landmarks to database done "));
    }


// ---------------------------------------------------------
// CPosTp11::IterateCategoriesL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp11::IterateCategoriesL()
    {
    CPosLmItemIterator* iter = iCategoryManager->CategoryIteratorL();
    CleanupStack::PushL(iter);

    AssertTrueSecL(iter->NumOfItemsL() == (TUint)iCategories.Count(), KCategoryIteratorNumOfItemsErr);

    CheckIteratorItemsL(*iter);
 
    iter->Reset();

    CheckIteratorItemsL(*iter);

    CleanupStack::PopAndDestroy(iter);
    }

// ---------------------------------------------------------
// CPosTp11::IterateReferencedCategoriesL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp11::IterateReferencedCategoriesL()
    {
    CPosLmItemIterator* iter = iCategoryManager->ReferencedCategoryIteratorL();
    CleanupStack::PushL(iter);

    AssertTrueSecL(iter->NumOfItemsL() == (TUint)(iCategories.Count()/2), KCategoryIteratorNumOfItemsErr);
    
    CheckIteratorItemsL(*iter);
 
    iter->Reset();

    CheckIteratorItemsL(*iter);
    
    CleanupStack::PopAndDestroy(iter);
    }

// ---------------------------------------------------------
// CPosTp11::CheckIteratorItemsL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp11::CheckIteratorItemsL(CPosLmItemIterator& iter)
    {
    TPosLmItemId id = iter.NextL();
    while (id != KPosLmNullItemId)
        {
        CPosLandmarkCategory* source = InternalGet(id);
        AssertTrueSecL(source != NULL, KCategoryIteratorIdErr);
        CPosLandmarkCategory* target = iCategoryManager->ReadCategoryLC(id);
        CompareCategoriesL(*source, *target);
        CleanupStack::PopAndDestroy(target); 
        id = iter.NextL();
        }    
    }

// ---------------------------------------------------------
// CPosTp11::IterateSetOfCategoriesL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp11::IterateSetOfCategoriesL()
    {
    CPosLmItemIterator* iter = iCategoryManager->CategoryIteratorL();
    CleanupStack::PushL(iter);

    const TInt startIndex=11;
    const TInt numOfItems=34;

    RArray<TPosLmItemId> ids;
    CleanupClosePushL(ids);

    iter->GetItemIdsL(ids, startIndex, numOfItems);
    
    AssertTrueSecL(ids.Count() == numOfItems, KCategoryIteratorNumOfItemsErr);

    for (TInt i=0; i<numOfItems; i++)
        {
        CPosLandmarkCategory* source = InternalGet(ids[i]);
        AssertTrueSecL(source != NULL, KCategoryIteratorIdErr);
        
        CPosLandmarkCategory* target = iCategoryManager->ReadCategoryLC(ids[i]);
        CompareCategoriesL(*source, *target);
        CleanupStack::PopAndDestroy(target); 
        }

    CleanupStack::PopAndDestroy(2, iter);

    }

// ---------------------------------------------------------
// InternalSort
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
TInt InternalSortL(const CPosLandmarkCategory& aSource, const CPosLandmarkCategory& aTarget)
    {
    TPtrC sourceName, targetName;
    
    User::LeaveIfError(aSource.GetCategoryName(sourceName));  
    User::LeaveIfError(aTarget.GetCategoryName(targetName));
    
    return sourceName.Compare(targetName);
    }

// ---------------------------------------------------------
// CPosTp11::IterateSortedCategoriesL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp11::IterateSortedCategoriesL()
    {
    
    TLinearOrder<CPosLandmarkCategory> order(InternalSortL);
    iCategories.Sort(order);

    CPosLmItemIterator* iter = iCategoryManager->CategoryIteratorL(
                                CPosLmCategoryManager::ECategorySortOrderNameDescending);
    CleanupStack::PushL(iter);

    AssertTrueSecL(iter->NumOfItemsL() == (TUint)iCategories.Count(), KCategoryIteratorNumOfItemsErr);

    TInt lastIndex=iCategories.Count()-1;
    for (TInt i=lastIndex; i>=0; i--)
        {
        CPosLandmarkCategory* target = iCategoryManager->ReadCategoryLC(iter->NextL());
       
        CompareCategoriesL(*iCategories[i], *target);
        CleanupStack::PopAndDestroy(target); 
        }
    CleanupStack::PopAndDestroy(iter);

    iter = iCategoryManager->CategoryIteratorL(
                                CPosLmCategoryManager::ECategorySortOrderNameAscending);
    CleanupStack::PushL(iter);

    for (TInt j=0; j < iCategories.Count(); j++)
        {
        CPosLandmarkCategory* target = iCategoryManager->ReadCategoryLC(iter->NextL());
       
        CompareCategoriesL(*iCategories[j], *target);
        CleanupStack::PopAndDestroy(target); 
        }

    CleanupStack::PopAndDestroy(iter);
    
    }

// ---------------------------------------------------------
// CPosTp11::IterateReferencedSortedCategoriesL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp11::IterateReferencedSortedCategoriesL()
    {
    TLinearOrder<CPosLandmarkCategory> order(InternalSortL);

    iReferencedCategories.Sort(order);

    CPosLmItemIterator* iter = iCategoryManager->ReferencedCategoryIteratorL(
                                CPosLmCategoryManager::ECategorySortOrderNameDescending);
    CleanupStack::PushL(iter);

    AssertTrueSecL(iter->NumOfItemsL() == (TUint)(iCategories.Count()/2), KCategoryIteratorNumOfItemsErr);

    TInt lastIndex=iReferencedCategories.Count()-1;
    for (TInt i=lastIndex; i>=0; i--)
        {
        CPosLandmarkCategory* target = iCategoryManager->ReadCategoryLC(iter->NextL());
       
        CompareCategoriesL(iReferencedCategories[i], *target);
        CleanupStack::PopAndDestroy(target); 
        }

    CleanupStack::PopAndDestroy(iter);

    iter = iCategoryManager->ReferencedCategoryIteratorL(
                                CPosLmCategoryManager::ECategorySortOrderNameAscending);
    CleanupStack::PushL(iter);

    for (TInt j=0; j < iReferencedCategories.Count(); j++)
        {
        CPosLandmarkCategory* target = iCategoryManager->ReadCategoryLC(iter->NextL());
       
        CompareCategoriesL(iReferencedCategories[j], *target);
        CleanupStack::PopAndDestroy(target); 
        }

    CleanupStack::PopAndDestroy(iter);
    }

// ---------------------------------------------------------
// CPosT11::InternalGet
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
CPosLandmarkCategory* CPosTp11::InternalGet(TPosLmItemId id)
    {
    for (TInt i=0; i<iCategories.Count(); i++)
        {   
        if (iCategories[i]->CategoryId() == id)
            {
            return iCategories[i];
            }
        }
  
    return NULL;
    }
                                 
// ---------------------------------------------------------
// CPosT11::CreateEmptyLmDatabaseL() 
// ---------------------------------------------------------
//
void CPosTp11::MakeEmptyLmDatabaseL( CPosLandmarkDatabase& aLdb,
                                     CPosLmCategoryManager& aCatMgr )    
    {
    
    CPosLmOperation* operation1 = aLdb.RemoveAllLandmarksL();
    //Remove all landmarks from default db : Sync call     
    ExecuteAndDeleteLD( operation1 ); 

    RArray<TPosLmItemId> catArray;
    CleanupClosePushL( catArray );
    
    // Get all the categories from the database and delete them if necessary 
    CPosLmItemIterator* iter = aCatMgr.CategoryIteratorL();
    CleanupStack::PushL( iter );

    TUint count = iter->NumOfItemsL();
    if ( count > 0 )
        { // can only be called if there are some items
        iter->GetItemIdsL( catArray, 0, count );
        }
        
    // Remove all the categories here Sync call     
    ExecuteAndDeleteLD(aCatMgr.RemoveCategoriesL( catArray ));    
    CleanupStack::PopAndDestroy( 2 ); // catArray, iter
    }
    
    
    
//  End of File