/*

* Copyright (c) 2006 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: 

*       Encapsulates saving and removing email accounts

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <msvapi.h>                     // CMsvEntry

#include <cemailaccounts.h>             // CEmailAccounts

#include <smtpset.h>                    // CImSmtpSettings

#include <pop3set.h>                    // CImPop3Settings

#include <imapset.h>                    // CImImap4Settings

#include <iapprefs.h>                   // CImIAPPreferences

#include <muiumsvuiserviceutilitiesinternal.h>

#include <SendUiConsts.h>

#include "ImumInternalApiImpl.h"

#include "ImumMboxSymbianDataConverter.h"

#include "ImumMboxInternalDataConverter.h"

#include "ImumMboxManager.h"

#include "ImumInHealthServicesImpl.h"

#include "ImumMboxData.h"

#include "ImumMboxSettingsCtrl.h"

#include "IMSSettingsNoteUi.h"

#include "ImumUtilsLogging.h"

#include "EmailUtils.H"

#include "ImumPanic.h"

#include <mtudreg.h>

#include <muiumsvuiserviceutilitiesinternal.h>

#include <featmgr.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KImumMboxQueryTextLength    = 100;

const TInt KImumMboxArrayGranularity   = 4;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CImumMboxManager::CImumMboxManager()

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

//

CImumMboxManager::CImumMboxManager(

    CImumInternalApiImpl& aMailboxApi )

    :

    iMailboxApi( aMailboxApi ),

    iMboxSettingsCtrl( NULL ),

    iAccounts( NULL ),

    iCleaner( NULL )

    {

    }

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

// CImumMboxManager::ConstructL()

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

//

void CImumMboxManager::ConstructL()

    {

    IMUM_CONTEXT( CImumMboxManager::ConstructL, 0, KLogData );

    IMUM_IN();

    FeatureManager::InitializeLibL();

    iAccounts = CEmailAccounts::NewL();

    iMboxSettingsCtrl = CImumMboxSettingsCtrl::NewL( iMailboxApi );

    iCleaner = CImumInHealthServicesImpl::NewL( iMailboxApi );

    IMUM_OUT();

    }

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

// CImumMboxManager::~CImumMboxManager()

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

//

CImumMboxManager::~CImumMboxManager()

    {

    IMUM_CONTEXT( CImumMboxManager::~CImumMboxManager, 0, KLogData );

    IMUM_IN();

    FeatureManager::UnInitializeLib();

    delete iMboxSettingsCtrl;

    iMboxSettingsCtrl = NULL;

    delete iAccounts;

    iAccounts = NULL;

    delete iCleaner;

    iCleaner = NULL;

    IMUM_OUT();

    }

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

// CImumMboxManager::NewL()

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

//

CImumMboxManager* CImumMboxManager::NewL(

    CImumInternalApiImpl& aMailboxApi )

    {

    IMUM_STATIC_CONTEXT( CImumMboxManager::NewL, 0, utils, KLogData );

    IMUM_IN();

    CImumMboxManager* self = NewLC( aMailboxApi );

    CleanupStack::Pop( self );

    IMUM_OUT();

    return self;

    }

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

// CImumMboxManager::NewLC()

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

//

CImumMboxManager* CImumMboxManager::NewLC(

    CImumInternalApiImpl& aMailboxApi )

    {

    IMUM_STATIC_CONTEXT( CImumMboxManager::NewLC, 0, utils, KLogData );

    IMUM_IN();

    CImumMboxManager* self =

        new ( ELeave ) CImumMboxManager( aMailboxApi );

    CleanupStack::PushL( self );

    self->ConstructL();

    IMUM_OUT();

    return self;

    }

/******************************************************************************

    Static Functions

******************************************************************************/

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

// CImumMboxManager::GetIapPreferencesL()

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

//

