/*
* 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 <StifParser.h>
#include "FT_CPosTp13.h"
#include <epos_cposlandmarkdatabase.h>
#include <epos_cposlmcategorymanager.h>
#include <epos_cposlmtextcriteria.h>
#include <epos_cposlmcategorycriteria.h>
#include <epos_cposlandmarksearch.h>
#include <bautils.h>
#include "EPos_Landmarks.h"
           
//  CONSTANTS
_LIT(KTP13Db, "eposlm_tp13.ldb");

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

// ---------------------------------------------------------
// CPosTp13::CloseTest
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp13::CloseTest()
    {
    iLog->Log(_L("CloseTest"));
    }

// ---------------------------------------------------------
// CPosTp13::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp13::StartL(CStifItemParser& /*aItem*/)
    {
    _LIT( KTransportName, "Teleport" );
    _LIT( KPeopleName, "People" );
    _LIT( KLmAName, "A" );
    _LIT( KLmBName, "B" );
    
    const TInt KTransportGlobalId = 45000;
    const TInt KPeopleGlobalId = 27000;
   
#undef TP13_PREP

#ifdef TP13_PREP    
    // Preparation code, should be executed in Finnish (non-English) locale
    // Default database should be removed so that new database is created

    CPosLandmarkDatabase* db = CPosLandmarkDatabase::OpenL();
    CleanupStack::PushL(db);
    
    CPosLmItemIterator* iter = NULL;
    if ( db->IsInitializingNeeded() )
        {
        ExecuteAndDeleteLD( db->InitializeL() );
        }

    CPosLmCategoryManager* catMan = CPosLmCategoryManager::NewL( *db );
    CleanupStack::PushL( catMan );

    // Rename global category
    TPosLmItemId id = catMan->GetGlobalCategoryL( KTransportGlobalId ); 
    CPosLandmarkCategory* cat = catMan->ReadCategoryLC( id );
    cat->SetCategoryNameL( KTransportName );
    catMan->UpdateCategoryL( *cat );
    CleanupStack::PopAndDestroy( cat );

    // Create user category
    cat = CPosLandmarkCategory::NewLC();
    cat->SetCategoryNameL( KPeopleName );
    TPosLmItemId idUserPeople = catMan->AddCategoryL( *cat );
    CleanupStack::PopAndDestroy( cat );
    
    // Find matching global category
    TPosLmItemId idPeople = catMan->GetGlobalCategoryL( KPeopleGlobalId );
    
    // Create landmark for user's People category
    CPosLandmark* lmA = CPosLandmark::NewLC();
    lmA->SetLandmarkNameL( KLmAName );
    lmA->AddCategoryL( idUserPeople );
    db->AddLandmarkL( *lmA );
    CleanupStack::PopAndDestroy( lmA );

    // Create landmark for global People category
    CPosLandmark* lmB = CPosLandmark::NewLC();
    lmA->SetLandmarkNameL( KLmBName );
    lmA->AddCategoryL( idPeople );
    db->AddLandmarkL( *lmB );
    CleanupStack::PopAndDestroy( lmB );

    CleanupStack::PopAndDestroy( catMan );
    CleanupStack::PopAndDestroy( db );
    
#else
    
    // Test code, should be executed in English locale
    
    TInt lang = User::Language();
    iLog->Log(_L("Current language is %d"), lang);

    if ( lang != ELangEnglish )
        { 
        iLog->Log(_L("Wrong language, should be English (1)"));
        User::Leave( KErrGeneral );
        }
    
    CopyTestDbFileL( KTP13Db );
    
    // 1. Open database
    iLog->Log(_L("1. Open database"));

    CPosLandmarkDatabase* db = CPosLandmarkDatabase::OpenL( KTP13Db );
    CleanupStack::PushL(db);
    
    // 2. Try to use it
    iLog->Log(_L("2. Try use it"));

    CPosLmItemIterator* iter = NULL;
    TRAPD( err, iter = db->LandmarkIteratorL() );
    if ( err != KErrPosLmNotInitialized )
        {
        iLog->Log(_L("Unexpected error on uninitialized database"));
        iErrorsFound++;
        }

    // 3. Initialize database
    iLog->Log(_L("3. Init database"));

    if ( db->IsInitializingNeeded() )
        {
        ExecuteAndDeleteLD( db->InitializeL() );
        }
    else
        {
        iLog->Log(_L("Intialization not requried"));
        iErrorsFound++;
        }

    // 4. Verify names of global categories
    iLog->Log(_L("4. Verify globals"));

    CPosLmCategoryManager* catMan = CPosLmCategoryManager::NewL( *db );
    CleanupStack::PushL( catMan );

    iter = catMan->CategoryIteratorL();
    CleanupStack::PushL( iter );

    TPosLmItemId id = iter->NextL();
    while ( id != KPosLmNullItemId )
        {
        CPosLandmarkCategory* cat = catMan->ReadCategoryLC( id );
        TPosLmGlobalCategory globalId = cat->GlobalCategory();
        
        TPtrC name;
        cat->GetCategoryName( name );

        if ( globalId != KTransportGlobalId )
            {
            HBufC* globalName = catMan->GlobalCategoryNameL( globalId );
            if ( name.Compare( *globalName ) != 0 )
                {
                iLog->Log( _L("Global category %d name mismatch: actual '%S', predefined '%S'"),
                    globalId, &name, globalName );
                iErrorsFound++;
                }
            delete globalName;
            }
        else // should retain user-defiend name
            {
            if ( name.Compare( KTransportName() ) != 0 )
                {
                iLog->Log( _L("Global category %d name mismatch: actual '%S', user-defined '%S'"),
                    globalId, &name, &KTransportName() );
                iErrorsFound++;
                }
            }
        
        CleanupStack::PopAndDestroy( cat );
        id = iter->NextL();
        }
    CleanupStack::PopAndDestroy( iter );

    // 5. Verify user-created category People, which now matches global category
    iLog->Log(_L("5. Verify user's"));
    TPosLmItemId idPeople = catMan->GetCategoryL( KPeopleName );
    CPosLandmarkCategory* cat = catMan->ReadCategoryLC( idPeople );
    TPosLmGlobalCategory idPeopleGlobal = cat->GlobalCategory();
    if ( idPeopleGlobal != KPeopleGlobalId )
        {
        iLog->Log( _L("Global category People ID mismatch: actual '%d', predefined '%d'"),
            idPeopleGlobal, KPeopleGlobalId );
        iErrorsFound++;
        }

    RArray<TPosLmItemId> lmIds;
    CleanupClosePushL( lmIds );
    FindLandmarksL( *db, idPeople, lmIds );
    if ( lmIds.Count() != 2 )
        {
        iLog->Log( _L("Global category People landmark list count mismatch: actual '%d', expected '%d'"),
            lmIds.Count(), 2 );
        iErrorsFound++;
        }
    CleanupStack::PopAndDestroy( &lmIds );

    // verify that those landmarks belong only to People
    RArray<TPosLmItemId> catIds;

    CPosLandmark* lmA = FindLandmarkLC( *db, KLmAName );
    lmA->GetCategoriesL( catIds );
    if ( catIds.Count() != 1 )
        {
        iLog->Log( _L("LmA: wrong category list count, actual '%d', expected '%d'"),
            catIds.Count(), 1 );
        iErrorsFound++;
        }
    if ( catIds.Count() && catIds[0] != idPeople )
        {
        iLog->Log( _L("LmB: wrong category in list, actual '%d', expected '%d'"),
            catIds[0], idPeople );
        iErrorsFound++;
        }
    catIds.Reset();
    CleanupStack::PopAndDestroy( lmA );

    CPosLandmark* lmB = FindLandmarkLC( *db, KLmBName );
    lmA->GetCategoriesL( catIds );
    if ( catIds.Count() != 1 )
        {
        iLog->Log( _L("LmB: wrong category list count, actual '%d', expected '%d'"),
            catIds.Count(), 1 );
        iErrorsFound++;
        }
    if ( catIds.Count() && catIds[0] != idPeople )
        {
        iLog->Log( _L("LmB: wrong category in list, actual '%d', expected '%d'"),
            catIds[0], idPeople );
        iErrorsFound++;
        }
    catIds.Reset();
    CleanupStack::PopAndDestroy( lmB );
    CleanupStack::PopAndDestroy( cat );
    
    // 6. Reset global categories and verify again
    iLog->Log(_L("6. Reset and verify globals"));
    ExecuteAndDeleteLD(catMan->ResetGlobalCategoriesL());
    
    iter = catMan->CategoryIteratorL();
    CleanupStack::PushL( iter );

    id = iter->NextL();
    while ( id != KPosLmNullItemId )
        {
        CPosLandmarkCategory* cat = catMan->ReadCategoryLC( id );
        TPosLmGlobalCategory globalId = cat->GlobalCategory();
        
        TPtrC name;
        cat->GetCategoryName( name );

        HBufC* globalName = catMan->GlobalCategoryNameL( globalId );
        if ( name.Compare( *globalName ) != 0 )
            {
            iLog->Log( _L("Global category %d name mismatch: actual '%S', predefined '%S'"),
                globalId, &name, globalName );
            iErrorsFound++;
            }
        delete globalName;
        CleanupStack::PopAndDestroy( cat );
        id = iter->NextL();
        }
    CleanupStack::PopAndDestroy( iter );

    CleanupStack::PopAndDestroy( catMan );
    CleanupStack::PopAndDestroy( db );
    
    if ( iErrorsFound > 0 )
        {
        iLog->Log(_L("Errors found in TP13 = %d"), iErrorsFound );
        User::Leave( KErrGeneral );
        }
#endif
	}

