/*

* 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 connection validation

*

*/

#include <eikenv.h>

#include "ImumPanic.h"

#include "MsvPop3ConnectOp.h"

#include <ImumUtils.rsg>

#include <miut_err.h>

#include <SendUiConsts.h>

#include <ImumInMailboxUtilities.h>

#include "MsvConnectionValidation.h"

#include "MsvEmailConnectionProgressProvider.h"

#include "EmailUtils.H"

#include "ImumDisconnectOperation.h"

#include "ImumMtmLogging.h"

#include "ImumMboxSettingsUtils.h"

#include <MsvPrgReporter.h>

// Constants and defines

const TInt KConnectOpPriority = CActive::EPriorityStandard;

const TInt KImumMaxLoginRetries = 3;

CMsvPop3ConnectOp* CMsvPop3ConnectOp::NewL(

    TRequestStatus& aObserverRequestStatus,

    MMsvProgressReporter& aReporter,

    TMsvId aService,

    TInt aPopulateLimit )

    {

    IMUM_STATIC_CONTEXT( CMsvPop3ConnectOp::NewL, 0, mtm, KImumMtmLog );

    IMUM_IN();

    // Normally this would be done in ConstructL method, but the base class

    // requires this instance to exist in constructor call. We don't want to

    // use the MTM instance of the emailAPI because this operation can outlive

    // the MTM.

    CImumInternalApi* emailApi = CreateEmailApiLC();

    CMsvPop3ConnectOp* op = new(ELeave) CMsvPop3ConnectOp( emailApi,

        aObserverRequestStatus,

        aReporter,

        aService,

        aPopulateLimit);

    CleanupStack::Pop( emailApi ); // ownership transferred to operation

    CleanupStack::PushL(op);

    op->ConstructL();

    CleanupStack::Pop();

    IMUM_OUT();

    return op;

    }

CMsvPop3ConnectOp::~CMsvPop3ConnectOp()

    {

    IMUM_CONTEXT( CMsvPop3ConnectOp::~CMsvPop3ConnectOp, 0, KImumMtmLog );

    IMUM_IN();

    delete iEntry;

    delete iProgProvider;

    delete iSelection;

    delete iMboxApi;

    IMUM_OUT();

    }

const TDesC8& CMsvPop3ConnectOp::ProgressL()

    {

    IMUM_CONTEXT( CMsvPop3ConnectOp::ProgressL, 0, KImumMtmLog );

    IMUM_IN();

    //

    // If refreshing the inbox, return client op progress, else use connection progress provider.

    //

    if ( iError != KErrNone )

        {

        if ( FlagIsSet( EIapWasInvalid ) )

            {

            iError = KPop3CannotConnect;

            }

        return GetErrorProgressL( iError );

        }

    if ( !iOperation )

        {

        IMUM_OUT();

        return iDummyProg;

        }

    iProgress.Copy( iOperation->ProgressL() );

    if ( iStatus == KRequestPending )

        {

        if ( iProgress().iPop3Progress == TPop3Progress::EPopRefreshing ||

             iProgress().iPop3Progress == TPop3Progress::EPopTopPopulating ||

             iProgress().iPop3Progress == TPop3Progress::EPopPopulating )

            {

            IMUM_OUT();

            // Refreshing inbox or doing populate

            return iProgress;

            }

        // Operation not completed, and not refreshing inbox.

        return iProgProvider->GetConnectionProgressL( iError );

        }

    else if ( FlagIsSet( EMaxNumberOfLoginTries ) )

        {

        // User has entered wrong username or password max number of times, display error note

        iProgress().iErrorCode = KPop3InvalidLogin;

        IMUM_OUT();

        return iProgress;

        }

    else if ( FlagIsSet( EInvalidDetails ) )

        {

        // User details are wrong.

        // This error is handled using a special dialog in DoRunL() which allows retrying of connection.

        // The user must have cancelled that dialog, so patch the error code so we don't display another

        // error notifier in CPop3MtmUi::DisplayProgressSummary().

        // iOperation is a Client MTM connect op, progress is a TPop3Progress.

        iProgress().iErrorCode = KErrCancel;

        IMUM_OUT();

        return iProgress;

        }

    IMUM_OUT();

    // Operation completed.

    return iProgress;

    }