TInt CImumMboxManager::GetIapPreferencesL(

    const TMsvId aMailboxId,

    CEmailAccounts& aAccounts,

    CImIAPPreferences& aIapPrefs,

    CImumInternalApiImpl& aMailboxApi,

    const TBool aSmtp )

    {

    IMUM_STATIC_CONTEXT( CImumMboxManager::GetIapPreferencesL, 0, utils, KLogData );

    IMUM_IN();

    TMsvEntry entry;

    // Get the correct part of the mailbox

    if ( aSmtp )

        {

        // Get SMTP part of the mailbox

        entry = aMailboxApi.MailboxUtilitiesL().GetMailboxEntryL(

            aMailboxId, MImumInMailboxUtilities::ERequestSending );

        // Define the account id

        TSmtpAccount smtpAccountId;

        smtpAccountId.iSmtpAccountId = entry.iMtmData2;

        // Load preferences

        aAccounts.LoadSmtpIapSettingsL( smtpAccountId, aIapPrefs );

        }

    else

        {

        // Get POP3 or IMAP4 part of the mailbox

        entry = aMailboxApi.MailboxUtilitiesL().GetMailboxEntryL(

            aMailboxId, MImumInMailboxUtilities::ERequestReceiving );

        // Load settings based on the mtm type

        if ( entry.iMtm.iUid == KSenduiMtmImap4UidValue )

            {

            // Define imap4 account id

            TImapAccount imapAccountId;

            imapAccountId.iImapAccountId = entry.iMtmData2;

            // Load preferences

            aAccounts.LoadImapIapSettingsL( imapAccountId, aIapPrefs );

            }

        else

            {

            // Define pop3 account id

            TPopAccount popAccountId;

            popAccountId.iPopAccountId = entry.iMtmData2;

            // Load preferences

            aAccounts.LoadPopIapSettingsL( popAccountId, aIapPrefs );

            }

        }

    IMUM_OUT();

    return KErrNone;

    }

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

// CImumMboxManager::SetIapPreferencesL()

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

//

TInt CImumMboxManager::SetIapPreferencesL(

    const TMsvId aMailboxId,

    CEmailAccounts& aAccounts,

    const CImIAPPreferences& aIapPrefs,

    CImumInternalApiImpl& aMailboxApi,

    const TBool aSmtp )

    {

    IMUM_STATIC_CONTEXT( CImumMboxManager::SetIapPreferencesL, 0, utils, KLogData );

    IMUM_IN();

    TMsvEntry entry;

    TInt error = KErrNone;

    // Get the correct part of the mailbox

    if ( aSmtp )

        {

        // Get SMTP part of the mailbox

        entry = aMailboxApi.MailboxUtilitiesL().GetMailboxEntryL(

            aMailboxId, MImumInMailboxUtilities::ERequestSending );

        // Define the account id

        TSmtpAccount smtpAccountId;

        smtpAccountId.iSmtpAccountId = entry.iMtmData2;

        // Load preferences

        aAccounts.SaveSmtpIapSettingsL( smtpAccountId, aIapPrefs );

        }

    else

        {

        // Get POP3 or IMAP4 part of the mailbox

        entry = aMailboxApi.MailboxUtilitiesL().GetMailboxEntryL(

            aMailboxId, MImumInMailboxUtilities::ERequestReceiving );

        // Load settings based on the mtm type

        if ( entry.iMtm.iUid == KSenduiMtmImap4UidValue )

            {

            // Define imap4 account id

            TImapAccount imapAccountId;

            imapAccountId.iImapAccountId = entry.iMtmData2;

            // Load preferences

            aAccounts.SaveImapIapSettingsL( imapAccountId, aIapPrefs );

            }

        else

            {

            // Define pop3 account id

            TPopAccount popAccountId;

            popAccountId.iPopAccountId = entry.iMtmData2;

            // Load preferences

            aAccounts.SavePopIapSettingsL( popAccountId, aIapPrefs );

            }

        }

    IMUM_OUT();

    return error;

    }

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

// CImumMboxManager::ForceAlwaysAskL()

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

//

