/*

* Copyright (c) 2009 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:  Implementation of HTI mailbox settings handling.

*

*/

// INCLUDE FILES

#include <cmconnectionmethod.h>

#include <cmconnectionmethoddef.h>

#include <cmdestination.h>

#include <cmmanager.h>

#include <cemailaccounts.h>

#include <etelmm.h>

#include <iapprefs.h>

#include <imapset.h>

#include <mtmuibas.h>

#include <SendUiConsts.h>

#include <pop3set.h>

#include <smtpset.h>

#include <txtrich.h>

#include <HtiDispatcherInterface.h>

#include <HtiLogging.h>

#include "HtiMessagesServicePlugin.h"

#include "HtiMailboxHandler.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KMinCreateMsgLength = 36;

const TInt KMinDeleteMsgLength = 3;

const TInt KImeiLength = 15;

const TInt KDefaultImapPortSSL = 993;

const TInt KDefaultPopPortSSL  = 995;

const TInt KDefaultSmtpPortSSL = 465;

// MACROS

// LOCAL CONSTANTS AND MACROS

_LIT8( KErrorInvalidParameters, "Invalid command parameters" );

_LIT8( KErrorCreateFailed, "Mailbox creation failed" );

_LIT8( KErrorDeleteFailed, "Mailbox deletion failed" );

#ifdef __WINS__

_LIT( KWinsImei, "123456789012345" );

#else

_LIT( KTsyName, "phonetsy" );

#endif

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CHtiMailboxHandler::NewL

// Two-phased constructor.

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

CHtiMailboxHandler* CHtiMailboxHandler::NewL()

    {

    HTI_LOG_FUNC_IN( "CHtiMailboxHandler::NewL" );

    CHtiMailboxHandler* self = new (ELeave) CHtiMailboxHandler();

    CleanupStack::PushL ( self );

    self->ConstructL();

    CleanupStack::Pop();

    HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::NewL" );

    return self;

    }

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

// CHtiMailboxHandler::CHtiMailboxHandler

// C++ default constructor can NOT contain any code, that

// might leave.

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

CHtiMailboxHandler::CHtiMailboxHandler()

    {

    HTI_LOG_FUNC_IN( "CHtiMailboxHandler::CHtiMailboxHandler" );

    HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::CHtiMailboxHandler" );

    }

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

// CHtiMailboxHandler::~CHtiMailboxHandler

// Destructor.

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

CHtiMailboxHandler::~CHtiMailboxHandler()

    {

    HTI_LOG_FUNC_IN( "CHtiMailboxHandler::~CHtiMailboxHandler" );

    delete iMailboxName;

    delete iIncomingServer;

    delete iIncomingApName;

    delete iIncomingUserName;

    delete iIncomingPassword;

    delete iOutgoingServer;

    delete iOutgoingApName;

    delete iOutgoingUserName;

    delete iOutgoingPassword;

    delete iOwnMailAddress;

    delete iOwnName;

    delete iSignatureText;

    delete iImapFolderPath;

    HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::~CHtiMailboxHandler" );

    }

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

// CHtiMailboxHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CHtiMailboxHandler::ConstructL()

    {

    HTI_LOG_FUNC_IN( "CHtiMailboxHandler::ConstructL" );

    HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::ConstructL" );

    }

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

// CHtiMailboxHandler::SetDispatcher

// Sets the dispatcher pointer.

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

void CHtiMailboxHandler::SetDispatcher( MHtiDispatcher* aDispatcher )

    {

    HTI_LOG_FUNC_IN( "CHtiMailboxHandler::SetDispatcher" );

    iDispatcher = aDispatcher;

    HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::SetDispatcher" );

    }

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

// CHtiMailboxHandler::ProcessMessageL

// Parses the received message and calls handler functions.

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

