/*

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

*  Version     : %version: 12.1.2 %

*

*/

#include "emailtrace.h"

#include <cemailaccounts.h>             // CEmailAccounts

#include <imapset.h>                    // CImImap4Settings

#include <SendUiConsts.h>

#include <e32property.h>

#include "ipssetdatamanager.h"

#include "ipssetdata.h"

// <cmail>

#include "ipssetutilsconsts.h"

// </cmail>

#include "ipssetdatastorer.h"

#include "ipssetutils.h"

#include "ipssetdatasignature.h"

#include "ipssetdataapi.h"

#include "ipsplgpropertywatcher.h"

#include "ipsplgcommon.h"

#include "CFSMailCommon.h"

const TInt KIpsSetManagerMaxCreTry = 10;

/* #ifdef _DEBUG <cmail>

_LIT( KMailboxCreationFailed, "IpsSettings - mbox creation failed");

#endif </cmail>*/

// <cmail>

const TInt KMaxBodyFetchSize = 999;

// </cmail>

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

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

// CIpsSetDataManager::CIpsSetDataManager()

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

//

CIpsSetDataManager::CIpsSetDataManager(

    CMsvSession& aSession )

    :

    iSession( aSession ),

    iStorer( NULL ),

    iAccounts( NULL )

    {

    FUNC_LOG;

    }

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

// CIpsSetDataManager::ConstructL()

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

//

void CIpsSetDataManager::ConstructL()

    {

    FUNC_LOG;

    iAccounts = CEmailAccounts::NewL();

    iStorer = CIpsSetDataStorer::NewL();

    }

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

// CIpsSetDataManager::~CIpsSetDataManager()

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

//

CIpsSetDataManager::~CIpsSetDataManager()

    {

    FUNC_LOG;

    delete iStorer;

    delete iAccounts;

    }

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

// CIpsSetDataManager::NewL()

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

//

CIpsSetDataManager* CIpsSetDataManager::NewL(

    CMsvSession& aSession )

    {

    FUNC_LOG;

    CIpsSetDataManager* self = NewLC( aSession );

    CleanupStack::Pop( self );

    return self;

    }

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

// CIpsSetDataManager::NewLC()

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

//

