/*

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

*     POP specific email agent

*

*/

//INCLUDES

#include <SenduiMtmUids.h>

#include <es_sock.h>

#include <MuiuOperationWait.h>

#include <ImumInSettingsKeys.h>

#include <ImumDaSettingsKeys.h>

#include "AlwaysOnlinePopAgent.h"

#include "AlwaysOnlineEmailPluginLogging.h"

#include "AlwaysOnlineEmailLoggingTools.h"

const TInt KEmailMaxCharsInLine = 75;

const TInt KEmailKB = 1024;

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

// CAlwaysOnlinePop3Agent()

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

CAlwaysOnlinePop3Agent::CAlwaysOnlinePop3Agent( 

    CMsvSession& aSession,

    CClientMtmRegistry& aClientMtmRegistry,

    MAlwaysOnlineStatusQueryInterface& aAlwaysOnlineManager,

    CAlwaysOnlineEmailAgent& aEmailAgent )

    :

    CAlwaysOnlineEmailAgentBase( 

        aSession, aClientMtmRegistry, 

        aAlwaysOnlineManager, aEmailAgent )

    {

    }

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

// NewL

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

CAlwaysOnlinePop3Agent* CAlwaysOnlinePop3Agent::NewL( 

    CMsvSession& aSession,

    CClientMtmRegistry& aClientMtmRegistry,

    TMsvId aMailboxId,

    MAlwaysOnlineStatusQueryInterface& aAlwaysOnlineManager,

    CAlwaysOnlineEmailAgent& aEmailAgent )

    {

    AOLOG_IN( "CAlwaysOnlinePop3Agent::NewL" );

    CAlwaysOnlinePop3Agent* self = new(ELeave)CAlwaysOnlinePop3Agent( 

        aSession, aClientMtmRegistry, aAlwaysOnlineManager, aEmailAgent );

    CleanupStack::PushL( self );

    self->ConstructL( aMailboxId );

    CleanupStack::Pop( self );

    return self;

    }

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

// ConstructL()

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

void CAlwaysOnlinePop3Agent::ConstructL( TMsvId aMailboxId )

    {

    AOLOG_IN( "CAlwaysOnlinePop3Agent::ConstructL" );

    CAlwaysOnlineEmailAgentBase::ConstructL( aMailboxId );

    iPop3ClientMtm = (CPop3ClientMtm*) iClientMtmRegistry.NewMtmL( 

        KSenduiMtmPop3Uid );

    iFlags->ClearFlag( EAOBFIsImap4 );    

    }

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

// ~CAlwaysOnlinePop3Agent()

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

CAlwaysOnlinePop3Agent::~CAlwaysOnlinePop3Agent()

    {

    AOLOG_IN( "CAlwaysOnlinePop3Agent::~CAlwaysOnlinePop3Agent" );

    // cancel ongoing operations

    CloseServices();

    delete iPop3ClientMtm;

    }

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

// StartL()

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

void CAlwaysOnlinePop3Agent::StartL()

    {

    AOLOG_IN( "CAlwaysOnlinePop3Agent::StartL" );

    //once start delay op has been started we don't ever reset that id.

    if ( iStartDelayOpId == KErrNotFound )

        {

        //check offline & roaming statuses from AO server

        TBool suspended = EFalse;

        QueryAndHandleAOServerInfoL( suspended );

        if ( suspended )

            {

            //we got iState = EEmailAgentIdle from CAlwaysOnlineEmailAgentBase::Suspend

            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlinePop3Agent::StartL() We have been suspended, not starting!");

            return;

            }

        iState = EEmailAgentInitialised;

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::StartL. Setting state: %d ",iState );

        TTime home;

        home.HomeTime();

        //Let's not start immediately on start. Small delay is safer

        TTimeIntervalSeconds startDelay( KInitWaitSeconds );

        home += startDelay;

        StartTimerOperationL( home, iStartDelayOpId );

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::StartL(). Activated startDelayWait 5sec Op Id: %d ",iStartDelayOpId );

        }//if

    else

        {

        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlinePop3Agent::StartL() called, but we're allready started. No changes to state machine");

        }

    }

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