void CImumMboxManager::ForceAlwaysAskL(

    const TMsvId aMailboxId,

    CEmailAccounts& aAccounts,

    CImIAPPreferences& aIapPrefs,

    CImumInternalApiImpl& aMailboxApi,

    const TBool aSmtp )

    {

    IMUM_STATIC_CONTEXT( CImumMboxManager::ForceAlwaysAskL, 0, utils, KLogData );

    IMUM_IN();

    aIapPrefs.RemoveIAPL( 0 );

    TImIAPChoice iap;

    iap.iDialogPref = ECommDbDialogPrefPrompt;

    iap.iIAP = 0;

    aIapPrefs.AddIAPL( iap );

    User::LeaveIfError( CImumMboxManager::SetIapPreferencesL(

        aMailboxId, aAccounts, aIapPrefs, aMailboxApi, aSmtp ) );

    IMUM_OUT();

    }

/******************************************************************************

    Manager tools

******************************************************************************/

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

// CImumMboxManager::CreateAccountFillIapL()

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

//

void CImumMboxManager::CreateAccountFillIapL(

    CImumMboxData& aSettings )

    {

    IMUM_CONTEXT( CImumMboxManager::CreateAccountFillIapL, 0, KLogData );

    IMUM_IN();

    // This is not ideal choice, but current situation forces to do this,

    // until Reset() funcion is exported from class CImIAPPreferences

    delete aSettings.iIncomingIapPref;

    aSettings.iIncomingIapPref = NULL;

    delete aSettings.iOutgoingIapPref;

    aSettings.iOutgoingIapPref = NULL;

    // Make sure the preferences are made

    if ( !aSettings.iIncomingIapPref )

        {

        aSettings.iIncomingIapPref = CImIAPPreferences::NewLC();

        CleanupStack::Pop( aSettings.iIncomingIapPref );

        }

    if ( !aSettings.iOutgoingIapPref )

        {

        aSettings.iOutgoingIapPref = CImIAPPreferences::NewLC();

        CleanupStack::Pop( aSettings.iOutgoingIapPref );

        }

    // Set incoming internet access point

    TImIAPChoice incomingIapChoice;

    incomingIapChoice.iIAP = aSettings.iIncomingIap;

    incomingIapChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

    aSettings.iIncomingIapPref->AddIAPL( incomingIapChoice );

    // Set outgoing internet access point

    TImIAPChoice outgoingIapChoice;

    outgoingIapChoice.iIAP = aSettings.iOutgoingIap;

    outgoingIapChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

    aSettings.iOutgoingIapPref->AddIAPL( outgoingIapChoice );

    IMUM_OUT();

    }

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

// CImumMboxManager::LoadAccountFillIapL()

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

//

void CImumMboxManager::LoadAccountFillIapL(

    CImumMboxData& aSettings )

    {

    IMUM_CONTEXT( CImumMboxManager::LoadAccountFillIapL, 0, KLogData );

    IMUM_IN();

    // Set internet access point (incoming IAP)

    TImIAPChoice incomingIapChoice =

        aSettings.iIncomingIapPref->IAPPreference( 0 );

    aSettings.iIncomingIap = incomingIapChoice.iIAP;

    // Set internet access point (Outgoing IAP)

    TImIAPChoice outgoingIapChoice =

        aSettings.iOutgoingIapPref->IAPPreference( 0 );

    aSettings.iOutgoingIap = outgoingIapChoice.iIAP;

    IMUM_OUT();

    }

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

// CImumMboxManager::DetermineDefaultAccountL()

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

//

void CImumMboxManager::DetermineDefaultAccountL(

    CImumMboxData& aSettings )

    {

    IMUM_CONTEXT( CImumMboxManager::DetermineDefaultAccountL, 0, KLogData );

    IMUM_IN();

    // First check if default account id is set

    aSettings.iDefaultAccountId =

        MsvUiServiceUtilitiesInternal::DefaultServiceForMTML(

            iMailboxApi.MsvSession(), KSenduiMtmSmtpUid, EFalse );

    // Set the newly created one as a default account

    if ( aSettings.iDefaultAccountId == KMsvUnknownServiceIndexEntryId )

        {

		if( !FeatureManager::FeatureSupported( KFeatureIdSelectableEmail ) ||

			!MsvUiServiceUtilitiesInternal::OtherEmailMTMExistL( 

			iMailboxApi.MsvSession(), aSettings.iMailboxId ) )

			{

            TSmtpAccount smtpAccountId;

            iAccounts->GetSmtpAccountL( aSettings.iMailboxId, smtpAccountId );

            iAccounts->SetDefaultSmtpAccountL( smtpAccountId );

			MsvUiServiceUtilitiesInternal::SetDefaultServiceForMTML(

					iMailboxApi.MsvSession(), KSenduiMtmSmtpUid, 

					aSettings.iMailboxId );

			aSettings.iDefaultAccountId = aSettings.iMailboxId;

			}

		}

    IMUM_OUT();

    }

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

