/*
* Copyright (c) 2002-2009 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:    Base class landmarks list provider for listbox model
*
*/


// SYSTEM INCLUDES
#include <EPos_CPosLandmarkDatabase.h>
#include <EPos_CPosLmOperation.h>
#include <EPos_CPosLmCategoryManager.h>
#include <AknWaitDialog.h>

// USER INCLUDES
#include "CLmkLmItemListProvider.h"
#include "MLmkListProviderObserver.h"
#include "CLmkDbUtils.h"
#include "CLmkDbInitializer.h"
#include "CLmkEventListenerSingleton.h"
#include "CLmkAOOperation.h"
#include "LmkConsts.h"
#include <lmkerrors.h>

// CONSTANTS
/// Unnamed namespace for local definitions
namespace {

_LIT( KPanicMsg, "CLmkLmItemListProvider" );

void Panic( TPanicCode aReason )
    {
    User::Panic( KPanicMsg, aReason );
    }
}  // namespace

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

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::CLmkLmItemListProvider
// C++ constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CLmkLmItemListProvider::CLmkLmItemListProvider(
    CPosLandmarkDatabase& aDb )
    : iDb( aDb ),
      iListAllItemsInDb( ETrue ),
      iIdArray( KLmItemArrayGranularity ),
      iSelectedItemsCount( 0 ), iCount( 0 ),
      iRequestFromFindBox(EFalse),
      iOperationNotInUse( ETrue ),
      iOperationCmd( ELmkCmdStopOperation ),  //temp default value
      iSelectedForDelete(KLmItemArrayGranularity),
      iItemsToDelete( 0 ),
      iItemsDeleted( 0 ),
      iIsRemoveLandmarks( EFalse ),
      iCategoryId(KPosLmNullItemId)
    {
    }

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CLmkLmItemListProvider::BaseConstructL()
    {
    // Create db utils, request callback only when operations completed:
    iDbUtils = CLmkDbUtils::NewL( iDb, *this, EFalse );
    //Create landmark array, which will hold all those landmarks, which belong
    //to one category and needs icon change.
    iIconChangeLmkArray = new(ELeave) RPointerArray<CPosLandmark>;
    // base class 2nd phase constructor
    CLmkListProviderBase::BaseConstructL();
    }

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::~CLmkLmItemListProvider
// -----------------------------------------------------------------------------
//
CLmkLmItemListProvider::~CLmkLmItemListProvider()
    {
    if ( iWaitNote )
        {
        TRAPD( err, iWaitNote->ProcessFinishedL() );
        if (err != KErrNone)
    		{
		    delete iWaitNote;
            iWaitNote = NULL;
	    	}
        }
    // Stop db event observing:
    CLmkEventListenerSingleton::RemoveObserver( *this );
	if (iIconChangeLmkArray)
		{
		iIconChangeLmkArray->ResetAndDestroy();
    	delete iIconChangeLmkArray;
		}
    delete iInitializer;
    delete iDbUtils;

    iSelectedForDelete.Close();
    iIdArray.Close();
    }

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::SelectedIndexesL
// -----------------------------------------------------------------------------
//
EXPORT_C CArrayFix<TInt>* CLmkLmItemListProvider::SelectedIndexesL(
    const RArray<TPosLmItemId>& aSelectedItems ) const
    {
    CArrayFix<TInt>* array = NULL;
    TInt count = aSelectedItems.Count();
    if ( count < KLmkMultiSelectionGranularity )
        { // decent minimum granularity because of possible user selections
        array =
            new ( ELeave ) CArrayFixFlat<TInt>( KLmkMultiSelectionGranularity );
        }
    else
        {
        array = new ( ELeave ) CArrayFixFlat<TInt>( aSelectedItems.Count() );
        }
    CleanupStack::PushL( array );

    GetSelectedIndexesL( *array, aSelectedItems );

    CleanupStack::Pop( array );
    return array;
    }

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::GetSelectedIndexesL
// -----------------------------------------------------------------------------
//
EXPORT_C void CLmkLmItemListProvider::GetSelectedIndexesL(
    CArrayFix<TInt>& aSelectedIndexes,
    const RArray<TPosLmItemId>& aSelectedItems ) const
    {
    aSelectedIndexes.Reset();
    TInt count = aSelectedItems.Count();
    for ( TInt i( 0 ); i < count; ++i )
        {
        TInt index = iIdArray.Find( aSelectedItems[i] );
        if ( index >= 0 )
            { // item found --> append it's index
            aSelectedIndexes.AppendL( index );
            }
        }
    }

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::GetSelectedItemIdsL
// -----------------------------------------------------------------------------
//
EXPORT_C void CLmkLmItemListProvider::GetSelectedItemIdsL(
    RArray<TPosLmItemId>& aSelectedItems,
    const CArrayFix<TInt>& aSelectedIndexes ) const
    {
    aSelectedItems.Reset();
    TInt itemCount = iIdArray.Count();
    TInt selectionCount = aSelectedIndexes.Count();

    for ( TInt i( 0 ); i < selectionCount; ++i )
        {
        TInt index = aSelectedIndexes[i];
        __ASSERT_ALWAYS( index >= 0 && index < itemCount,
                         Panic( KLmkPanicInvalidIndex ) );

        User::LeaveIfError( aSelectedItems.Append( iIdArray[index] ) );
        }
    }

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::GetAllItemIdsL
// -----------------------------------------------------------------------------
//
EXPORT_C void CLmkLmItemListProvider::GetAllItemIdsL(
    RArray<TPosLmItemId>& aSelectedItems ) const
    {
    aSelectedItems.Reset();
    TInt itemCount = iIdArray.Count();

    for ( TInt i( 0 ); i < itemCount; ++i )
        {
        User::LeaveIfError( aSelectedItems.Append( iIdArray[i] ) );
        }
    }

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::SelectedIndex
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CLmkLmItemListProvider::SelectedIndex(
    TPosLmItemId aSelectedItem ) const
    {
    return iIdArray.Find( aSelectedItem );
    }

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::GetSelectedItemId
// -----------------------------------------------------------------------------
//
EXPORT_C void CLmkLmItemListProvider::GetSelectedItemId(
    TPosLmItemId& aSelected,
    TInt aIndex ) const
    {
    __ASSERT_ALWAYS( aIndex >= 0 && aIndex < iIdArray.Count(),
                     Panic( KLmkPanicInvalidIndex ) );

    aSelected = iIdArray[aIndex];
    }

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::SetSelectedItemsCount
// -----------------------------------------------------------------------------
//
EXPORT_C void CLmkLmItemListProvider::SetSelectedItemsCount( TInt aSelectedItemsCount )
	{
	iSelectedItemsCount = aSelectedItemsCount;
	}

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::RemoveItem
// -----------------------------------------------------------------------------
//
EXPORT_C void CLmkLmItemListProvider::RemoveItem( TPosLmItemId aItemId )
	{
   	TInt index = iIdArray.Find(aItemId);
   	if( index != KErrNotFound && index < iIdArray.Count())
   		{
   		iIdArray.Remove(index);
		NotifyObservers( ELmkEventListReady );
   		}
	}

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::RemoveItemsL
// -----------------------------------------------------------------------------
//
EXPORT_C void CLmkLmItemListProvider::RemoveItemsL(
											const RArray<TPosLmItemId>& aSelectedItems,
											MLmkAOOperationObserver::TOperationTypes aType,
											TPosLmItemId aCategoryId )
	{
	iCategoryId = aCategoryId;
	iType = aType;
	RemoveLandmarksL(aSelectedItems);
	}

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::SetOperationCmd
// -----------------------------------------------------------------------------
//
EXPORT_C void CLmkLmItemListProvider::SetOperationCmd( TLmkAppCmdId aOperationCmd )
	{
	iOperationCmd = aOperationCmd;
	}

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::InitializeL
// -----------------------------------------------------------------------------
//
void CLmkLmItemListProvider::InitializeL()
    {
    __ASSERT_DEBUG( !iInitializer, Panic( KLmkPanicIllegalMethodCall ) );
    // We don't want intermediate callbacks -> 3rd parameter EFalse
    iInitializer = CLmkDbInitializer::NewL( iDb, *this, EFalse );
    iInitializer->StartInitAndCompactL();
    }

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::StartSearchingLandmarksL()
// -----------------------------------------------------------------------------
//
TBool CLmkLmItemListProvider::StartSearchingLandmarksL(
								const TDesC& aSearchPattern,
    							TBool aSearchOnlyInPreviousMatches)
	{
	iRequestFromFindBox = ETrue;
	return PrepareListL(aSearchPattern, aSearchOnlyInPreviousMatches);
	}

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::ItemCount
// -----------------------------------------------------------------------------
//
TInt CLmkLmItemListProvider::ItemCount() const
    {
    return iIdArray.Count();
    }

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::HandleOperationL
// -----------------------------------------------------------------------------
//
void CLmkLmItemListProvider::HandleOperationL(
    TOperationTypes /*aType*/,
    TReal32 /*aProgress*/,
    TInt aStatus )
    {
    __ASSERT_DEBUG( aStatus != KPosLmOperationNotComplete,
                    Panic( KLmkPanicIntermediateCallback ) );

    // init and compact completed, delete unnecessary helper object:
    delete iInitializer;
    iInitializer = NULL;

    TInt err( aStatus );

    if ( aStatus == KErrNone )
        {
        TRAP( err, HandleDatabaseInitializedL() );
        }

    if ( err != KErrNone )
        { // Error already in aStatus or within this method
        HandleError( err );
        }
    }

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::HandleDatabaseInitializedL
// -----------------------------------------------------------------------------
//
void CLmkLmItemListProvider::HandleDatabaseInitializedL()
    {
    // Start db event observing:
    CLmkEventListenerSingleton::AddObserverL( *this, iDb );
    
    iRequestFromFindBox = EFalse;
    
    // Call provider-specific templated method for preparing list:
    PrepareListL();
    }

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::HandleError
// -----------------------------------------------------------------------------
//
void CLmkLmItemListProvider::HandleError( TInt aError )
    {
    if ( aError != KErrNone )
        {
        NotifyError( aError );
        }
    }

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::HandleDatabaseEvent
// -----------------------------------------------------------------------------
//
void CLmkLmItemListProvider::HandleDatabaseEvent( TPosLmEvent& aEvent )
    {
    switch ( aEvent.iEventType )
        {
        case EPosLmEventNewDefaultDatabaseLocation:
        case EPosLmEventMediaRemoved:
            {
            //TODO:
            break;
            }
        default:
            {
            //TODO:
            // not interesting event for this class
            break;
            }
        }
    }