// ConnectAndUpdateHeadersL()

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

void CAlwaysOnlinePop3Agent::ConnectAndUpdateHeadersL()

    {

    AOLOG_IN( "CAlwaysOnlinePop3Agent::ConnectAndUpdateHeadersL" );

    KAOEMAIL_LOGGER_WRITE_FORMAT( "CAlwaysOnlinePop3Agent::ConnectAndUpdateHeadersL(). Starting to connect into: %d", iEntry->Entry().Id() );

    CreatePop3OperationL( iConnectOpId, KPOP3MTMConnect, EFalse );

    iState = EEmailAgentConnecting;

    KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::ConnectAndUpdateHeadersL(). Setting state:  %d ",iState );

    }

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

// DisconnectL()

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

void CAlwaysOnlinePop3Agent::DisconnectL( TBool aAutomatic )

    {

    AOLOG_IN( "CAlwaysOnlinePop3Agent::DisconnectL" );    

    TBuf8<1> dummyParams;

    dummyParams.Zero();

    CMsvSingleOpWatcher* watcher = CMsvSingleOpWatcher::NewL(*this);

    CleanupStack::PushL( watcher );

    CMsvOperation* op = NULL;

    if ( iEntry->Entry().Connected() )

        {

        CMsvEntrySelection* selection = new(ELeave) CMsvEntrySelection;

        CleanupStack::PushL( selection );

        selection->AppendL( iEntry->Entry().iServiceId );

        iPop3ClientMtm->SwitchCurrentEntryL( iEntry->Entry().iServiceId );

        op = iPop3ClientMtm->InvokeAsyncFunctionL( 

            KPOP3MTMDisconnect, *selection, dummyParams, watcher->iStatus);

        CleanupStack::PopAndDestroy( selection );//selection

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::DisconnectL: ADDING DISCONNECT OPERATION: %d", op->Id() );

        }

    else 

        {

        //already disconnected

        op = CMsvCompletedOperation::NewL(

                iSession, iEntry->Entry().iMtm, KNullDesC8, 

                KMsvLocalServiceIndexEntryId, 

                watcher->iStatus, KErrCancel);

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::DisconnectL: ADDING COMPLETED OPERATION: %d", op->Id() );

        }

    CleanupStack::PushL( op );

    AppendWatcherAndSetOperationL( watcher, op ); // takes immediately ownership

    CleanupStack::Pop( 2, watcher); // op // CSI: 12,47 # nothing wrong

    if ( aAutomatic )

        {

        iState = EEmailAgentAutoDisconnecting;

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::DisconnectL. Automatic, setting state:  %d ",iState );

        }

    else

        {

        iState = EEmailAgentUserDisconnecting;

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::DisconnectL. Setting state:  %d ",iState );

        }

    }

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

// ChangeNextStateL

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