// ---------------------------------------------------------
// ---------------------------------------------------------
//
CPosLandmark* CPosTp13::FindLandmarkLC( CPosLandmarkDatabase& aDb, const TDesC& aName )
    {
    CPosLmTextCriteria* crit = CPosLmTextCriteria::NewLC();
    crit->SetTextL( aName );
    crit->SetAttributesToSearch( CPosLandmark::ELandmarkName );
    
    CPosLandmarkSearch* search = CPosLandmarkSearch::NewL( aDb );
    CleanupStack::PushL( search );
    
    CPosLmOperation* op = search->StartLandmarkSearchL( *crit );
    CleanupStack::PushL( op );
    op->ExecuteL();
    
    CPosLmItemIterator* iter = search->MatchIteratorL();
    CleanupStack::PushL( iter );
    RArray<TPosLmItemId> lmIds;
    iter->GetItemIdsL( lmIds, 0, iter->NumOfItemsL() );
    CleanupClosePushL( lmIds );
    
    if ( lmIds.Count() < 1 )
        {
        iLog->Log(_L("Couldn't find landmarks, which match name '%S'"), &aName );
        User::Leave( KErrNotFound );
        }
    else
        {
        iLog->Log(_L("Found %d landmarks, which match name '%S'"), lmIds.Count(), &aName );
        }
    
    CPosLandmark* lm = aDb.ReadLandmarkLC( lmIds[0] );
    CleanupStack::Pop();
    
    CleanupStack::PopAndDestroy( &lmIds );
    CleanupStack::PopAndDestroy( iter );
    CleanupStack::PopAndDestroy( op );
    CleanupStack::PopAndDestroy( search );
    CleanupStack::PopAndDestroy( crit );
    
    CleanupStack::PushL( lm );
    return lm;
    }

