/*

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

*

*/

#include <etelmm.h>

#include <msvapi.h>

#include "engine.h"

#include "enginewrapper.h"

#include "creator_mailbox.h" 

#include "creator_traces.h"

static const TInt KMailboxesFieldLength = 160;

_LIT(KCreatorMailboxesPrefixName, "CR_");

_LIT(KDefaultIncomingServer, "mail.example.com");

_LIT(KDefaultOutgoingServer, "smtp.example.com");

_LIT(KInternet, "internet");

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

CMailboxesParameters::CMailboxesParameters()

    {

    LOGSTRING("Creator: CMailboxesParameters::CMailboxesParameters");

    iIncomingPort = KUndef;

    iOutgoingPort = KUndef;

    iMaxEmailSize = KUndef;

    iSyncRate = KUndef;

    iAttachmentFetchSize = KUndef;

    iAttachmentSizeLimit = KUndef;

    iBodyTextSizeLimit = KUndef;

    iAttachmentFetchSize = KUndef;

    iInboxSyncLimit = -1; // -1 = All

    iMailboxSyncLimit = -1; // -1 = All    

    iToCCIncludeLimit = KUndef;

    iImapIdleTimeout = KUndef;

    /*iMailboxName = HBufC::New(KMailboxesFieldLength);

    iAccessPoint = HBufC::New(KMailboxesFieldLength);

    iMyMailAddress = HBufC::New(KMailboxesFieldLength);

    iOutgoingMailServer = HBufC::New(KMailboxesFieldLength);

    iUserName = HBufC::New(KMailboxesFieldLength);

    iPassword = HBufC::New(KMailboxesFieldLength);

    iIncomingMailServer = HBufC::New(KMailboxesFieldLength);*/

    }

CMailboxesParameters::~CMailboxesParameters()

    {

    LOGSTRING("Creator: CMailboxesParameters::~CMailboxesParameters");

    /*delete iIncomingMailServer;

    delete iPassword;

    delete iUserName;

    delete iOutgoingMailServer;

    delete iMyMailAddress;

    delete iAccessPoint;

    delete iMailboxName;*/

    delete iMailboxName;

    delete iIncomingLoginName;

    delete iIncomingPassword;

    delete iIncomingServerName;

    delete iIncomingConnectionMethod;

    delete iIncomingFolderPath;

    delete iPathSeparator;

    delete iOutgoingLoginName;

    delete iOutgoingPassword;

    delete iOutgoingServerName;

    delete iOutgoingConnectionMethod;

    delete iOwnEmailAddress;

    delete iOwnEmailAlias;

    delete iReceiptAddress;

    delete iReplyToAddress;

    }

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

CCreatorMailboxes* CCreatorMailboxes::NewL(CCreatorEngine* aEngine)

    {

    CCreatorMailboxes* self = CCreatorMailboxes::NewLC(aEngine);

    CleanupStack::Pop(self);

    return self;

    }

CCreatorMailboxes* CCreatorMailboxes::NewLC(CCreatorEngine* aEngine)

    {

    CCreatorMailboxes* self = new (ELeave) CCreatorMailboxes;

    CleanupStack::PushL(self);

    self->ConstructL(aEngine);

    return self;

    }

CCreatorMailboxes::CCreatorMailboxes()

    {    

    }

void CCreatorMailboxes::ConstructL(CCreatorEngine* aEngine)

    {

    LOGSTRING("Creator: CCreatorMailboxes::ConstructL");

    iEngine = aEngine;

    }

CCreatorMailboxes::~CCreatorMailboxes()

    {

    LOGSTRING("Creator: CCreatorMailboxes::~CCreatorMailboxes");

    if ( iEngine && iEntryIds.Count() )

        {

        TRAP_IGNORE( iEngine->WriteEntryIdsToStoreL( iEntryIds, KUidDictionaryUidMailbox ) );

        }

    iEntryIds.Reset();

    iEntryIds.Close();

    if (iParameters)

        delete iParameters;

    }

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