void CAlwaysOnlinePop3Agent::ChangeNextStateL()

    {

    AOLOG_IN( "CAlwaysOnlinePop3Agent::ChangeNextStateL" ); 

    KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::ChangeNextStateL() iState: %d", iState);

    //if we are waiting for schedule to start, we don't handle conn errors.

    //this should only occur if conn op has been started just before schedule ends.

    if ( iError != KErrNone && iState != EEmailAgentTimerWaitingForStart )

        {

        HandleOpErrorL();

        }

    switch ( iState )

        {

        //agent just constructed ( or settings changed ) and ready. Should be here only when settings have be saved

        //with always / home settings

        case EEmailAgentInitialised:

            //settings may have been changed, reset all pending operations

            //because their timings can be different compared to newly saved settings

            ResetAll();

            if ( !IsEmn() )

                {

                CheckAndHandleSchedulingL();//starts schedule timers and sets state accordingly

                if( iWaitForStopOpId != KErrNotFound || 

                    ( iWaitForStopOpId == KErrNotFound && 

                      iWaitForStartOpId == KErrNotFound ) )//no start or stop waiters, all times

                    {

                    //CheckAndHandleCheduling started waitForStopTimer

                    StartWaitTimerL();

                    }

                //else, do nothing, we wait until waitForStartTimer expires and starts updates again

                }

            else

                {

                iState = EEmailAgentIdle;

                CreateCompletedOpL();

                KAOEMAIL_LOGGER_WRITE("CAlwaysOnlinePop3Agent::ChangeNextStateL() EMN is on --> no scheduling or timers needed!");

                }

            break;

        //case EEmailAgentConnected:

        case EEmailAgentConnecting:

            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlinePop3Agent::ChangeNextStateL() DoFilteredPopulateL");

            //if filter not used, just moves to next state - disconnect

            DoFilteredPopulateL();

            break;

        case EEmailAgentDoingFilteredPopulate:

            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlinePop3Agent::ChangeNextStateL() DisconnectL");

            DisconnectL( ETrue );

            break;

        case EEmailAgentConnectFailed:

        case EEmailAgentQueued:

        case EEmailAgentReconnecting:

        case EEmailAgentAutoDisconnecting:

        case EEmailAgentUserDisconnecting:

        case EEmailAgentConnTerminated:

            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlinePop3Agent::ChangeNextStateL() StartWaitTimerL");

            if ( IsReconnectAfterError() )

                {

                StartWaitTimerL();

                }

            else

                {

                DisconnectL( ETrue );

                // disconnect if we are connected

                iState = EEmailAgentIdle;

                //give up, reset retry counter

                iRetryCounter = 0;

                CreateCompletedOpL();

                }

            break;

        case EEmailAgentTimerWaiting:

            //just make sure that wait has completed before connecting

            ConnectIfAllowedL( iIntervalWaitId );

            break;

        case EEmailAgentTimerWaitingForStart://wait end, can connect

            ConnectIfAllowedL( iWaitForStartOpId );

            //else, do nothing, we are not going to change state until waitForStart timer completes

            break;

        case EEmailAgentIdle:

            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlinePop3Agent::ChangeNextStateL() Idling.... zZzZzZzZzzzzzzzzzzzzz");

            //No handling for idle, we just "hang around"

            break;

        case EEmailAgentFatalError:

            //something is so wrong that connection cannot be made without user intervention

            //like incorrect settings or such

            DisplayGlobalErrorNoteL();

            SwitchAutoUpdateOffL();

            break;

        default:

            KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::ChangeNextStateL() Unknown state!: %d,resetting all!", iState);

            ResetAll();

            iState = EEmailAgentInitialised;

            CreateCompletedOpL();

            break;

        }

    }

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

// StartWaitTimerL

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