void CMsvPop3ConnectOp::DoCancel()

    {

    IMUM_CONTEXT( CMsvPop3ConnectOp::DoCancel, 0, KImumMtmLog );

    CImumOnlineOperation::DoCancel();

    IMUM_OUT();

    }

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

// CMsvPop3ConnectOp::DoRunL()

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

//

void CMsvPop3ConnectOp::DoRunL()

    {

    IMUM_CONTEXT( CMsvPop3ConnectOp::DoRunL, 0, KImumMtmLog );

    IMUM_IN();

    TInt err  = KErrNone;

    if ( FlagIsSet( EDoConnect ) )

        {

        // To speed up connection establishment, avoid loading settings multiple

        // times. Get all the info needed at once.

        CImumInSettingsData* settings =

            iMailboxApi.MailboxServicesL().LoadMailboxSettingsL( iService );

        CleanupStack::PushL( settings );

        // Get iap name

        TBuf<KImasImailMaxSettingsLength> iapName;

        MsvConnectionValidation::GetServiceIapNameL( *settings,

            KSenduiMtmPop3Uid, iapName);

        TBool ok = ValidateL( *settings );

        CleanupStack::PopAndDestroy(); // settings

        if ( ok )

            {

            // Begin Connect.

            UnsetFlag( EDoConnect );

            iProgProvider = CMsvEmailConnectionProgressProvider::NewL(

                iapName, iService );

            DoConnectL();

            IMUM_OUT();

            return;

            }

        else

            {

            err = KErrCancel;    // User cancelled.

            }

        }

    else

        {

        // Connect completed.

        err = GetOperationCompletionCodeL();

        if ( ( err == KPop3InvalidUser ) ||

             ( err == KPop3InvalidLogin )  ||

             ( err == KPop3InvalidApopLogin ) )

            {

            // Login details are wrong.

            TBool retry = EFalse;

            if ( iLoginRetryCounter < KImumMaxLoginRetries )

                {

                TRAP( err, retry =

                    MsvConnectionValidation::ShowLoginDetailsRejectionDlgL(

                    iMailboxApi, iService ) );

                }

            else

                {

                SetFlag( EMaxNumberOfLoginTries );

                }

            iLoginRetryCounter++;

            if ( retry )

                {

                // Retry connect.

                ReDisplayProgressL(R_EMAIL_CONNECTING_SERVER, iService);

                delete iOperation;

                iOperation = NULL;

                DoConnectL();

                IMUM_OUT();

                return;

                }

            else

                {

                SetFlag( EInvalidDetails );

                }

            }

        else if ( err != KErrNone )

            {

            // We can't do this before, because we want to handle KPop3InvalidUser,

            // KPop3InvalidLogin and KPop3InvalidApopLogin separately.

            User::Leave( err );

            }

        else

            {

            if ( !iPopulated &&

                !FlagIsSet( EDoingPopulate ) &&

                ( iPopulateLimit == -1 || iPopulateLimit > 0 ) )

                {

            	ImumMboxSettingsUtils::SetLastUpdateInfoL(

            	    iMailboxApi,

                	iService,

                	err == KErrNone && !FlagIsSet( EInvalidDetails ) );

                //start populate

                DoPopulateL();

                IMUM_OUT();

                return;

                }

            if ( FlagIsSet( EDoingPopulate ) )

                {

                UnsetFlag( EDoingPopulate );

                }

            }

        /* Background Handling */

        MsvEmailMtmUiUtils::CallNewMessagesL( iService );

        }

    CompleteObserver( err );

    IMUM_OUT();

    }

const TDesC8& CMsvPop3ConnectOp::GetErrorProgressL(TInt aError)

    {

    IMUM_CONTEXT( CMsvPop3ConnectOp::GetErrorProgressL, 0, KImumMtmLog );

    IMUM_IN();

    iError = aError;

    if ( iOperation && iError == KErrNone )

        {

        IMUM_OUT();

        return iOperation->ProgressL();

        }

    TPop3Progress& progress = iProgress();

    progress.iPop3Progress = TPop3Progress::EPopConnecting;

    progress.iTotalMsgs = 0;

    progress.iMsgsToProcess = 0;

    progress.iBytesDone = 0;

    progress.iTotalBytes = 0;

    progress.iErrorCode = iError;

    progress.iPop3SubStateProgress = TPop3Progress::EPopConnecting;

    progress.iServiceId = iService;

    IMUM_OUT();

    return iProgress;

    }

