/*
* Copyright (c) 2008 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:  Definition of the class CPbkxRclSearchEngine.
*
*/


#include "emailtrace.h"
#include <coemain.h>
//<cmail>
#include "cfsccontactactionservice.h"
#include "mfsccontactaction.h"
#include "fscactionpluginactionuids.h"

#include "tfsccontactactionqueryresult.h"
//</cmail>
#include <CPbkContactEngine.h>
#include <CPbkContactItem.h>

#include <CVPbkContactStoreUriArray.h>
#include <TVPbkContactStoreUriPtr.h>
#include <CVPbkContactManager.h>
#include <MVPbkContactStore.h>
#include <MVPbkContactStoreList.h>
#include <MVPbkContactStoreProperties.h>
#include <MVPbkStoreContact.h>  // for RFscStoreContactList items

#include "cpbkxrclactionservicewrapper.h"
#include "pbkxrclengineconstants.h"
#include "cpbkxrclcontactconverter.h"


// Contact databases
_LIT(KRclDefaultCntDbURI, "cntdb://c:contacts.cdb");

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

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::NewL
// ---------------------------------------------------------------------------
//
CPbkxRclActionServiceWrapper* CPbkxRclActionServiceWrapper::NewL( 
    CPbkContactEngine& aContactEngine )
    {
    FUNC_LOG;
    CPbkxRclActionServiceWrapper* wrapper = new ( ELeave ) 
        CPbkxRclActionServiceWrapper( aContactEngine );
    CleanupStack::PushL( wrapper );
    wrapper->ConstructL();
    CleanupStack::Pop( wrapper );
    return wrapper;
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::CPbkxRclActionServiceWrapper
// ---------------------------------------------------------------------------
//
CPbkxRclActionServiceWrapper::CPbkxRclActionServiceWrapper( CPbkContactEngine& 
    aContactEngine ) : CBase(), iContactEngine( aContactEngine ) 
    {
    FUNC_LOG;
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::~CPbkxRclActionServiceWrapper
// ---------------------------------------------------------------------------
//
CPbkxRclActionServiceWrapper::~CPbkxRclActionServiceWrapper()
    {
    FUNC_LOG;
    
    iConvertedContact.ResetAndDestroy(); 
    
    if( iContactManager )
        {
        if ( iContactStore )
            {
            iContactStore->Close(*this);
            }
        } 
    delete iContactManager;
    delete iContactActionService;
    delete iContactConverter;    
    delete iWait;  
    
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::ConstructL
// ---------------------------------------------------------------------------
//
void CPbkxRclActionServiceWrapper::ConstructL()
    {
    FUNC_LOG;
    // Create Contact Manager
    CVPbkContactStoreUriArray* uriList = CVPbkContactStoreUriArray::NewLC();    
    uriList->AppendL( TVPbkContactStoreUriPtr( KRclDefaultCntDbURI ) );  
    iContactManager = CVPbkContactManager::NewL( *uriList, &(CCoeEnv::Static()->FsSession()) );
    CleanupStack::PopAndDestroy( uriList );
    
    // Get store list
    MVPbkContactStoreList& defaultstore = iContactManager->ContactStoresL();
    
    // Open contact store
    iContactStore = &defaultstore.At( 0 );
    iContactStore->OpenL( *this );   
    
    iContactActionService = CFscContactActionService::NewL( *iContactManager );
    
    iContactConverter = CPbkxRclContactConverter::NewL( 
            iContactEngine, *iContactManager, *iContactStore );
    
    iWait = new ( ELeave ) CActiveSchedulerWait();

    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::SetContactSelectorMode
// ---------------------------------------------------------------------------
//
void CPbkxRclActionServiceWrapper::SetContactSelectorMode( 
    TBool aContactSelectorMode )
    {
    FUNC_LOG;
    iContactSelectorMode = aContactSelectorMode;
    if ( aContactSelectorMode )
        {
        // in contact selector mode the flags are static

        // all actions except save as is queried 
        iFlags = KFscAtMan & ( ~KFscAtManSaveAs );
        }
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::SetActionMenuMode
// ---------------------------------------------------------------------------
//
void CPbkxRclActionServiceWrapper::SetActionMenuMode(
    TBool aActionMenuMode )
    {
    FUNC_LOG;
    // if not in contact selector mode, flags depend on whether
    // we are showing the action menu or not
    if ( !iContactSelectorMode )
        {
        if ( aActionMenuMode )
            {
            // in action menu mode poc and save as are disabled
            iFlags = KFscAtAll & ( ~KFscAtComCallPoc ) & ( ~KFscAtManSaveAs );
            }
        else
            {
            // when not in action menu mode, all actions but save as contact 
            // are enabled
            iFlags = KFscAtAll & ( ~KFscAtManSaveAs );
            }
        }
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::SetCurrentContactL
// ---------------------------------------------------------------------------
//
void CPbkxRclActionServiceWrapper::SetCurrentContactL( CPbkContactItem* aContactItem )
    {
    FUNC_LOG;

    iConvertedContact.ResetAndDestroy(); // clean before new use
    
    // Convert contact to MVPbkStoreContact object, only one item in 
    if ( aContactItem )
        {
        iContactConverter->ConvertContactL( *aContactItem, iConvertedContact );
        }

    iContactActionService->SetContactSetL( iConvertedContact );

    iSaveAsContactActionExists = EFalse;

    iQueryComplete = EFalse;
    // first query for save as contact
    iContactActionService->QueryActionsL( this, EFalse, KFscAtManSaveAs );

    // Wait async operation callback. If operation is completed before returning method call
    // don't start waiting
    if (!iQueryComplete)
        {
        iWait->Start();
        }
    
    const CFscContactActionList& actions = iContactActionService->QueryResults();

    // look for save as contact
    for ( TInt i = 0; i < actions.Count(); i++ )
        {
        const TFscContactActionQueryResult& result = actions[i];
        if ( result.iAction->Uid() == KFscActionUidSaveAsContact )
            {
            iSaveAsContactResult = TFscContactActionQueryResult(
                result.iAction, 
                result.iPriority,
                result.iActionMenuVisibility,
                result.iOptionsMenuVisibility );
            
            iSaveAsContactActionExists = ETrue;
            break;
            }
        }
    
    // Wait async operation callback. If operation is completed before returning method call
    // don't start waiting
    iQueryComplete = EFalse;
    iContactActionService->QueryActionsL( this, EFalse, iFlags );
    if (!iQueryComplete)
        {
        iWait->Start();
        } 
        
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::IsActionEnabled
// ---------------------------------------------------------------------------
//
TBool CPbkxRclActionServiceWrapper::IsActionEnabled( 
    const TUint64 aActionType ) const
    {
    FUNC_LOG;
    TBool enabled = EFalse;
    
    const TFscContactActionQueryResult* result = GetResult( aActionType );
    
    if ( result != NULL )
        {
        enabled = ( result->iOptionsMenuVisibility.iVisibility == 
        TFscContactActionVisibility::EFscActionVisible && 
                    result->iPriority >= 0 );
        }

    return enabled;
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::GetActionL
// ---------------------------------------------------------------------------
// 
const TFscContactActionQueryResult* CPbkxRclActionServiceWrapper::GetActionL(
        const TUint64 aActionType) const
    {    
    const CFscContactActionList& actions = iContactActionService->AllActionsListL( KFscAtAll );
           
    for ( TInt i = 0; i < actions.Count(); i++ )
        {
        const TFscContactActionQueryResult& queryResult = actions[i];
        if ( queryResult.iAction->Type() == aActionType )
            {
            return &queryResult;
            }
        }
    
    return NULL;
    }


// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::ExecuteActionL
// ---------------------------------------------------------------------------
//
void CPbkxRclActionServiceWrapper::ExecuteActionL( const TUint64 aActionType )
    {
    FUNC_LOG;
    const TFscContactActionQueryResult* result = GetActionL(aActionType);
    
    if ( result == NULL )
        {
        User::Leave( KErrNotFound );
        }
    
    iExecuteComplete = EFalse;
    iContactActionService->ExecuteL( result->iAction->Uid(), this );
    // Wait async operation callback. If operation is completed before returning method call
    // don't start waiting
    if (!iExecuteComplete)
        {
        iWait->Start();
        }     
   
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::ActionService
// ---------------------------------------------------------------------------
//
CFscContactActionService* CPbkxRclActionServiceWrapper::ActionService()
    {
    FUNC_LOG;
    return iContactActionService;
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::GetResult
// ---------------------------------------------------------------------------
//
const TFscContactActionQueryResult* CPbkxRclActionServiceWrapper::GetResult( 
    const TUint64 aType ) const
    {
    FUNC_LOG;
    if ( iSaveAsContactActionExists && aType == iSaveAsContactResult.iAction->Type() )
        {
        return &iSaveAsContactResult;
        }
    else
        {
        const CFscContactActionList& actions = iContactActionService->QueryResults();
        
        for ( TInt i = 0; i < actions.Count(); i++ )
            {
            const TFscContactActionQueryResult& queryResult = actions[i];
            if ( queryResult.iAction->Type() == aType )
                {
                return &queryResult;
                }
            }
        }
    return NULL;
    }
// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::ContactConverter
// ---------------------------------------------------------------------------
//
CPbkxRclContactConverter* CPbkxRclActionServiceWrapper::ContactConverter()
    {
    FUNC_LOG;
    return iContactConverter;
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::StoreReady
// ---------------------------------------------------------------------------
//
void CPbkxRclActionServiceWrapper::StoreReady( 
        MVPbkContactStore& /* aContactStore */ )
    {
    FUNC_LOG;
    iLastError = KErrNone;
    }
// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::StoreUnavailable()
// ---------------------------------------------------------------------------
//
void CPbkxRclActionServiceWrapper::StoreUnavailable( 
        MVPbkContactStore& /* aContactStore */, 
        TInt aReason )
    {
    FUNC_LOG;
    iLastError = aReason;
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::HandleStoreEventL()
// ---------------------------------------------------------------------------
//
void CPbkxRclActionServiceWrapper::HandleStoreEventL( 
        MVPbkContactStore& /* aContactStore */, 
        TVPbkContactStoreEvent /* aStoreEvent */ )
    {
    FUNC_LOG;
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::QueryActionsComplete()
// ---------------------------------------------------------------------------
//
void CPbkxRclActionServiceWrapper::QueryActionsComplete()
    {
    FUNC_LOG;
    iLastError = KErrNone;
    iQueryComplete = ETrue;
    if (iWait->IsStarted())
        {
        iWait->AsyncStop();
        }
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::QueryActionsFailed()
// ---------------------------------------------------------------------------
//
void CPbkxRclActionServiceWrapper::QueryActionsFailed( TInt aError )
    {
    FUNC_LOG;
    iLastError = aError;
    iQueryComplete = ETrue;
    if (iWait->IsStarted())
        {    
        iWait->AsyncStop();
        }
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::ExecuteComplete()
// ---------------------------------------------------------------------------
//
void CPbkxRclActionServiceWrapper::ExecuteComplete()
    {
    FUNC_LOG;
    iLastError = KErrNone;
    iExecuteComplete = ETrue;
    if (iWait->IsStarted())
        {    
        iWait->AsyncStop();
        }
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::ExecuteFailed()
// ---------------------------------------------------------------------------
//
void CPbkxRclActionServiceWrapper::ExecuteFailed( TInt aError )
    {
    FUNC_LOG;
    iLastError = aError;
    iExecuteComplete = ETrue;
    if (iWait->IsStarted())
        {
        iWait->AsyncStop();
        }
    }

// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::ExecuteFailed()
// ---------------------------------------------------------------------------
//
void CPbkxRclActionServiceWrapper::CancelQuery()
	{
    FUNC_LOG;
	iContactActionService->CancelQueryActions();
	if (iWait->IsStarted())
		{
		iWait->AsyncStop();
		}
	}

//RCL - Add
// ---------------------------------------------------------------------------
// CPbkxRclActionServiceWrapper::ContactManager()
// ---------------------------------------------------------------------------
//
CVPbkContactManager& CPbkxRclActionServiceWrapper::ContactManager()
    {
    return *iContactManager;
    }