void CAlwaysOnlinePop3Agent::StartWaitTimerL( )

    {

    AOLOG_IN( "CAlwaysOnlinePop3Agent::StartWaitTimerL" );

    //waiting already

    if ( iState == EEmailAgentTimerWaiting )

        {

        KAOEMAIL_LOGGER_FN1("CAlwaysOnlinePop3Agent::StartWaitTimerL(), already waiting");

        return;

        }

    TTime time;

    time.HomeTime();

    //if just exited settings we should connect, only when AO is on (not EMN).

    if ( iFlags->Flag( EAOBFConnectNow ) && !IsEmn() )

        {

        // Set to false, one time only

        iFlags->ClearFlag( EAOBFConnectNow );

        TTimeIntervalSeconds conn = KInitWaitSeconds;

        time += conn;

        StartTimerOperationL( time, iIntervalWaitId );

        iState = EEmailAgentTimerWaiting;

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::StartWaitTimerL. Connecting in 5 seconds. Op Id:  %d ",iIntervalWaitId );

        return;

        }

    //if we are retrying a connection. 3 quick retries and then qive up

    if ( (iRetryCounter % KAOMaxRetries) != 0 )

        {

        TTimeIntervalSeconds seconds( 0 );

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::StartWaitTimerL() iRetryCounter %d", iRetryCounter);

        switch ( (iRetryCounter % KAOMaxRetries) )

            {

            //values for these retry times configured in AlwaysOnlineEmailAgentBase.h

            case 1:

            case 2: // CSI: 47 # see comment above

                seconds = EEMailAgentReconnectThree;

                break;

            default:

                seconds = EEMailAgentReconnectFive;

                break;

            }//switch

        time += seconds;

        }//if

    else if( iState == EEmailAgentQueued )

        {

        TTimeIntervalSeconds seconds( 0 );

        seconds = EEMailAgentReconnectFour;

        time += seconds;

        }

    else if ( !IsEmn() )

        {

        TInt minutes = RetrievalIntervalInMinutes( LoadSettingL<TInt>( 

            TImumDaSettings::EKeyAutoRetrievalInterval, EFalse ));

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::StartWaitTimerL(). Minutes to wait: %d", minutes);

        TTimeIntervalMinutes intervalMinutes( minutes );

        time += intervalMinutes;

        }

    StartTimerOperationL( time, iIntervalWaitId );

    KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::StartWaitTimerL. Interval timer started. Op Id:  %d ",iIntervalWaitId );

    iState = EEmailAgentTimerWaiting;

    KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::StartWaitTimerL. Setting state:  %d ",iState );

    }

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

// CreatePop3OperationL()

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

void CAlwaysOnlinePop3Agent::CreatePop3OperationL( 

    TInt aFunctionId, 

    TBool aCompletedOperation /*= EFalse*/ )

    {

    AOLOG_IN( "CAlwaysOnlinePop3Agent::CreatePop3OperationL" );

    TMsvOp dummy;

    CreatePop3OperationL( dummy, aFunctionId, aCompletedOperation );

    }

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

// CAlwaysOnlinePop3Agent::FillMailOptionsL()

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

//

TImPop3PopulateOptions CAlwaysOnlinePop3Agent::FillMailOptionsL()

    {

    AOLOG_IN( "CAlwaysOnlinePop3Agent::FillMailOptionsL" );

    TImPop3PopulateOptions pop3GetMailInfo;

    TInt32 sync = LoadSettingL<TInt32>( 

        TImumInSettings::EKeySyncFlags, ETrue );

    if ( sync == TImumInSettings::EFlagDownloadPartialCumulative )

        {

        // Population limit is set only if user defined limit has been defined

        TInt32 limit = LoadSettingL<TInt32>(

            TImumInSettings::EKeyDownloadBodySize, ETrue );

        pop3GetMailInfo.SetPopulationLimit(

            ( limit * KEmailKB ) / KEmailMaxCharsInLine );

        }

    return pop3GetMailInfo;

    }

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

// CreatePop3OperationL

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