CIpsSetDataManager* CIpsSetDataManager::NewLC(

    CMsvSession& aSession )

    {

    FUNC_LOG;

    CIpsSetDataManager* self =

        new ( ELeave ) CIpsSetDataManager( aSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

    Manager tools

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

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

// CIpsSetDataManager::RemoveAccountL()

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

//

void CIpsSetDataManager::RemoveAccountL(

    const TMsvEntry& aMailbox )

    {

    FUNC_LOG;

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

    TInt error = iStorer->DeleteExtendedSettingsL( aMailbox );

    // Cleanup all global folders that might have entries belonging to the 

    CleanGlobalFoldersL( aMailbox );

    // Determine the account type

    if ( aMailbox.iMtm == KSenduiMtmImap4Uid )

        {

        // Remove the Imap4 account

        TImapAccount imap;

        iAccounts->GetImapAccountL( aMailbox.iServiceId, imap);

        iAccounts->DeleteImapAccountL( imap );

        }

    else

        {

        // Remove the Pop3 account

        TPopAccount pop;

        iAccounts->GetPopAccountL( aMailbox.iServiceId, pop);

        iAccounts->DeletePopAccountL( pop );

        }

    TSmtpAccount smtp;

    iAccounts->GetSmtpAccountL( aMailbox.iRelatedId, smtp);

    iAccounts->DeleteSmtpAccountL( smtp );

    }

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

// CIpsSetDataManager::CleanGlobalFoldersL()

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

//

void CIpsSetDataManager::CleanGlobalFoldersL( const TMsvEntry& aMailbox )

    {

    FUNC_LOG;

    CleanGlobalFolderL( KMsvGlobalOutBoxIndexEntryId, aMailbox );

    CleanGlobalFolderL( KMsvDraftEntryId, aMailbox );

    CleanGlobalFolderL( KMsvSentEntryId, aMailbox );

    }

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

// CIpsSetDataManager::CleanGlobalFolderL()

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

//

void CIpsSetDataManager::CleanGlobalFolderL( const TMsvId& aFolderId, const TMsvEntry& aMailbox )

    {

    FUNC_LOG;

    // delete possible entries from this folder that are related to the given mailbox

    CMsvEntry* cEntry = iSession.GetEntryL( aFolderId );

    CleanupStack::PushL( cEntry );

    CMsvEntrySelection* selection = cEntry->ChildrenL();

    CleanupStack::PushL( selection );

    for ( TInt ii = 0; ii < selection->Count(); ii++ )

        {

        TMsvEntry tEntry;

        TMsvId service;

        User::LeaveIfError( iSession.GetEntry( selection->At(ii), service, tEntry ) );

        if( tEntry.iServiceId == aMailbox.iRelatedId )

            {

            iSession.RemoveEntry( selection->At(ii) );

            }

        }

    CleanupStack::PopAndDestroy( selection );

    CleanupStack::PopAndDestroy( cEntry );

    }

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

    Account creation

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

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

// CIpsSetDataManager::CreateEmailAccount()

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

//

TInt CIpsSetDataManager::CreateEmailAccount(

    CIpsSetData&  aSettings ,

    const TBool aPopulateDefaults )

    {

    FUNC_LOG;

    TInt error = KErrNone;

    // If settings not ready, don't try to create

    if ( aSettings.IsOk() )

        {

        TBool creReady = EFalse;

        for ( TInt i = 0; i < KIpsSetManagerMaxCreTry && !creReady; i++ )

            {

        // Attempt to create the mailaccount

            error = KErrNone;

            TRAP( error, DoCreateEmailAccountL( 

                    aSettings, aPopulateDefaults ) );

            if ( error == KErrNone )

                {

                creReady = VerifyMailboxCreation( aSettings );

                }

            else

                {

                CleanInvalidMailbox( aSettings );

                }

            }

        if ( error == KErrNone && !creReady )

            {

            // mailbox not good, set return error;

            error = KErrGeneral;

            }

        // Creating mailbox has failed, delete entries and cenrep settings

        if ( error != KErrNone )

            {

            CleanInvalidMailbox( aSettings );

            }

        }

    return error;

    }

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

// CIpsSetDataManager::CleanInvalidMailbox()

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

//

TBool CIpsSetDataManager::VerifyMailboxCreation( const CIpsSetData& aSettings )

                {

    FUNC_LOG;

    TInt error = KErrNotFound;

    TMsvId mboxId = 0;

    TMsvId smtpId = 0;

    TUid mtmId = aSettings.Protocol();

    if ( mtmId == KSenduiMtmImap4Uid )

        {

        mboxId = aSettings.ImapAccount().iImapService;

        smtpId = aSettings.ImapAccount().iSmtpService;

                }

            else

                {

        mboxId = aSettings.PopAccount().iPopService;

        smtpId = aSettings.PopAccount().iSmtpService;

        }

                TMsvEntry mboxEntry;

    TMsvEntry smtpEntry;

    TMsvId dummy;

    error = iSession.GetEntry( mboxId, dummy, mboxEntry );

    if ( error == KErrNone )

        {

        error = iSession.GetEntry( smtpId, dummy, smtpEntry );

                }

    if ( error == KErrNone )

        {

        // check that related id is set

        if ( mboxEntry.iRelatedId != smtpEntry.Id() )

            {

            TRAP( error, SetRelatedIdL( mboxEntry.Id(), smtpEntry.Id() ) );

            }

        if ( error == KErrNone && 

                smtpEntry.iRelatedId != mboxEntry.Id() )

            {

            TRAP( error, SetRelatedIdL( smtpEntry.Id(), mboxEntry.Id() ) );

        }

        }

    TBool ret = EFalse;

    if ( error == KErrNone )

        {

        ret = ETrue;

        }

    else

        {

        CleanInvalidMailbox( aSettings );

        ret = EFalse;

        }

    return ret;

    }

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

// CIpsSetDataManager::SetRelatedIdL()

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

//

void CIpsSetDataManager::SetRelatedIdL( TMsvId aEntryId, TMsvId aRelatedId )

    {

    FUNC_LOG;

    CMsvEntry* centry = iSession.GetEntryL( aEntryId );

    CleanupStack::PushL( centry );

    TMsvEntry tentry = centry->Entry();

    tentry.iRelatedId = aRelatedId;

    centry->ChangeL( tentry );

    CleanupStack::PopAndDestroy( centry );

    centry = NULL;

    // make sure that id is really changed

    TMsvId dummy;

    TInt error = iSession.GetEntry( aEntryId, dummy, tentry );

    if ( error != KErrNone || tentry.iRelatedId != aRelatedId )

        {

        User::Leave( KErrNotFound );

        }

    }

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

// CIpsSetDataManager::CleanInvalidMailbox()

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

//

void CIpsSetDataManager::CleanInvalidMailbox( const CIpsSetData& aSettings )

    {

    FUNC_LOG;

    // Determine the account type

    TMsvId mboxId = 0;

    TUid mtmId = aSettings.Protocol();

    // <cmail>TUint32 accountId = 0;</cmail>

    if ( mtmId == KSenduiMtmImap4Uid )

        {

        // Remove the Imap4 account

        TImapAccount imap = aSettings.ImapAccount();

        mboxId = imap.iImapService;

        // <cmail>accountId = imap.iImapAccountId;</cmail>

        TRAP_IGNORE( iAccounts->DeleteImapAccountL( imap ) );

        }

    else

        {

        // Remove the Pop3 account

        TPopAccount pop = aSettings.PopAccount();

        mboxId = pop.iPopService;

        // <cmail>accountId = pop.iPopAccountId;</cmail>

        TRAP_IGNORE( iAccounts->DeletePopAccountL( pop ) );

        }

    TRAP_IGNORE( TInt error = iStorer->DeleteExtendedSettingsL(

        mboxId, mtmId ) );

    TRAP_IGNORE( iAccounts->DeleteSmtpAccountL( aSettings.SmtpAccount() ) ); 

    }

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

// CIpsSetDataManager::DoCreateEmailAccountL()

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

//

void CIpsSetDataManager::DoCreateEmailAccountL(

    CIpsSetData& aSettings,

    const TBool aPopulateDefaults )

    {

    FUNC_LOG;

    TUint32 id = 0;

    TUid mtmId;

    TMsvId mailboxId;

    // Check for imap4

    if ( aSettings.Protocol() == KSenduiMtmImap4Uid )

        {

        // Catch all the problems with account creation

        id = CreateImap4AccountL( aSettings, aPopulateDefaults );

        mtmId = KSenduiMtmImap4Uid;

        mailboxId = aSettings.ImapAccount().iImapService;

        }

    else

        {

        id = CreatePop3AccountL( aSettings, aPopulateDefaults );

        mtmId = KSenduiMtmPop3Uid;

        mailboxId = aSettings.PopAccount().iPopService;

        }

    CreateExtendedSettingsL( mailboxId, id, mtmId, aSettings );

    TRAPD( signerr, StoreSignatureL( aSettings ) );

    if ( signerr != KErrNone )

        {

        }

    StoreIMEIToMailbox( mailboxId );

    }

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

// CIpsSetDataManager::CreateImap4AccountL()

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

//

TUint32 CIpsSetDataManager::CreateImap4AccountL(

    CIpsSetData& aSettings,

    const TBool aPopulateDefaults,

    const TBool aReadOnly )

    {

    FUNC_LOG;

    // Populate defaults

    if ( aPopulateDefaults )

        {

        iAccounts->PopulateDefaultImapSettingsL(

            *aSettings.Imap4Settings(), *aSettings.IncomingIapPref() );

        iAccounts->PopulateDefaultSmtpSettingsL(

            *aSettings.SmtpSettings(), *aSettings.OutgoingIapPref() );

        }

    aSettings.Imap4Settings()->SetPathSeparator( '/' );

    aSettings.Imap4Settings()->SetUpdatingSeenFlags(ETrue);

    // Create the account

    aSettings.ImapAccount() = iAccounts->CreateImapAccountL(

        aSettings.MailboxName(), 

        *aSettings.Imap4Settings(), *aSettings.IncomingIapPref(), aReadOnly );

    aSettings.SmtpAccount() = iAccounts->CreateSmtpAccountL( 

        aSettings.ImapAccount(),

        *aSettings.SmtpSettings(), *aSettings.OutgoingIapPref(), aReadOnly );

    return aSettings.ImapAccount().iImapAccountId;

    }

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

// CIpsSetDataManager::CreatePop3AccountL()

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

//

TUint32 CIpsSetDataManager::CreatePop3AccountL(

    CIpsSetData& aSettings,

    const TBool aPopulateDefaults,

    const TBool aReadOnly )

    {

    FUNC_LOG;

    // Populate defaults

    if ( aPopulateDefaults )

        {

        iAccounts->PopulateDefaultPopSettingsL(

            *aSettings.Pop3Settings(), *aSettings.IncomingIapPref() );

        iAccounts->PopulateDefaultSmtpSettingsL(

            *aSettings.SmtpSettings(), *aSettings.OutgoingIapPref() );

        }

    // Create the account

    aSettings.PopAccount() = iAccounts->CreatePopAccountL(

        aSettings.MailboxName(),

        *aSettings.Pop3Settings(), *aSettings.IncomingIapPref(), aReadOnly );

    aSettings.SmtpAccount() = iAccounts->CreateSmtpAccountL( 

        aSettings.PopAccount(),

        *aSettings.SmtpSettings(), *aSettings.OutgoingIapPref(), aReadOnly );

    return aSettings.PopAccount().iPopAccountId;

    }

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

// CIpsSetDataManager::CreateExtendedSettingsL()

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

//

void CIpsSetDataManager::CreateExtendedSettingsL(

    const TMsvId aMailboxId,

    const TUint32 aAccountId,

    const TUid& aProtocol,

    CIpsSetData& aSettings,

    const TBool aPopulateDefaults )

    {

    FUNC_LOG;

    // If populating has been successful

    User::LeaveIfError( iStorer->CreateExtendedSettings(

        aMailboxId, aAccountId, aProtocol,

        *aSettings.ExtendedSettings(), aPopulateDefaults ) );

    }

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

// CIpsSetDataManager::StoreIMEIToMailbox()

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

//

TInt CIpsSetDataManager::StoreIMEIToMailbox(

    const TMsvId aMailboxId ) const

    {

    FUNC_LOG;

    // Get available mailbox entries

    TMsvEntry entry;    

    TInt result = IpsSetUtils::GetMailboxEntry( iSession, aMailboxId, entry );

    // Imap4 & Pop3 & Smtp protocols contain two entries

    if ( result == KErrNone )

        {

        // Attempt to store the IMEI code to the entry

        result = StoreIMEIToEntry( entry.Id() );       

        }

    // Imap4 / Pop3 protocols have two different entries

    if ( IpsSetUtils::IsMailMtm( entry.iMtm ) )

        {

        TMsvEntry secondaryEntry;

        result = IpsSetUtils::GetMailboxEntry( iSession, entry.iRelatedId, entry );

        if ( result == KErrNone ) 

            {

            // Attempt to store the IMEI code to the entry

            result = StoreIMEIToEntry( entry.Id() );

            }            

        }

    return result;

    }

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

// CIpsSetDataManager::StoreIMEIToEntry()

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

//

TInt CIpsSetDataManager::StoreIMEIToEntry( const TMsvId aMailboxId ) const

    {

    FUNC_LOG;

    TRAPD( error, GetAndStoreIMEIToEntryL( aMailboxId ) );

    return ( error == KErrNone ) ? KErrNone : KErrGeneral;

    }