/*
* Copyright (c) 2002 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:  MuiuEmailTools implementation
*
*/



// INCLUDE FILES
#include <e32base.h>
#include <cemailaccounts.h>         // CEmailAccounts
#include <msvstd.h>                 // TEntry
#include <msvids.h>                 // KMsvUnknownServiceIndexEntryId
#include <msvstd.hrh>               // KUidMsvServiceEntryValue
#include <miuthdr.h>                // TMsvEmailEntry
#include <MtmExtendedCapabilities.hrh> // Capabilities
#include <mtclreg.h>                // CClientMtmRegistry
#include <mtclbase.h>               // CBaseMtm
#include <mtuireg.h>
#include <muiuemailtools.h>

// EXTERNAL DATA STRUCTURES
// EXTERNAL FUNCTION PROTOTYPES
// CONSTANTS
// MACROS
// LOCAL CONSTANTS AND MACROS
// MODULE DATA STRUCTURES
// LOCAL FUNCTION PROTOTYPES
// FORWARD DECLARATIONS

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

// ----------------------------------------------------------------------------
// MuiuEmailTools::SetDefaultSendingMailboxL()
// ----------------------------------------------------------------------------
//
EXPORT_C void MuiuEmailTools::SetDefaultSendingMailboxL(    
    const TMsvId aSendingMailboxId )
    {
    CEmailAccounts* account = CEmailAccounts::NewLC();
    
    // Store the id
	TSmtpAccount sendingId;
	account->GetSmtpAccountL( aSendingMailboxId, sendingId );
	account->SetDefaultSmtpAccountL( sendingId );   		       
    
    CleanupStack::PopAndDestroy( account );        
    }
    
// ----------------------------------------------------------------------------
// MuiuEmailTools::DefaultSendingMailboxL()
// ----------------------------------------------------------------------------
//
EXPORT_C TMsvId MuiuEmailTools::DefaultSendingMailboxL( 
    CMsvSession& aMsvSession,
    TUid& aMtmId )
    {        
    // In case of basic mail mtm's, force the smtp as a searchable mtm
    TMsvId serviceId = KMsvUnknownServiceIndexEntryId;
    
    // If Imap4, Pop3 or Smtp mailbox, use CEmailAccounts to check the
    // default service
    if ( MuiuEmailTools::IsMailMtm( aMtmId ) )
        {
        TInt result = KErrNone;
        TSmtpAccount smtpId;
        aMtmId = KSenduiMtmSmtpUid;
        
        // Solve the mystery of the default mailbox
        CEmailAccounts* account = CEmailAccounts::NewLC();
        TRAPD( error, result = account->DefaultSmtpAccountL( smtpId ) );                    
        if ( error != KErrNone || result != KErrNone )
            {
            // Getting the default mailbox didn't succeed, 
            // return unknown service
            smtpId.iSmtpService = KMsvUnknownServiceIndexEntryId;
            }
        
        CleanupStack::PopAndDestroy( account );
        account = NULL;
        
        serviceId = smtpId.iSmtpService;
        }
    else
        {
        serviceId = QueryDefaultServiceL( aMsvSession, aMtmId );
        }
    
    // After the service has been specified, make sure it is valid    
    if ( !ValidateMailboxL( aMsvSession, aMtmId, serviceId ) )
        {
        serviceId = KMsvUnknownServiceIndexEntryId;
        }    
        
    return serviceId;
    }

// ----------------------------------------------------------------------------
// MuiuEmailTools::FindFirstValidMailboxL()
// ----------------------------------------------------------------------------
//
TMsvId MuiuEmailTools::FindFirstValidMailboxL( 
    CMsvSession& aMsvSession,
    const CMsvEntrySelection& aSelection,
    const TUid& aMtmId )
    {
    TMsvId serviceId = KMsvUnknownServiceIndexEntryId;
    
    // Prepare the mtm store and get the MtmUi of the desired mtmId
    CClientMtmRegistry* registry = CClientMtmRegistry::NewL( aMsvSession );
    CleanupStack::PushL( registry );
    CBaseMtm* mtm = registry->NewMtmL( aMtmId );
    CleanupStack::PushL( mtm );
    CMtmUiRegistry* uiRegistry = CMtmUiRegistry::NewL( aMsvSession );
    CleanupStack::PushL( uiRegistry );
    CBaseMtmUi* smtpMtmUi = uiRegistry->NewMtmUiL( *mtm );
    CleanupStack::PushL( smtpMtmUi );
    
    // Query from the mtm, if it is able to validate the service
    if ( QueryCapability( 
        KUidMsvMtmQuerySupportValidateSelection, *smtpMtmUi ) )
        {
        const TInt count = aSelection.Count();
        for ( TInt index = 0; 
              index < count && serviceId == KMsvUnknownServiceIndexEntryId; 
              index++ )
            {
            TMsvId mailbox = aSelection.At( index );
            serviceId = QueryMailboxValidityL( mailbox, *smtpMtmUi ) > 0 ?
                mailbox : KMsvUnknownServiceIndexEntryId;
            }        
        }
        
    CleanupStack::PopAndDestroy( 4, registry ); // registry, mtm, uiRegistry, smtpMtmUi
    
    return serviceId;
    }
        