// CImumMboxManager::RemoveAccountL()

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

//

void CImumMboxManager::RemoveAccountL(

    const CImumMboxData& aSettings )

    {

    IMUM_CONTEXT( CImumMboxManager::RemoveAccountL, 0, KLogData );

    IMUM_IN();

    // Delete Imap4 or Pop3 account

    if ( aSettings.iIsImap4 )

        {

        DeleteExtendedSettings( TIMAStorerParams(

            aSettings.iImap4AccountId.iImapAccountId, KSenduiMtmImap4Uid ) );

        DeleteBaseSettingsL( aSettings );

        }

    else

        {

        DeleteExtendedSettings( TIMAStorerParams(

            aSettings.iPop3AccountId.iPopAccountId, KSenduiMtmPop3Uid ) );

        DeleteBaseSettingsL( aSettings );

        }

    IMUM_OUT();

    }

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

// CImumMboxManager::RemoveAccountL()

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

//

void CImumMboxManager::RemoveAccountL(

    const TMsvEntry& aMailboxEntry, TBool aSilent )

    {

    IMUM_CONTEXT( CImumMboxManager::RemoveAccountL, 0, KLogData );

    IMUM_IN();

    if ( aSilent || AccountDeletionConditionsOkL( aMailboxEntry.Id() ) )

        {

        // Delete Imap4 or Pop3 account

        if ( aMailboxEntry.iMtm == KSenduiMtmImap4Uid )

            {

            DeleteExtendedSettings( TIMAStorerParams(

                aMailboxEntry.iMtmData2, KSenduiMtmImap4Uid ) );

            DeleteBaseSettingsL( aMailboxEntry.iMtmData2, ETrue );

            }

        else

            {

            DeleteExtendedSettings( TIMAStorerParams(

                aMailboxEntry.iMtmData2, KSenduiMtmPop3Uid ) );

            DeleteBaseSettingsL( aMailboxEntry.iMtmData2, EFalse );

            }

        }

    IMUM_OUT();

    }

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

// CImumMboxManager::RemoveAccountL()

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

//

void CImumMboxManager::RemoveAccountL(

    const TUint32 aRelatedAccountId,

    const TUid& aMtmId )

    {

    IMUM_CONTEXT( CImumMboxManager::RemoveAccountL, 0, KLogData );

    IMUM_IN();

    // First remove the extended settings, as this cannot leave

    DeleteExtendedSettings(

        TIMAStorerParams( aRelatedAccountId, aMtmId ) );

    // Delete Imap4 or Pop3 account

    DeleteBaseSettingsL(

        aRelatedAccountId, aMtmId == KSenduiMtmImap4Uid );

    IMUM_OUT();

    }

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

// CImumMboxManager::RemoveAccount()

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

//

void CImumMboxManager::RemoveAccount( const TMsvId aMailboxId, TBool aSilent )

    {

    IMUM_CONTEXT( CImumMboxManager::RemoveAccount, 0, KLogData );

    IMUM_IN();

    TMsvEntry entry;

    TRAPD( error, entry = iMailboxApi.MailboxUtilitiesL().GetMailboxEntryL(

        aMailboxId,

        MImumInMailboxUtilities::ERequestReceiving ) );

    if ( !error )

        {

        TRAP_IGNORE( RemoveAccountL( entry, aSilent ) );

        }

    IMUM_OUT();

    }

/******************************************************************************

    Account creation

******************************************************************************/