TBool CCreatorMailboxes::AskDataFromUserL(TInt aCommand)

    {

    LOGSTRING("Creator: CCreatorMailboxes::AskDataFromUserL");

    CCreatorModuleBase::AskDataFromUserL( aCommand );//ignore retval

    if ( aCommand == ECmdDeleteMailboxes )

        {

        return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all mailboxes?"), this, ECreatorModuleDelete );

        }

    else if ( aCommand ==  ECmdDeleteCreatorMailboxes )

        {

        return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all mailboxes created with Creator?"), this, ECreatorModuleDelete );

        }

    return iEngine->GetEngineWrapper()->EntriesQueryDialog( &iEntriesToBeCreated, _L("How many entries to create?"), EFalse, this, ECreatorModuleStart );

    }

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

TInt CCreatorMailboxes::CreateMailboxEntryL(CMailboxesParameters *aParameters)

    {

    LOGSTRING("Creator: CCreatorMailboxes::CreateMailboxEntryL");

      // clear any existing parameter definations

    delete iParameters;

    iParameters = NULL;

    CMailboxesParameters* parameters = aParameters;

    // random data needed if no predefined data available

    if (!parameters)

        {

        iParameters = new(ELeave) CMailboxesParameters;

        parameters = iParameters;

        TPtrC company(iEngine->RandomString(CCreatorEngine::ECompany));

        TPtrC firstName(iEngine->RandomString(CCreatorEngine::EFirstName));

        delete parameters->iMailboxName;

        parameters->iMailboxName = 0;

        parameters->iMailboxName = HBufC::NewL(KMailboxesFieldLength);

        parameters->iMailboxName->Des() = KCreatorMailboxesPrefixName;

        parameters->iMailboxName->Des().Append( company );

        parameters->iMailboxName->Des().Append(_L(" #"));

        parameters->iMailboxName->Des().AppendNum(iEngine->RandomNumber(1, 100));

        delete parameters->iIncomingLoginName;

        parameters->iIncomingLoginName = 0;

        parameters->iIncomingLoginName = HBufC::NewL(KMailboxesFieldLength); 

        delete parameters->iOutgoingLoginName;

        parameters->iOutgoingLoginName = 0;

        parameters->iOutgoingLoginName = HBufC::NewL(KMailboxesFieldLength); 

        parameters->iIncomingLoginName->Des() = iEngine->RandomString(CCreatorEngine::EFirstName);

        parameters->iIncomingLoginName->Des().LowerCase();

        parameters->iOutgoingLoginName->Des().Copy(parameters->iIncomingLoginName->Des());

        delete parameters->iIncomingPassword;

        parameters->iIncomingPassword = 0;

        parameters->iIncomingPassword = HBufC::NewL(KMailboxesFieldLength); 

        delete parameters->iOutgoingPassword;

        parameters->iOutgoingPassword = 0;

        parameters->iOutgoingPassword = HBufC::NewL(KMailboxesFieldLength); 

        parameters->iIncomingPassword->Des() = iEngine->RandomString(CCreatorEngine::ESurname);

        parameters->iIncomingPassword->Des().LowerCase();

        parameters->iOutgoingPassword->Des().Copy(parameters->iIncomingPassword->Des());

        delete parameters->iIncomingServerName;

        parameters->iIncomingServerName = 0;

        parameters->iIncomingServerName = HBufC::NewL(KMailboxesFieldLength); 

        parameters->iIncomingServerName->Des() = _L("incoming.");

        parameters->iIncomingServerName->Des().Append(company);

        parameters->iIncomingServerName->Des().Append(_L(".com"));

        parameters->iIncomingServerName->Des().LowerCase();

        delete parameters->iIncomingConnectionMethod;

        parameters->iIncomingConnectionMethod = 0;

        parameters->iIncomingConnectionMethod = HBufC::NewL(KInternet().Length());

        parameters->iIncomingConnectionMethod->Des() = KInternet;  // use always this one, if it's not found, default will be used instead

        delete parameters->iOutgoingServerName;

        parameters->iOutgoingServerName = 0;

        parameters->iOutgoingServerName = HBufC::NewL(KMailboxesFieldLength); 

        parameters->iOutgoingServerName->Des() = _L("smtp.");

        parameters->iOutgoingServerName->Des().Append(company);

        parameters->iOutgoingServerName->Des().Append(_L(".com"));

        parameters->iOutgoingServerName->Des().LowerCase();

        delete parameters->iOutgoingConnectionMethod;

        parameters->iOutgoingConnectionMethod = 0;

        parameters->iOutgoingConnectionMethod = HBufC::NewL(KInternet().Length());

        parameters->iOutgoingConnectionMethod->Des() = KInternet;  // use always this one, if it's not found, default will be used instead

        delete parameters->iOwnEmailAddress;

        parameters->iOwnEmailAddress = 0;

        parameters->iOwnEmailAddress = iEngine->CreateEmailAddressLC();

        parameters->iOwnEmailAddress->Des().LowerCase();

        CleanupStack::Pop(); // parameters->iOwnEmailAddress

        delete parameters->iOwnEmailAlias;

        parameters->iOwnEmailAlias = 0;

        parameters->iOwnEmailAlias = HBufC::NewL(firstName.Length());        

        parameters->iOwnEmailAlias->Des().Copy(firstName);       

        delete parameters->iReceiptAddress;

        parameters->iReceiptAddress = 0;

        parameters->iReceiptAddress = iEngine->CreateEmailAddressLC();

        parameters->iReceiptAddress->Des().LowerCase();

        CleanupStack::Pop(); // parameters->iReceiptAddress

        delete parameters->iReplyToAddress;

        parameters->iReplyToAddress = 0;

        parameters->iReplyToAddress = iEngine->CreateEmailAddressLC();

        parameters->iReplyToAddress->Des().LowerCase();

        CleanupStack::Pop(); // parameters->iReplyToAddress

        parameters->iIncomingSSLWrapper = iEngine->RandomNumber(0, 1);

        parameters->iIncomingSecureSockets = iEngine->RandomNumber(0, 1);        

        parameters->iAcknowledgeReceipts = iEngine->RandomNumber(0, 1);

        parameters->iAutoSendOnConnect = iEngine->RandomNumber(0, 1);

        parameters->iDeleteEmailsAtDisconnect = iEngine->RandomNumber(0, 1);

        parameters->iImapIdleCommand = iEngine->RandomNumber(0, 1);

        parameters->iMarkSeenInSync = iEngine->RandomNumber(0, 1);

        parameters->iEnableExpungeMode = iEngine->RandomNumber(0, 1);

        parameters->iUseApop = iEngine->RandomNumber(0, 1);

        parameters->iDisconnectedUserMode = iEngine->RandomNumber(0, 1);                

        parameters->iOutgoingSSLWrapper = iEngine->RandomNumber(0, 1);

        parameters->iOutgoingSecureSockets = iEngine->RandomNumber(0, 1);

        parameters->iIncludeSignature = EFalse;

        parameters->iAddVCard = EFalse;

        parameters->iRequestReceipts = iEngine->RandomNumber(0, 1);

        parameters->iSmtpAuth = iEngine->RandomNumber(0, 1);

        parameters->iIncomingPort = iEngine->RandomNumber(25, 500);

        parameters->iAttachmentSizeLimit = iEngine->RandomNumber(1, KMaxTInt);

        parameters->iBodyTextSizeLimit = iEngine->RandomNumber(1, KMaxTInt);

        parameters->iAttachmentFetchSize = iEngine->RandomNumber(1, 40960);

        parameters->iImapIdleTimeout = iEngine->RandomNumber(10, 2000);

        parameters->iMaxEmailSize = iEngine->RandomNumber(1024, KMaxTInt);

        parameters->iSyncRate = iEngine->RandomNumber(10, 500);        

        parameters->iInboxSyncLimit = iEngine->RandomNumber(-1, 256);

        parameters->iMailboxSyncLimit = iEngine->RandomNumber(-1, 256);

        parameters->iOutgoingPort = KDefaultSmtpPort;

        parameters->iToCCIncludeLimit = iEngine->RandomNumber(0, 30);                      

        parameters->iGetEmailOptions = (CMailboxesParameters::TGetEmailOption) iEngine->RandomNumber(CMailboxesParameters::EUndef, CMailboxesParameters::EGetEmailOptionLast-1);

        parameters->iSubscribeType = (TFolderSubscribeType) iEngine->RandomNumber(EUpdateNeither, EUpdateBoth);

        parameters->iSyncType = (TFolderSyncType) iEngine->RandomNumber(EUseCombination, EUseRemote);

        parameters->iSendCopyToSelf = (TImSMTPSendCopyToSelf) iEngine->RandomNumber(ESendNoCopy, ESendCopyAsBccRecipient);

        parameters->iSendOption = (TImSMTPSendMessageOption) iEngine->RandomNumber(ESendMessageImmediately, ESendMessageOnRequest);

        parameters->iMailboxType = (TMailboxType) iEngine->RandomNumber(EMailboxPOP3, EMailboxIMAP4);

        }

    TInt err = KErrNone;

    // make sure we have some IMEI stored

    if (iIMEI.Length() == 0)

        {

        TRAP(err, GetIMEIFromThePhoneL());

        }

    // init 

    CImImap4Settings* imap4Set = new(ELeave) CImImap4Settings;

    CleanupStack::PushL(imap4Set);

    CImPop3Settings* pop3Set = new(ELeave) CImPop3Settings;

    CleanupStack::PushL(pop3Set);

    CImSmtpSettings* smtpSet = new(ELeave) CImSmtpSettings;

    CleanupStack::PushL(smtpSet);

    CImIAPPreferences* outgoingIAPSet = CImIAPPreferences::NewLC();

    CImIAPPreferences* incomingIAPSet = CImIAPPreferences::NewLC();

    CEmailAccounts* account = CEmailAccounts::NewLC();

    // Get SMTP settings:

    PopulateSmtpSettingsL(*account, *smtpSet, *outgoingIAPSet, *parameters);

    // appending mailbox type to array to be able to use

    // correct type when deleting mailboxes

    iEntryIds.Append( parameters->iMailboxType );

    if (parameters->iMailboxType == EMailboxIMAP4)

        {

        // Get IMAP settings:

        PopulateImapSettingsL(*account, *imap4Set, *incomingIAPSet, *parameters);

        TImapAccount imapAccountId = account->CreateImapAccountL(parameters->iMailboxName->Des(), *imap4Set, *incomingIAPSet, EFalse);

        TSmtpAccount smtpAccountId = account->CreateSmtpAccountL(imapAccountId, *smtpSet, *outgoingIAPSet, EFalse);

        account->SetDefaultSmtpAccountL(smtpAccountId);

        iEntryIds.Append( imapAccountId.iImapAccountId );

        iEntryIds.Append( imapAccountId.iImapService );

        iEntryIds.Append( imapAccountId.iSmtpService );      

        iEntryIds.Append( smtpAccountId.iSmtpAccountId );

        iEntryIds.Append( smtpAccountId.iSmtpService );

        iEntryIds.Append( smtpAccountId.iRelatedService );

        StoreIMEIToEntryL( imapAccountId.iImapService );

        StoreIMEIToEntryL( smtpAccountId.iSmtpService );

        }

    else

        {

        // Get POP settings:

        PopulatePopSettingsL(*account, *pop3Set, *incomingIAPSet, *parameters);

        TPopAccount popAccountId = account->CreatePopAccountL(parameters->iMailboxName->Des(), *pop3Set, *incomingIAPSet, EFalse);

        TSmtpAccount smtpAccountId = account->CreateSmtpAccountL(popAccountId, *smtpSet, *outgoingIAPSet, EFalse);     

        account->SetDefaultSmtpAccountL(smtpAccountId);

        iEntryIds.Append( popAccountId.iPopAccountId );

        iEntryIds.Append( popAccountId.iPopService );

        iEntryIds.Append( popAccountId.iSmtpService );

        iEntryIds.Append( smtpAccountId.iSmtpAccountId );

        iEntryIds.Append( smtpAccountId.iSmtpService );

        iEntryIds.Append( smtpAccountId.iRelatedService );

        StoreIMEIToEntryL( popAccountId.iPopService );

        StoreIMEIToEntryL( smtpAccountId.iSmtpService );

        }  

    CleanupStack::PopAndDestroy(6); //imap4Set, pop3Set, smtpSet, outgoingIAPSet, incomingIAPSet, account 

    return err;

    }