void CAlwaysOnlinePop3Agent::CreatePop3OperationL( 

    TMsvOp& aOpId, 

    TInt aFunctionId, 

    TBool aCompletedOperation /*= EFalse*/ )

    {

    AOLOG_IN( "CAlwaysOnlinePop3Agent::CreatePop3OperationL" );

    KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::CreatePop3OperationL() aFunctionId %d", aFunctionId);

    CMsvEntrySelection* selection = new(ELeave) CMsvEntrySelection;

    CleanupStack::PushL( selection );

    CMsvSingleOpWatcher* watcher = CMsvSingleOpWatcher::NewL(*this);

    CleanupStack::PushL( watcher );

    CMsvOperation* op = NULL;

    if ( aCompletedOperation )

        {

        op = CMsvCompletedOperation::NewL(  // CSI: 35 # cleanupstack is used

                iSession, iEntry->Entry().iMtm, KNullDesC8, 

                KMsvLocalServiceIndexEntryId, 

                watcher->iStatus, KErrCancel);

        aOpId = op->Id();

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::CreatePop3OperationL: ADDING COMPLETED OPERATION. ID: %d", aOpId );

        }

    else

        {

        selection->AppendL( iEntry->Entry().iServiceId );

        iPop3ClientMtm->SwitchCurrentEntryL( iEntry->Entry().iServiceId );

        TImPop3PopulateOptions pop3GetMailInfo = FillMailOptionsL();

        // Add the population limit to packet for fetch operation

        TPckg<TImPop3PopulateOptions> params(pop3GetMailInfo);

        // Begin the fetching operation

        op = iPop3ClientMtm->InvokeAsyncFunctionL( 

            aFunctionId, *selection, params, watcher->iStatus);

        aOpId = op->Id();

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::CreatePop3OperationL: ADDING CONNECT OPERATION. ID: %d", aOpId );

        }

    CleanupStack::PushL( op );

    AppendWatcherAndSetOperationL( watcher, op ); // takes immediately ownership

    CleanupStack::Pop( 2, watcher); // op // CSI: 12,47 # nothing wrong

    CleanupStack::PopAndDestroy( selection );//selection

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlinePop3Agent::CreatePop3OperationL");

    }

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

// DoFilteredPopulateL

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

void CAlwaysOnlinePop3Agent::DoFilteredPopulateL()

    {

    AOLOG_IN( "CAlwaysOnlinePop3Agent::DoFilteredPopulateL" );

    TInt32 sync = LoadSettingL<TInt32>( 

        TImumInSettings::EKeySyncFlags, ETrue );

    if ( sync == TImumInSettings::EFlagDownloadPartialCumulative ||

         sync == TImumInSettings::EFlagSetDownloadAll )

        {

        // Either user defined limit or full download is selected

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::DoFilteredPopulateL(): Doing filtered populate with setting: %d", sync );

        iState = EEmailAgentDoingFilteredPopulate;

        CreatePop3OperationL( 

            iFilteredPopulateOpId, 

            KPOP3MTMPopulateNew,

            EFalse );

        }

    else

        {

        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlinePop3Agent::DoFilteredPopulateL(): Filters not set. Will not populate." );

        //set state and do completed op to step to next state

        iState = EEmailAgentDoingFilteredPopulate;

        CreateCompletedOpL();

        }

    }

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

// HandleOpErrorL

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

void CAlwaysOnlinePop3Agent::HandleOpErrorL()

    {

    AOLOG_IN( "CAlwaysOnlinePop3Agent::HandleOpErrorL" );

    AOLOG_WRMV( "iError: ",  EAoNormalError, iError, EAoLogSt3 );

    KAOEMAIL_LOGGER_WRITE("CAlwaysOnlinePop3Agent::HandleOpErrorL() Error Handling started" );

    KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::HandleOpErrorL() Error ID: %d", iError );

    switch ( iError )

        {

        case KErrNone:

            //shouldn't come here if KErrNone

            break;

        case KErrAbort:

        case KErrCancel:

            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlinePop3Agent::HandleOpErrorL(): KErrCancel");

            //sometimes we seem to get these errors with connection operations.

            //so go to initialised state -> reset all

            iError = KErrNone;

            iState = EEmailAgentInitialised; //this will be changed where those timers were cancelled.

            break;

        case KErrGeneral://seems that this is what is given when phone/csd is in use

            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlinePop3Agent::HandleOpErrorL(): KErrGeneral");

            iState = EEmailAgentQueued;

            KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::HandleOpErrorL. Setting state:  %d ",iState );

            break;

        case KErrInUse:

            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlinePop3Agent::HandleOpErrorL(): KErrInUse");

            iState = EEmailAgentQueued;

            KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlinePop3Agent::HandleOpErrorL. Setting state:  %d ",iState );

            break;

        //fatal errors, cannot recover without user intervention

        case KPop3InvalidUser:

        case KPop3InvalidLogin:

        case KPop3InvalidApopLogin:

        case KErrPop3TLSNegotiateFailed: