/*

* Copyright (c) 2008-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:  Implementation of class CESMRContactMenuHandler.

*

*/

#include "emailtrace.h"

#include "cesmrcontactmenuhandler.h"

#include "cesmrcontactmenuurlhandler.h"

#include "mmrcontactmenuobserver.h"

//<cmail>

#include "cfsccontactactionservice.h"

#include "cfsccontactactionmenu.h"

#include "tfsccontactactionqueryresult.h"

#include "tfsccontactactionvisibility.h"

#include "mfsccontactaction.h"

#include "mfsccontactactionmenumodel.h"

#include <esmrgui.rsg>

#include "esmrcommands.h"

//</cmail>

#include <eikenv.h>

#include <eikmenup.h>

#include <commonphoneparser.h>

// <cmail> Removed profiling. </cmail>

/// Unnamed namespace for local definitions

namespace{ // codescanner::namespace

const TInt KGranularity( 8 );

}//namespace

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

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

// CESMRContactMenuHandler::CESMRContactMenuHandler( )

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

//

CESMRContactMenuHandler::CESMRContactMenuHandler( 

		CESMRContactManagerHandler& aContactManagerHandler ):

    iContactManagerHandler( aContactManagerHandler ), 

    iContactActionList( KGranularity )

    {

    FUNC_LOG;

    //do nothing

    }

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

// CESMRContactMenuHandler::NewL( )

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

//

CESMRContactMenuHandler* CESMRContactMenuHandler::NewL( 

		CESMRContactManagerHandler& aContactManagerHandler )

    {

    FUNC_LOG;

    CESMRContactMenuHandler* self = new (ELeave) CESMRContactMenuHandler( 

													aContactManagerHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRContactMenuHandler::ConstructL( )

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

//

void CESMRContactMenuHandler::ConstructL( )

    {

    FUNC_LOG;

    CVPbkContactManager& contactManager =

            iContactManagerHandler.GetContactManager();

    iContactActionService = CFscContactActionService::NewL( contactManager );

    iContactActionMenu = CFscContactActionMenu::NewL( *iContactActionService );

    iContactMenuUrlHandler

            = CESMRContactMenuUrlHandler::NewL( *iContactActionMenu );

    if ( iContactManagerHandler.IsReady() )

        {

        iContactManagerReady = ETrue;

        }

    else

        {

        iContactManagerHandler.AddObserverL ( this );

        }

    }

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

// CESMRContactMenuHandler::~CESMRContactMenuHandler( )

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

//

CESMRContactMenuHandler::~CESMRContactMenuHandler( )

    {

    FUNC_LOG;

    iStoreContactList.ResetAndDestroy();

    delete iFindResultsArray;

    delete iContactMenuUrlHandler;    

    delete iContactOperationBase;

    delete iContactActionMenu;

    delete iContactActionService;

    delete iValue;

    }

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

// CESMRContactMenuHandler::OptionsMenuAvailable( )

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

//

EXPORT_C TBool CESMRContactMenuHandler::OptionsMenuAvailable( )

    {

    FUNC_LOG;

    return iOptionsMenuReady || iContactMenuUrlHandler->OptionsMenuAvailable( );

    }

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

// CESMRContactMenuHandler::InitOptionsMenuL

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

//

EXPORT_C void CESMRContactMenuHandler::InitOptionsMenuL(

		CEikMenuPane* aActionMenuPane )

    {

    FUNC_LOG;

    switch ( iValueType )

        {

        case EValueTypeEmail: // Fall through

        case EValueTypePhoneNumber:

            {

            // Add actions to options / actions submenu

            const TInt count(iContactActionList.Count());

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

                {

                CEikMenuPaneItem::SData data;

                data.iFlags = 0;

                data.iCascadeId = 0;

                data.iCommandId = EESMRCmdActionMenuFirst + i;

                data.iText = iContactActionList[i].iAction->ActionMenuText();

                aActionMenuPane->AddMenuItemL( data );

                aActionMenuPane->SetItemDimmed( 

                		data.iCommandId,

                        iContactActionList[i].iOptionsMenuVisibility.iVisibility

                        == TFscContactActionVisibility::EFscActionDimmed );

                }

            break;

            }

        case EValueTypeURL:

            {

            iContactMenuUrlHandler->InitOptionsMenuL( aActionMenuPane );

            break;

            }  

        default:

            {

            break;

            }

        }

    }

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

// CESMRContactMenuHandler::ExecuteOptionsMenuL

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

//

EXPORT_C void CESMRContactMenuHandler::ExecuteOptionsMenuL( TInt aCommand )

    {

    FUNC_LOG;

    switch ( iValueType )

        {

        case EValueTypeEmail: // Fall through

        case EValueTypePhoneNumber:

            {

            TInt index = aCommand - EESMRCmdActionMenuFirst;

            if ( index >= 0 && index < iContactActionList.Count() )

                {

                TUid uid = iContactActionList[index].iAction->Uid();

                iContactActionService->ExecuteL( uid, this );

                }

            break;

            }

        case EValueTypeURL:

            {

            iContactMenuUrlHandler->ExecuteOptionsMenuL( aCommand );

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// CESMRContactMenuHandler::Reset( )

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

//

EXPORT_C void CESMRContactMenuHandler::Reset( )

    {

    FUNC_LOG;

    delete iContactOperationBase;

    iContactOperationBase = NULL;

    delete iFindResultsArray;

    iFindResultsArray = NULL;

    iContactMenuUrlHandler->Reset();

    iContactActionMenu->Model().RemoveAll();

    delete iValue;

    iValue = NULL;

    iValueType = EValueTypeNone;

    iContactActionList.Reset();

    iStoreContactList.ResetAndDestroy();

    iActionMenuReady = EFalse;

    iOptionsMenuReady = EFalse;

    }

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

// CESMRContactMenuHandler::SetValueL

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

//

EXPORT_C void CESMRContactMenuHandler::SetValueL(

        const TDesC& aValue, TValueType aValueType )

    {

    FUNC_LOG;

    Reset();

    if ( aValueType == EValueTypeURL )

        {

        iContactMenuUrlHandler->SetUrlL( aValue );

        iValueType = aValueType;

        }

    else if ( aValueType != EValueTypeNone )

        {

        iValue = aValue.AllocL();

        iValueType = aValueType;

        if ( iContactManagerReady )

            {

            SearchContactL();

            }

        }

    }

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

// CESMRContactMenuHandler::SetContactMenuObserver()

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

//

EXPORT_C void CESMRContactMenuHandler::SetContactMenuObserver(

        MMRContactMenuObserver* aObserver )

    {

    iContactMenuObserver = aObserver;

    }

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

// CESMRContactMenuHandler::SetCommandObserver()

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

//

EXPORT_C void CESMRContactMenuHandler::SetCommandObserver(

            MEikCommandObserver* aCommandObserver )

    {

    FUNC_LOG;

    iCommandObserver = aCommandObserver;

    }

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

// CESMRContactMenuHandler::ShowActionMenuL( )

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

//

EXPORT_C void CESMRContactMenuHandler::ShowActionMenuL( )

    {

    FUNC_LOG;

    if ( iValueType == EValueTypeURL )

        {

        iContactMenuUrlHandler->ShowActionMenuL();

        }  

    else if ( iActionMenuReady )

        {

        iContactActionMenu->ExecuteL( );

        }

    }

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

// CESMRContactMenuHandler::VerifyContactDetailsL

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

//

void CESMRContactMenuHandler::VerifyContactDetailsL()

    {

    FUNC_LOG;

    if ( iFindResultsArrayIndex < iFindResultsArray->Count() )

        {

        CVPbkContactManager& contactManager =

                iContactManagerHandler.GetContactManager();

        iContactOperationBase =

            contactManager.RetrieveContactL( 

            		iFindResultsArray->At( iFindResultsArrayIndex ), 

            		*this );

        }

    else

        {

        delete iFindResultsArray;

        iFindResultsArray = NULL;

        if ( iStoreContactList.Count() > 0 )

            {

            iContactActionService->SetContactSetL( iStoreContactList );

            iContactActionService->QueryActionsL( this );

            }

        else

            {

            CreateContactL ( );

            }

        }

    }

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

// CESMRContactMenuHandler::ContactManagerReady( )

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

//

void CESMRContactMenuHandler::ContactManagerReady( )

    {

    FUNC_LOG;

    iContactManagerReady = ETrue;

    iContactManagerHandler.RemoveObserver( this );

    if ( iValue )

        {

        TRAP_IGNORE( SearchContactL() );

        }

    }

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

// CESMRContactMenuHandler::VPbkSingleContactOperationComplete

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

//

void CESMRContactMenuHandler::VPbkSingleContactOperationComplete(

        MVPbkContactOperationBase& /*aOperation*/,

        MVPbkStoreContact* aContact )

    {

    FUNC_LOG;

    delete iContactOperationBase;

    iContactOperationBase = NULL;

    MVPbkStoreContactFieldCollection& fieldCollection =

        aContact->Fields();

    TBool valueMatchFound = EFalse;

    const TInt count(fieldCollection.FieldCount());

    for ( TInt i = 0; valueMatchFound == EFalse && i < count; ++i )

        {

        MVPbkStoreContactField& contactField = fieldCollection.FieldAt( i );

        MVPbkContactFieldData& fieldData = contactField.FieldData();

        if ( fieldData.DataType() == EVPbkFieldStorageTypeText )

            {

            MVPbkContactFieldTextData& fieldTextData =

                MVPbkContactFieldTextData::Cast( fieldData );

            if ( fieldTextData.Text().CompareF( *iValue ) == 0 )

                {

                valueMatchFound = ETrue;

                }

            }

        }

    if ( valueMatchFound )

        {

        TRAP_IGNORE( iStoreContactList.AppendL( aContact ) );

        }

    else

        {

        delete aContact;

        }

    ++iFindResultsArrayIndex;

    TRAPD( err, VerifyContactDetailsL() );

    if ( err != KErrNone )

        {

        Reset();

        }

    }

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

// CESMRContactMenuHandler::VPbkSingleContactOperationFailed

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

//

void CESMRContactMenuHandler::VPbkSingleContactOperationFailed(

        MVPbkContactOperationBase& /*aOperation*/,

        TInt /*aError*/ )

    {

    FUNC_LOG;

    delete iContactOperationBase;

    iContactOperationBase = NULL;

    ++iFindResultsArrayIndex;

    TRAPD( err, VerifyContactDetailsL() );

    if ( err != KErrNone )

        {

        Reset();

        }

    }

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

// CESMRContactMenuHandler::FindCompleteL

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

//

void CESMRContactMenuHandler::FindCompleteL( MVPbkContactLinkArray* aResults )

    {

    FUNC_LOG;

    delete iContactOperationBase;

    iContactOperationBase = NULL;

    iStoreContactList.ResetAndDestroy();

    iFindResultsArray = aResults;

    iFindResultsArrayIndex = 0;

    VerifyContactDetailsL();

    }

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

// CESMRContactMenuHandler::FindFailed

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

//

void CESMRContactMenuHandler::FindFailed( TInt /*aError*/)

    {

    FUNC_LOG;

    delete iContactOperationBase;

    iContactOperationBase = NULL;

    Reset ( );

    }

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

// CESMRContactMenuHandler::QueryActionsComplete( )

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

//

void CESMRContactMenuHandler::QueryActionsComplete( )

    {

    FUNC_LOG;

    const CFscContactActionList& actionList =

            iContactActionService->QueryResults();

    // Add visible actions to local contact action list for

    // options menu / actions.

    const TInt count(actionList.Count());

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

        {

        TFscContactActionVisibility::TVisibility visibility =

                actionList[i].iOptionsMenuVisibility.iVisibility;

        if ( visibility == TFscContactActionVisibility::EFscActionVisible ||

             visibility == TFscContactActionVisibility::EFscActionDimmed )

            {

            TRAP_IGNORE( iContactActionList.AppendL( actionList.At(i) ) );

            }

        }

    const TInt count2(iContactActionList.Count());

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

        {

        iContactActionList[i].iPriority = -iContactActionList[i].iPriority;

        }

    // Sort local list of actions by priority.

    TKeyArrayFix sortKey( _FOFF( TFscContactActionQueryResult, // codescanner::foff

                                 iPriority ),

                          ECmpTInt);

    iContactActionList.Sort( sortKey );

    // Enable options menu / actions if there are actions available.

    iOptionsMenuReady = iContactActionList.Count() > 0;

    // Initialize contact action menu and enable it.

    TRAPD( error, iContactActionMenu->Model().AddPreQueriedCasItemsL ( ) );

    if ( error != KErrNone )

        {

        iActionMenuReady = EFalse;

        }

    else

        {

        iActionMenuReady = ETrue;

        }

    if ( iContactMenuObserver )

        {

        iContactMenuObserver->ContactActionQueryComplete();

        }

    }

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

// CESMRContactMenuHandler::QueryActionsFailed

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

//

void CESMRContactMenuHandler::QueryActionsFailed( TInt /*aError*/)

    {

    FUNC_LOG;

    Reset();