void CCreatorMailboxes::PopulateImapSettingsL( 

            CEmailAccounts& aEmailAccount, 

            CImImap4Settings& aImapSettings, 

            CImIAPPreferences& aIApSettings, 

            const CMailboxesParameters& aParameters )

    {

    // Get default settings first:

    aEmailAccount.PopulateDefaultImapSettingsL(aImapSettings, aIApSettings);

    TImIAPChoice iapChoice;

    iapChoice.iIAP = 0;

    if( aParameters.iIncomingConnectionMethod == 0 || 

        aParameters.iIncomingConnectionMethod->Des().Length() == 0 )

        {

        TRAP_IGNORE( iapChoice.iIAP = iEngine->AccessPointNameToIdL( KInternet ));

        }

    else

        {

        TRAP_IGNORE( iapChoice.iIAP = iEngine->AccessPointNameToIdL( aParameters.iIncomingConnectionMethod->Des()));

        }

    iapChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

    aIApSettings.AddIAPL(iapChoice);

    TBuf8<256> buf8;

    if( aParameters.iIncomingLoginName && aParameters.iIncomingLoginName->Length() > 0 )                

        buf8.Copy(aParameters.iIncomingLoginName->Des());

    else

        buf8.Copy(iEngine->RandomString(CCreatorEngine::EFirstName));

    aImapSettings.SetLoginNameL(buf8);  //8

    if( aParameters.iIncomingPassword && aParameters.iIncomingPassword->Length() > 0 )

        buf8.Copy(aParameters.iIncomingPassword->Des());    

    else

        buf8.Copy(iEngine->RandomString(CCreatorEngine::EFirstName));

    aImapSettings.SetPasswordL(buf8);  //8

    if( aParameters.iIncomingFolderPath && aParameters.iIncomingFolderPath->Length() > 0 )

        {

        buf8.Copy(aParameters.iIncomingFolderPath->Des());

        aImapSettings.SetFolderPathL(buf8);

        }

    if( aParameters.iPathSeparator && aParameters.iPathSeparator->Length() > 0 )

        aImapSettings.SetPathSeparator(aParameters.iIncomingFolderPath->Des()[0]);

    aImapSettings.SetDisconnectedUserMode(aParameters.iDisconnectedUserMode);

    aImapSettings.SetSynchronise(aParameters.iSyncType);

    aImapSettings.SetSubscribe(aParameters.iSubscribeType);

    aImapSettings.SetAutoSendOnConnect(aParameters.iAutoSendOnConnect);

    if(aParameters.iMaxEmailSize != KUndef )

        aImapSettings.SetMaxEmailSize(aParameters.iMaxEmailSize);

    aImapSettings.SetDeleteEmailsWhenDisconnecting(aParameters.iDeleteEmailsAtDisconnect);

    aImapSettings.SetAcknowledgeReceipts(aParameters.iAcknowledgeReceipts);

    if(aParameters.iGetEmailOptions == CMailboxesParameters::EGetBodyText )

        aImapSettings.SetGetMailOptions(EGetImap4EmailBodyText);

    else if(aParameters.iGetEmailOptions == CMailboxesParameters::EGetBodyTextAndAttachments )

        aImapSettings.SetGetMailOptions(EGetImap4EmailBodyTextAndAttachments);

    else if(aParameters.iGetEmailOptions == CMailboxesParameters::EGetAttachments )

        aImapSettings.SetGetMailOptions(EGetImap4EmailAttachments);

    else if(aParameters.iGetEmailOptions == CMailboxesParameters::EGetBodyAlternativeText )

        aImapSettings.SetGetMailOptions(EGetImap4EmailBodyAlternativeText);

    else

        aImapSettings.SetGetMailOptions(EGetImap4EmailHeaders); // Default

    if( aParameters.iInboxSyncLimit != KUndef )

        aImapSettings.SetInboxSynchronisationLimit(aParameters.iInboxSyncLimit);

    if( aParameters.iMailboxSyncLimit != KUndef )

        aImapSettings.SetMailboxSynchronisationLimit(aParameters.iMailboxSyncLimit);

    aImapSettings.SetUpdatingSeenFlags(aParameters.iMarkSeenInSync);

    if( aParameters.iSyncRate != KUndef )

        aImapSettings.SetSyncRateL(aParameters.iSyncRate);

    if( aParameters.iAttachmentFetchSize != KUndef )

        aImapSettings.SetFetchSizeL(aParameters.iAttachmentFetchSize);

    aImapSettings.SetImapIdle(aParameters.iImapIdleCommand);

    if( aParameters.iImapIdleTimeout != KUndef )

        aImapSettings.SetImapIdleTimeoutL(aParameters.iImapIdleTimeout);

    if( aParameters.iBodyTextSizeLimit != KUndef )

        aImapSettings.SetBodyTextSizeLimitL(aParameters.iBodyTextSizeLimit);

    if( aParameters.iAttachmentSizeLimit != KUndef )

        aImapSettings.SetAttachmentSizeLimitL(aParameters.iAttachmentSizeLimit);

#if(!defined __SERIES60_30__ && !defined __SERIES60_31__)

    aImapSettings.SetUseExpunge(aParameters.iEnableExpungeMode);

#endif

    if(aParameters.iIncomingServerName && aParameters.iIncomingServerName->Length() > 0 )

        aImapSettings.SetServerAddressL(aParameters.iIncomingServerName->Des());

    else

        aImapSettings.SetServerAddressL(KDefaultIncomingServer);

    if( aParameters.iIncomingPort != KUndef )

        aImapSettings.SetPort(aParameters.iIncomingPort);                 

    aImapSettings.SetSecureSockets(aParameters.iIncomingSecureSockets);

    aImapSettings.SetSSLWrapper(aParameters.iIncomingSSLWrapper);

    }