void CHtiMailboxHandler::ProcessMessageL( const TDesC8& aMessage,

    THtiMessagePriority /*aPriority*/ )

    {

    HTI_LOG_FUNC_IN( "CHtiMailboxHandler::ProcessMessageL" );

    // Zero length message and command code validity already checked

    // in HtiMessagesServicePlugin.

    if ( aMessage[0] == CHtiMessagesServicePlugin::ECreateMailBox )

        {

        if ( aMessage.Length() < KMinCreateMsgLength )

            {

            SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

            }

        else

            {

            iCmManager.OpenL();

            TRAPD( err, HandleCreateMailboxL(

                    aMessage.Right( aMessage.Length() - 1 ) ) );

            if ( err != KErrNone )

                {

                if ( err == KErrArgument )

                    {

                    SendErrorMessageL( err, KErrorInvalidParameters );

                    }

                else

                    {

                    HTI_LOG_FORMAT( "Create error %d", err );

                    SendErrorMessageL( err, KErrorCreateFailed );

                    }

                }

            else

                {

                SendOkMsgL( KNullDesC8 );

                }

            ResetVariables();

            }

        }

    else

        {

        if ( aMessage.Length() < KMinDeleteMsgLength )

            {

            SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

            }

        else

            {

            TRAPD( err, HandleDeleteMailboxL(

                    aMessage.Right( aMessage.Length() - 1 ) ) );

            if ( err != KErrNone )

                {

                HTI_LOG_FORMAT( "Delete error %d", err );

                SendErrorMessageL( err, KErrorDeleteFailed );

                }

            else

                {

                SendOkMsgL( KNullDesC8 );

                }

            }

        }

    HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::ProcessMessageL" );

    }

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

// CHtiMailboxHandler::HandleCreateMailboxL

// Creates new mailbox.

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