// -----------------------------------------------------------------------------
// CLmkLmItemListProvider::GetLandmarkLC
// -----------------------------------------------------------------------------
//
CPosLandmark* CLmkLmItemListProvider::GetLandmarkLC(TInt aIndex)
	{
	RArray<TPosLmItemId> itemArray;
	CPosLandmark* landmark = iDb.ReadPartialLandmarkLC( iIdArray[aIndex] );
	//check whether landmark is associated with more than one cat.
	landmark->GetCategoriesL(itemArray);
	if (itemArray.Count() == 1)
		{
		//if associated with one cat, check if the icon is not set by the
		//user explicitly
		TPtrC iconPath;
	    TInt iconId;
	    TInt iconMaskIndex;
		if (landmark->GetIcon(iconPath,iconId,  iconMaskIndex))
	        {
	       	//lmk has one cat & icon is not set by the user:
			CPosLmCategoryManager* categoryMgr = CPosLmCategoryManager::NewL(iDb);
			CleanupStack::PushL( categoryMgr );
			CPosLandmarkCategory* category = categoryMgr->ReadCategoryLC( itemArray[0] );
			//get the cat icon and set it as landmark icon only for display
			if (category->GetIcon(iconPath,iconId,  iconMaskIndex) == KErrNone )
				{
				landmark->SetIconL(iconPath,iconId,iconMaskIndex);
				}
			CleanupStack::PopAndDestroy();//category
			CleanupStack::PopAndDestroy();//categoryMgr
	        }
		}
	itemArray.Close();
	return landmark;
	}
//  End of File