void CCreatorMailboxes::PopulatePopSettingsL( 

            CEmailAccounts& aEmailAccount, 

            CImPop3Settings& aPopSettings, 

            CImIAPPreferences& aIApSettings, 

            const CMailboxesParameters& aParameters )

    {

    aEmailAccount.PopulateDefaultPopSettingsL(aPopSettings, aIApSettings);

    TImIAPChoice iapChoice;

    iapChoice.iIAP = 0;

    if( aParameters.iIncomingConnectionMethod == 0 || 

        aParameters.iIncomingConnectionMethod->Des().Length() == 0 )

        {

        TRAP_IGNORE( iapChoice.iIAP = iEngine->AccessPointNameToIdL( KInternet ));

        }

    else

        {

        TRAP_IGNORE( iapChoice.iIAP = iEngine->AccessPointNameToIdL( aParameters.iIncomingConnectionMethod->Des() ));

        }

    iapChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

    aIApSettings.AddIAPL(iapChoice);

    TBuf8<256> buf8;

    if( aParameters.iIncomingLoginName && aParameters.iIncomingLoginName->Length() > 0 )                

        buf8.Copy(aParameters.iIncomingLoginName->Des());

    else

        buf8.Copy(iEngine->RandomString(CCreatorEngine::EFirstName));

    aPopSettings.SetLoginNameL(buf8);  //8

    if( aParameters.iIncomingPassword && aParameters.iIncomingPassword->Length() > 0 )

        buf8.Copy(aParameters.iIncomingPassword->Des());    

    else

        buf8.Copy(iEngine->RandomString(CCreatorEngine::EFirstName));

    aPopSettings.SetPasswordL(buf8);  //8

    aPopSettings.SetAutoSendOnConnect( aParameters.iAutoSendOnConnect );

    aPopSettings.SetApop( aParameters.iUseApop );

    aPopSettings.SetDisconnectedUserMode( aParameters.iDisconnectedUserMode );

    aPopSettings.SetDeleteEmailsWhenDisconnecting( aParameters.iDeleteEmailsAtDisconnect );

    aPopSettings.SetAcknowledgeReceipts( aParameters.iAcknowledgeReceipts );

    if( aParameters.iMaxEmailSize != KUndef )

        aPopSettings.SetMaxEmailSize(aParameters.iMaxEmailSize);

    if(aParameters.iGetEmailOptions != CMailboxesParameters::EGetHeaders && 

            aParameters.iGetEmailOptions != CMailboxesParameters::EUndef )

        {

        aPopSettings.SetGetMailOptions(EGetPop3EmailMessages);

        aPopSettings.SetPopulationLimitL( -1 ); // -1 = body and attachment

        }

    else

        {

        aPopSettings.SetGetMailOptions(EGetPop3EmailHeaders); // Default

        aPopSettings.SetPopulationLimitL( -2 ); // -2 = headers only

        }

    if( aParameters.iInboxSyncLimit != KUndef )

        {

        aPopSettings.SetInboxSynchronisationLimit(aParameters.iInboxSyncLimit);

        }

    if(aParameters.iIncomingServerName && aParameters.iIncomingServerName->Length() > 0 )

        aPopSettings.SetServerAddressL(aParameters.iIncomingServerName->Des());

    else

        aPopSettings.SetServerAddressL(KDefaultIncomingServer);