void CHtiMailboxHandler::HandleCreateMailboxL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CHtiMailboxHandler::HandleCreateMailboxL" );

    ParseCreateMsgL( aData );

    TSmtpAccount smtpAcc;

    TInt result = FindSmtpAccount( *iMailboxName, smtpAcc );

    if ( result != KErrNotFound )

        {

        User::Leave( KErrAlreadyExists );

        }

    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* incomingIapSet = CImIAPPreferences::NewLC();

    CImIAPPreferences* outgoingIapSet = CImIAPPreferences::NewLC();

    CEmailAccounts* accounts = CEmailAccounts::NewLC();

    accounts->PopulateDefaultSmtpSettingsL( *smtpSet, *outgoingIapSet );

    if ( iMailboxType == 0 )  // POP3

        {

        accounts->PopulateDefaultPopSettingsL( *pop3Set, *incomingIapSet );

        }

    else // IMAP4

        {

        accounts->PopulateDefaultImapSettingsL( *imap4Set, *incomingIapSet );

        }

    // Set access point settings

    TImIAPChoice imIAPChoice;

    imIAPChoice.iIAP = 0;

    imIAPChoice.iDialogPref = ECommDbDialogPrefPrompt;

    if ( iIncomingApName->Length() > 0 )

        {

        User::LeaveIfError(

            imIAPChoice.iIAP = AccessPointUIDL( *iIncomingApName ) );

        imIAPChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

        HTI_LOG_TEXT( "Incoming IAP user defined" );

        }

    incomingIapSet->AddIAPL( imIAPChoice );

    imIAPChoice.iIAP = 0;

    imIAPChoice.iDialogPref = ECommDbDialogPrefPrompt;

    if ( iOutgoingApName->Length() > 0 )

        {

        User::LeaveIfError(

            imIAPChoice.iIAP = AccessPointUIDL( *iOutgoingApName ) );

        imIAPChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

        HTI_LOG_TEXT( "Outgoing IAP user defined" );

        }

    outgoingIapSet->AddIAPL( imIAPChoice );

    // Set SMTP settings

    HTI_LOG_TEXT( "Setting SMTP settings" );

    smtpSet->SetServerAddressL( *iOutgoingServer );

    smtpSet->SetLoginNameL( *iOutgoingUserName );

    smtpSet->SetPasswordL( *iOutgoingPassword );

    smtpSet->SetEmailAddressL( *iOwnMailAddress );

    smtpSet->SetReplyToAddressL( *iOwnMailAddress );

    smtpSet->SetEmailAliasL( *iOwnName );

    if ( iSignatureText->Length() > 0 )

        {

        smtpSet->SetAddSignatureToEmail( ETrue );

        }

    else

        {

        smtpSet->SetAddSignatureToEmail( EFalse );

        }

    smtpSet->SetSendCopyToSelf( (TImSMTPSendCopyToSelf) iSendCopyToOwnAddress );

    smtpSet->SetSendMessageOption( (TImSMTPSendMessageOption) iSendOption );

    if ( iOutgoingSecurity == 0 )

        {

        smtpSet->SetSecureSockets( EFalse );

        }

    else

        {

        smtpSet->SetSecureSockets( ETrue );

        if ( iOutgoingSecurity == 1 )

            {

            smtpSet->SetSSLWrapper( EFalse );

            }

        else // 2 = SSL

            {

            smtpSet->SetSSLWrapper( ETrue );

            }

        }

    if ( iOutgoingPort > 0 )

        {

        smtpSet->SetPort( (TUint) iOutgoingPort );

        }

    else

        {

        if ( iOutgoingSecurity == 2 ) // SSL

            {

            smtpSet->SetPort( KDefaultSmtpPortSSL );

            }

        else

            {

            smtpSet->SetPort( KSMTPDefaultPortNumber );

            }

        }

    smtpSet->SetBodyEncoding( EMsgOutboxMIME );

    smtpSet->SetAddVCardToEmail( EFalse );

    smtpSet->SetRequestReceipts( EFalse );

    smtpSet->SetSMTPAuth( ETrue );

    TSmtpAccount smtpAccount;

    TPopAccount popAccount;

    TImapAccount imapAccount;

    // Set POP3 settings

    if ( iMailboxType == 0 )  // POP3

        {

        HTI_LOG_TEXT( "Setting POP3 settings" );

        pop3Set->SetServerAddressL( *iIncomingServer );

        pop3Set->SetLoginNameL( *iIncomingUserName );

        pop3Set->SetPasswordL( *iIncomingPassword );

        pop3Set->SetApop( iAPopSecureLogin );

        if ( iIncomingSecurity == 0 )

            {

            pop3Set->SetSecureSockets( EFalse );

            }

        else

            {

            pop3Set->SetSecureSockets( ETrue );

            if ( iIncomingSecurity == 1 )

                {

                pop3Set->SetSSLWrapper( EFalse );

                }

            else

                {

                pop3Set->SetSSLWrapper( ETrue );

                }

            }

        if ( iIncomingPort > 0 )

            {

            pop3Set->SetPort( (TUint) iIncomingPort );

            }

        else

            {

            if ( iIncomingSecurity == 2 ) // SSL

                {

                pop3Set->SetPort( KDefaultPopPortSSL );

                }

            else

                {

                pop3Set->SetPort( KPOP3DefaultPortNumber );

                }

            }

        if ( iRetrievedParts == 0 ) // Only headers

            {

            pop3Set->SetGetMailOptions( EGetPop3EmailHeaders );

            pop3Set->SetPopulationLimitL( -2 ); // -2 = headers only (EmailUtils.h)

            }

        else

            {

            pop3Set->SetGetMailOptions( EGetPop3EmailMessages );

            if ( iRetrievedParts == 1 ) // Less than (kb)

                {

                pop3Set->SetMaxEmailSize( iRetrieveSizeLimitKb );

                pop3Set->SetPopulationLimitL( iRetrieveSizeLimitKb );

                }

            else

                {

                pop3Set->SetPopulationLimitL( -1 ); // -1 = body and attachment (EmailUtils.h)

                }

            }

        if ( iEmailsToRetrieve > 0 )

            {

            pop3Set->SetInboxSynchronisationLimit( iEmailsToRetrieve );

            }

        else

            {

            // If limit is not set (zero), retrieves all

            pop3Set->SetInboxSynchronisationLimit( KErrNotFound );

            }

        pop3Set->SetAcknowledgeReceipts( EFalse );

        pop3Set->SetDisconnectedUserMode( ETrue );

        pop3Set->SetAutoSendOnConnect( ETrue );

        pop3Set->SetDeleteEmailsWhenDisconnecting( EFalse );

        popAccount = accounts->CreatePopAccountL(

            *iMailboxName, *pop3Set, *incomingIapSet, EFalse );

        HTI_LOG_FORMAT( "Created POP3 account %d", popAccount.iPopAccountId );

        smtpAccount = accounts->CreateSmtpAccountL(

            popAccount, *smtpSet, *outgoingIapSet, EFalse );

        HTI_LOG_FORMAT( "Created SMTP account %d", smtpAccount.iSmtpAccountId );

        }

    // Set IMAP4 settings

    else

        {

        HTI_LOG_TEXT( "Setting IMAP4 settings" );

        imap4Set->SetServerAddressL( *iIncomingServer );

        imap4Set->SetLoginNameL( *iIncomingUserName );

        imap4Set->SetPasswordL( *iIncomingPassword );

        if ( iIncomingSecurity == 0 )

            {

            imap4Set->SetSecureSockets( EFalse );

            }

        else

            {

            imap4Set->SetSecureSockets( ETrue );

            if ( iIncomingSecurity == 1 )

                {

                imap4Set->SetSSLWrapper( EFalse );

                }

            else

                {

                imap4Set->SetSSLWrapper( ETrue );

                }

            }

        if ( iIncomingPort > 0 )

            {

            imap4Set->SetPort( (TUint) iIncomingPort );

            }

        else

            {

            if ( iIncomingSecurity == 2 ) // SSL

                {

                imap4Set->SetPort( KDefaultImapPortSSL );

                }

            else

                {

                imap4Set->SetPort( KIMAPDefaultPortNumber );

                }

            }

        if ( iEmailsToRetrieve > 0 )

            {

            imap4Set->SetInboxSynchronisationLimit( iEmailsToRetrieve );

            imap4Set->SetMailboxSynchronisationLimit( iEmailsToRetrieve );

            }

        else

            {

            // If limit is not set (zero), retrieves all

            imap4Set->SetInboxSynchronisationLimit( KErrNotFound );

            imap4Set->SetMailboxSynchronisationLimit( KErrNotFound );

            }

        imap4Set->SetFolderPathL( *iImapFolderPath );

        imap4Set->SetGetMailOptions( EGetImap4EmailHeaders );

        imap4Set->SetPartialMailOptionsL( ENoSizeLimits );

        imap4Set->SetBodyTextSizeLimitL( KMaxTInt );

        imap4Set->SetAttachmentSizeLimitL( KMaxTInt );

        imap4Set->SetAcknowledgeReceipts( EFalse );

        imap4Set->SetDisconnectedUserMode( ETrue );

        imap4Set->SetSynchronise( EUseLocal );

        imap4Set->SetSubscribe( EUpdateNeither );

        imap4Set->SetAutoSendOnConnect( ETrue );

        imap4Set->SetDeleteEmailsWhenDisconnecting( EFalse );

        imap4Set->SetImapIdle( ETrue );

        imap4Set->SetUpdatingSeenFlags( ETrue );

        imapAccount = accounts->CreateImapAccountL(

            *iMailboxName, *imap4Set, *incomingIapSet, EFalse );

        HTI_LOG_FORMAT( "Created IMAP4 account %d", imapAccount.iImapAccountId );

        smtpAccount = accounts->CreateSmtpAccountL(

            imapAccount, *smtpSet, *outgoingIapSet, EFalse );

        HTI_LOG_FORMAT( "Created SMTP account %d", smtpAccount.iSmtpAccountId );

        }

    // Set as default if requested

     if ( iSetAsDefault )

        {

        accounts->SetDefaultSmtpAccountL( smtpAccount );

        }

    // accounts, outgoingIapSet, incomingIapSet, smtpSet, pop3Set, imap4set

    CleanupStack::PopAndDestroy( 6 );

    // Get IDs of created incoming mail account

    TMsvId mailboxId = 0;

    TUint32 accountId = 0;

    TUid protocol = TUid::Null();

    if ( iMailboxType == 0 ) // POP3

        {

        mailboxId = popAccount.iPopService;

        accountId = popAccount.iPopAccountId;

        protocol.iUid = KSenduiMtmPop3UidValue;

        }

    else // IMAP4

        {

        mailboxId = imapAccount.iImapService;

        accountId = imapAccount.iImapAccountId;

        protocol.iUid = KSenduiMtmImap4UidValue;

        iRetrievedParts = 0;

        }

    // Get the created mailbox entries

    HTI_LOG_TEXT( "Opening MSV session" );

    CMsvSession* session = CMsvSession::OpenSyncL( *this );

    CleanupStack::PushL( session );

    HTI_LOG_TEXT( "Getting mailbox MSV entries" );

    CMsvEntry* incomingEntry = session->GetEntryL( mailboxId );