CMsvPop3ConnectOp::CMsvPop3ConnectOp(

    CImumInternalApi* aMailboxApi,

    TRequestStatus& aObserverRequestStatus,

    MMsvProgressReporter& aReporter,

    TMsvId aServiceId,

    TInt aPopulateLimit)

    :

    CImumOnlineOperation(

    *aMailboxApi,

    KConnectOpPriority,

    aObserverRequestStatus,

    aReporter)

    {

    IMUM_CONTEXT( CMsvPop3ConnectOp::CMsvPop3ConnectOp, 0, KImumMtmLog );

    IMUM_IN();

    iMboxApi = aMailboxApi;

    iService = aServiceId;

    iPopulateLimit = aPopulateLimit;

    IMUM_OUT();

    }

void CMsvPop3ConnectOp::ConstructL()

    {

    IMUM_CONTEXT( CMsvPop3ConnectOp::ConstructL, 0, KImumMtmLog );

    IMUM_IN();

    iEntry = iMsvSession.GetEntryL(iService);

    iSelection = new(ELeave) CMsvEntrySelection;

    const TMsvEntry& tentry = iEntry->Entry();

    __ASSERT_ALWAYS( tentry.iType.iUid == KUidMsvServiceEntryValue,

        User::Panic(KImumMtmUiPanic,EPop3MtmUiOpConnectNotAService) );

    BaseConstructL(KUidMsgTypePOP3);

    TBool ok = ETrue;

    if(tentry.Connected())

        {

        // We are already connected.

        ok = EFalse;

        //if connected, we must have populated already

        iPopulated = ETrue;

        }

    if(ok)

        {

        // User did not cancel connection, and we are not connected.

        SetFlag(EDoConnect);

        }

    SetActive();

    CompleteThis();

    IMUM_OUT();

    }

void CMsvPop3ConnectOp::DoConnectL()

    {

    IMUM_CONTEXT( CMsvPop3ConnectOp::DoConnectL, 0, KImumMtmLog );

    IMUM_IN();

    // Begin connect.

    iStatus = KRequestPending;

    InvokeClientMtmAsyncFunctionL(KPOP3MTMConnect, iService, iService);

    SetActive();

    }

void CMsvPop3ConnectOp::DoPopulateL()

    {

    IMUM_CONTEXT( CMsvPop3ConnectOp::DoPopulateL, 0, KImumMtmLog );

    IMUM_IN();

    // Populate only if it hasn't done yet

    if( !iPopulated )

        {

        iStatus = KRequestPending;

        // Prepare parameters and include filtering

        TImPop3PopulateOptions pop3GetMailInfo;

        pop3GetMailInfo.SetMaxEmailSize( KMaxTInt32 );

        pop3GetMailInfo.SetPopulationLimit( iPopulateLimit );

        TPckg<TImPop3PopulateOptions> params(pop3GetMailInfo);

        iSelection->InsertL(0, iService);

        // Start the fetch operation

        InvokeClientMtmAsyncFunctionL(

            KPOP3MTMPopulateNew,

            *iSelection,

            iService,

            params);

        SetFlag(EDoingPopulate);

        // Make sure that this won't be done too many times

        iPopulated = ETrue;

        }

    SetActive();

    IMUM_OUT();

    }

TBool CMsvPop3ConnectOp::ValidateL( CImumInSettingsData& aSettings )

    {

    IMUM_CONTEXT( CMsvPop3ConnectOp::ValidateL, 0, KImumMtmLog );

    IMUM_IN();

    iLoginRetryCounter = 0;

    TBool ok = ( aSettings.Validate() == KErrNone );

    if ( !ok )

        {

        SetFlag( EIapWasInvalid );

        }

    else

        {

        UnsetFlag( EIapWasInvalid );

        }

    if(ok)

        {

        iReporter.MakeProgressVisibleL(ETrue);

        TMsvLoginData loginData;

        ImumMboxSettingsUtils::GetLoginInformationL( aSettings,

            KSenduiMtmImap4Uid, loginData.iUsername, loginData.iPassword,

            loginData.iIsPasswordTemporary );

        ok = MsvConnectionValidation::CheckAndPromptForPasswordL(

                iMailboxApi, iService, loginData, iLoginRetryCounter );

        }

    IMUM_OUT();

    return ok;

    }