// ----------------------------------------------------------------------------
// MuiuEmailTools::IsMailMtm()
// ----------------------------------------------------------------------------
//
EXPORT_C TBool MuiuEmailTools::IsMailMtm( 
    const TUid& aMtm,
    const TBool aAllowExtended )
    {                   
    // Basic mail mtm's   
    TBool basicMtms = 
        ( aMtm == KSenduiMtmSmtpUid ) || 
        ( aMtm == KSenduiMtmPop3Uid ) || 
        ( aMtm == KSenduiMtmImap4Uid );
    // extended mail mtm's
    TBool extendedMtms =
        ( aMtm == KSenduiMtmSyncMLEmailUid );
            
    // Returns ETrue, if the id is any of the following
    return basicMtms || ( aAllowExtended && extendedMtms );
    }     

// ----------------------------------------------------------------------------
// MuiuEmailTools::GetMailboxServiceId()
// ----------------------------------------------------------------------------
//
EXPORT_C TInt MuiuEmailTools::GetMailboxServiceId(
    CMsvSession& aMsvSession,
    TMsvEntry& aMailbox,
    const TMsvId aMailboxId,    
    const TBool aGetSendingService )
    {
    // Get the entry based on mailbox id    
    TMsvId serviceId;            
    TInt error = aMsvSession.GetEntry( aMailboxId, serviceId, aMailbox );
    
    TInt32 mtm = aMailbox.iMtm.iUid;
    
    // Continue handling, if successful
    if ( error == KErrNone && 
         aMailbox.iType.iUid == KUidMsvServiceEntryValue && 
         IsMailMtm( aMailbox.iMtm ) )  
        {        
        // Get related entry, if:
        // Mailbox type is smtp and pop3 or imap4 is wanted OR
        // Mailbox type is pop3 or imap4 and smtp is wanted
        if ( aGetSendingService && mtm != KSenduiMtmSmtpUidValue || 
            !aGetSendingService && mtm == KSenduiMtmSmtpUidValue )
            {
            error = aMsvSession.GetEntry( aMailbox.iRelatedId, serviceId, aMailbox );
            }
        }

    return error;
    }    

// ----------------------------------------------------------------------------
// MuiuEmailTools::ValidateMailboxL()
// ----------------------------------------------------------------------------
//
TBool MuiuEmailTools::ValidateMailboxL( 
    CMsvSession& aMsvSession,
    const TUid& aMtmId,
    const TMsvId aMailboxId )
    {
    // Prepare the mtm store and get the MtmUi of the desired mtmId
    TBool validity = EFalse;

    CClientMtmRegistry* registry = CClientMtmRegistry::NewL( aMsvSession );
    CleanupStack::PushL( registry );
    CBaseMtm* mtm = registry->NewMtmL( aMtmId );
    CleanupStack::PushL( mtm );
    CMtmUiRegistry* uiRegistry = CMtmUiRegistry::NewL( aMsvSession );
    CleanupStack::PushL( uiRegistry );
    CBaseMtmUi* smtpMtmUi = uiRegistry->NewMtmUiL( *mtm );
    CleanupStack::PushL( smtpMtmUi );

    // Query from the mtm, if it is able to validate the service
    if ( QueryCapability( 
        KUidMsvMtmQuerySupportValidateSelection, *smtpMtmUi ) )
        {
        validity = QueryMailboxValidityL( aMailboxId, *smtpMtmUi ) > 0;
        }
        
    CleanupStack::PopAndDestroy( 4, registry ); // registry, mtm, uiRegistry, smtpMtmUi
    
    return validity;
    }
    
// ----------------------------------------------------------------------------
// MuiuEmailTools::QueryCapability()
// ----------------------------------------------------------------------------
//
TBool MuiuEmailTools::QueryCapability( const TInt aQuery, CBaseMtmUi& aMtmUi )
    {
    TInt response = EFalse;
    TUid capabilityId = TUid::Uid( aQuery ); 
    
    // Query the capability from the Mtm
    TInt error = aMtmUi.QueryCapability( capabilityId, response );
    
    // Result is ok, when no error has occurred
    return !error && response;
    }    

// ----------------------------------------------------------------------------
// MuiuEmailTools::QueryMailboxValidityL()
// ----------------------------------------------------------------------------
//
TInt MuiuEmailTools::QueryMailboxValidityL( 
    const TMsvId aMailboxId,
    CBaseMtmUi& aMtmUi )
    {
    CMsvEntrySelection* selection = new ( ELeave ) CMsvEntrySelection();
    CleanupStack::PushL( selection );
    selection->AppendL( aMailboxId );
    TPckgBuf<TInt> parameter = EFalse;    
    
    // Invoke mtm's sync function
    aMtmUi.InvokeSyncFunctionL( 
        KUidMsvMtmQuerySupportValidateSelection, *selection, parameter );

    CleanupStack::PopAndDestroy( selection );
        
    return ( parameter() == KErrNone );        
    }  
    
    
// ----------------------------------------------------------------------------
// MuiuEmailTools::QueryDefaultServiceL()
// ----------------------------------------------------------------------------
//
TMsvId MuiuEmailTools::QueryDefaultServiceL( 
    CMsvSession& aMsvSession, 
    const TUid& aMtmId )
    {
    TMsvId serviceId = KMsvUnknownServiceIndexEntryId;
    CClientMtmRegistry* registry = CClientMtmRegistry::NewL( aMsvSession );
    CleanupStack::PushL( registry );
    CBaseMtm* mtm = registry->NewMtmL( aMtmId );
    CleanupStack::PushL( mtm );
    TRAPD( error, serviceId = mtm->DefaultServiceL() );
    if( error != KErrNone )
        {
        serviceId = KMsvUnknownServiceIndexEntryId;
        }
        
    CleanupStack::PopAndDestroy( 2, registry ); 
    registry = NULL;
    mtm = NULL;
    
    return serviceId;
    }           
            
// End of File