// ---------------------------------------------------------
// ---------------------------------------------------------
//
void CPosTp13::FindLandmarksL( 
    CPosLandmarkDatabase& aDb, 
    TPosLmItemId aCategoryId,  
    RArray<TPosLmItemId>& aLmIds )
    {
    CPosLmCategoryCriteria* crit = CPosLmCategoryCriteria::NewLC();
    crit->SetCategoryItemId( aCategoryId );
    
    CPosLandmarkSearch* search = CPosLandmarkSearch::NewL( aDb );
    CleanupStack::PushL( search );
    
    CPosLmOperation* op = search->StartLandmarkSearchL( *crit );
    CleanupStack::PushL( op );
    op->ExecuteL();
    
    CPosLmItemIterator* iter = search->MatchIteratorL();
    CleanupStack::PushL( iter );

    iter->GetItemIdsL( aLmIds, 0, iter->NumOfItemsL() );

    CleanupStack::PopAndDestroy( iter );
    CleanupStack::PopAndDestroy( op );
    CleanupStack::PopAndDestroy( search );
    CleanupStack::PopAndDestroy( crit );
    }

// ---------------------------------------------------------
// ---------------------------------------------------------
//
void CPosTp13::ListCategoriesL( CPosLmCategoryManager& aCatMan )
    {
    iLog->Log(_L("--- Global Categories ---"));

    CPosLmItemIterator* iter = aCatMan.CategoryIteratorL();
    CleanupStack::PushL(iter);
	TBuf<50> buffe;

    TPosLmItemId idde = iter->NextL();
    while (idde != KPosLmNullItemId)
        {       
        CPosLandmarkCategory* cat = aCatMan.ReadCategoryLC(idde);

        TPtrC name;
        cat->GetCategoryName(name);

        TPosLmGlobalCategory globalId = cat->GlobalCategory();

        TPtrC iconName;
        TInt iconNr;
        TInt iconMaskIndex;
        cat->GetIcon(iconName, iconNr, iconMaskIndex);
        
        iLog->Log(_L("Category %d, globalId %d, name '%S', icon {'%S',%d,%d}"),
            cat->CategoryId(), cat->GlobalCategory(), &name, &iconName, iconNr, iconMaskIndex );

        CleanupStack::PopAndDestroy(cat); 

        idde = iter->NextL();
        }
    CleanupStack::PopAndDestroy(iter);

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


//  End of File