/*

* 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: 

*     Email imap agent

*

*/

#include <AlwaysOnlineStatusQueryInterface.h>

#include <SenduiMtmUids.h>

#include <es_sock.h>

#include <MuiuOperationWait.h>

#include <ImumInSettingsData.h>

#include "AlwaysOnlineEmailPluginTimer.h"

#include "AlwaysOnlineEmailPluginLogging.h"

#include "AlwaysOnlineEmailLoggingTools.h"

#include "AlwaysOnlineImapAgent.h"

#include "AlwaysOnlineImap4FolderPopulate.h"

const TInt KAlwaysOnlineMaxLimit = 30;  // if inbox sync rate is less than this and we are using gprs, then connection is kept open all the time.

const TInt KAlwaysOnlineTwoMinutes = 120;

const TInt KAlwaysOnlineMinuteToSecondsMultiplier = 60;

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

// CAlwaysOnlineImap4Agent()

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

CAlwaysOnlineImap4Agent::CAlwaysOnlineImap4Agent(

    CMsvSession& aSession,

    CClientMtmRegistry& aClientMtmRegistry,

    MAlwaysOnlineStatusQueryInterface& aAlwaysOnlineManager,

    CAlwaysOnlineEmailAgent& aEmailAgent )

    :

    CAlwaysOnlineEmailAgentBase(

        aSession,

        aClientMtmRegistry,

        aAlwaysOnlineManager,

        aEmailAgent ),

    iInboxId( 0 ),

    iImap4StateFlags()

    {

    }

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

// NewL

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

CAlwaysOnlineImap4Agent* CAlwaysOnlineImap4Agent::NewL(

    CMsvSession& aSession,

    CClientMtmRegistry& aClientMtmRegistry,

    TMsvId aMailboxId,

    MAlwaysOnlineStatusQueryInterface& aAlwaysOnlineManager,

    CAlwaysOnlineEmailAgent& aEmailAgent )

    {

    AOLOG_IN( "CAlwaysOnlineImap4Agent::IsReconnectAfterError" );

    CAlwaysOnlineImap4Agent* self = new(ELeave)CAlwaysOnlineImap4Agent(

        aSession,

        aClientMtmRegistry,

        aAlwaysOnlineManager,

        aEmailAgent );

    CleanupStack::PushL( self );

    self->ConstructL( aMailboxId );

    CleanupStack::Pop( self );

    return self;

    }

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

// ConstructL()

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

void CAlwaysOnlineImap4Agent::ConstructL( TMsvId aMailboxId )

    {

    AOLOG_IN( "CAlwaysOnlineImap4Agent::ConstructL" );

    CAlwaysOnlineEmailAgentBase::ConstructL( aMailboxId );

    iImap4ClientMtm = (CImap4ClientMtm*) iClientMtmRegistry.NewMtmL(

        KSenduiMtmImap4Uid );

    iFolderArray = new (ELeave) CMsvEntrySelection();

    iFlags->SetFlag( EAOBFIsImap4 );

    }

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

// ~CAlwaysOnlineImap4Agent()

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

CAlwaysOnlineImap4Agent::~CAlwaysOnlineImap4Agent()

    {

    AOLOG_IN( "CAlwaysOnlineImap4Agent::~CAlwaysOnlineImap4Agent" );

    // cancel ongoing operations

    CloseServices();

    delete iFolderArray;

    delete iFolderObserver;

    delete iImap4ClientMtm;

    }

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

// SetStayOnlineFlagL()

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

void CAlwaysOnlineImap4Agent::SetStayOnlineFlagL()

    {

    AOLOG_IN( "CAlwaysOnlineImap4Agent::SetStayOnlineFlagL" );

    //first, check the mode we should be operating in.

    TBool isCsd = EFalse;

    TRAP_IGNORE( isCsd = IsBearerCSDL() );

    TInt inboxTime = RetrievalIntervalInMinutes( LoadSettingL<TInt>( 

            TImumDaSettings::EKeyAutoRetrievalInterval, EFalse ));

    if ( inboxTime <= KAlwaysOnlineMaxLimit && !isCsd )

        {

        iImap4StateFlags.SetFlag( EAlwaysOnlineImap4StayOnline );

        }

    else

        {

        iImap4StateFlags.ClearFlag( EAlwaysOnlineImap4StayOnline );

        }

    }

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

// StartL()

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

void CAlwaysOnlineImap4Agent::StartL()

    {

    AOLOG_IN( "CAlwaysOnlineImap4Agent::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("CAlwaysOnlineImap4Agent::StartL() We have been suspended, not starting!");

            return;

            }

        iState = EEmailAgentInitialised;

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineImap4Agent::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("CAlwaysOnlineImap4Agent::StartL(). Activated startDelayWait 5sec Op Id: %d ",iStartDelayOpId );

        }//if

    else

        {

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

        }

    }

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

// ResumeL()

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

void CAlwaysOnlineImap4Agent::ResumeL( const TBool aConnectNow )

    {

    AOLOG_IN( "CAlwaysOnlineImap4Agent::ResumeL" );

    CAlwaysOnlineEmailAgentBase::ResumeL( aConnectNow );

	// just make sure that connection will not stay open

	iImap4StateFlags.ClearFlag( EAlwaysOnlineImap4StayOnline );

    }

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

// CreateImap4OperationL()

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

void CAlwaysOnlineImap4Agent::CreateImap4OperationL(

    TInt aFunctionId,

    TBool aCompletedOperation /*= EFalse*/ )

    {

    AOLOG_IN( "CAlwaysOnlineImap4Agent::CreateImap4OperationL" );

    TMsvOp dummy;

    CreateImap4OperationL( dummy, aFunctionId, aCompletedOperation );

    }

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

// CreateImap4OperationL()

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

void CAlwaysOnlineImap4Agent::CreateImap4OperationL(

    TMsvOp& aOpId,

    TInt aFunctionId,

    TBool aCompletedOperation /*= EFalse*/ )

    {

    AOLOG_IN( "CAlwaysOnlineImap4Agent::CreateImap4OperationL" );

    KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineImap4Agent::CreateImap4OperationL() 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("CAlwaysOnlineImap4Agent::CreateImap4OperationL: ADDING COMPLETED OPERATION. ID: %d", aOpId );

        }

    else

        {

        TPckg<MMsvImapConnectionObserver*> param( this );

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

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

        op = iImap4ClientMtm->InvokeAsyncFunctionL(

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

        aOpId = op->Id();

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineImap4Agent::CreateImap4OperationL: 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

    }

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

// ConnectAndUpdateHeadersL()

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

void CAlwaysOnlineImap4Agent::ConnectAndUpdateHeadersL()

    {

    AOLOG_IN( "CAlwaysOnlineImap4Agent::ConnectAndUpdateHeadersL" );

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

    //Just connect. Whether to stay online or just poll, is decided elsewhere

    if ( iImap4StateFlags.Flag( EAlwaysOnlineImap4StayOnline ) && !IsEmn() )

        {

        KAOEMAIL_LOGGER_WRITE(" CAlwaysOnlineImap4Agent::ConnectAndUpdateHeadersL() Connecting to stay online");

        //do full sync, inbox and folders

        CreateImap4OperationL( iConnectAndStayOnlineOpId,

            KIMAP4MTMConnectAndSyncCompleteAfterDisconnect,

            EFalse );

        iState = EEmailAgentConnectingToStayOnline;

        //folder sync is started from HandleImapConnectionEvent after sync completes

        //mail partial fetch is also started from HandleImapConnectionEvent

        }

    else

        {

        KAOEMAIL_LOGGER_WRITE(" CAlwaysOnlineImap4Agent::ConnectAndUpdateHeadersL() Doing plaing connect");

        //just connect. After this completes, sync is invoked elsewhere

        CreateImap4OperationL( iConnectOpId, KIMAP4MTMConnect, EFalse );

        iState = EEmailAgentPlainConnecting;

        }

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

    }

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

// DisconnectL()

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

void CAlwaysOnlineImap4Agent::DisconnectL( TBool aAutomatic )

    {

    AOLOG_IN( "CAlwaysOnlineImap4Agent::DisconnectL" );

    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineImap4Agent::DisconnectL");

    TBuf8<1> dummyParams;

    dummyParams.Zero();

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

    CleanupStack::PushL( watcher );

    CMsvOperation* op = NULL;

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

        {

        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineImap4Agent::DisconnectL() Connected");

        CMsvEntrySelection* selection = new(ELeave) CMsvEntrySelection;

        CleanupStack::PushL( selection );

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

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

        op = iImap4ClientMtm->InvokeAsyncFunctionL(

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

        iDisconnectOpId = op->Id();

        CleanupStack::PopAndDestroy( selection );//selection

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineImap4Agent::DisconnectL: ADDING DISCONNECT OPERATION: %d", iDisconnectOpId );

        }

    else

        {

        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineImap4Agent::DisconnectL() Not connected");

        //already disconnected

        op = CMsvCompletedOperation::NewL(

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

                KMsvLocalServiceIndexEntryId,

                watcher->iStatus, KErrCancel);

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineImap4Agent::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("CAlwaysOnlineImap4Agent::DisconnectL. Setting state:  %d ",iState );

        }

    else

        {

        iState = EEmailAgentUserDisconnecting;

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

        }

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineImap4Agent::DisconnectL");

    }

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

// SynchroniseNewL()

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

void CAlwaysOnlineImap4Agent::SynchroniseNewL()

    {

    AOLOG_IN( "CAlwaysOnlineImap4Agent::SynchroniseNewL" );

    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineImap4Agent::SynchroniseNewL");

    TBuf8<1> dummyParams;

    dummyParams.Zero();

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

    CleanupStack::PushL( watcher );

    CMsvOperation* op = NULL;

    //we must be connected to use inboxnewsync

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

        {

        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineImap4Agent::SynchroniseNewL() Connected");

        SetLastSuccessfulUpdate();

        CMsvEntrySelection* selection = new(ELeave) CMsvEntrySelection;

        CleanupStack::PushL( selection );

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

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

        op = iImap4ClientMtm->InvokeAsyncFunctionL(

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

        iSyncOpId = op->Id();

        CleanupStack::PopAndDestroy( selection );//selection

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineImap4Agent::SynchroniseNewL: Adding synchronise new operation. ID: %d", iSyncOpId );

        iState = EEmailAgentSynchronising;

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineImap4Agent::SynchroniseNewL. Setting state:  %d ",iState );

        }

    else

        {

        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineImap4Agent::SynchroniseNewL() Not connected");

        //for some reason we have been disconnected before we got to sync part. Invoke normal retry procedure

        iError = KErrDisconnected; //this error will cause us to retry

        op = CMsvCompletedOperation::NewL(

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

                KMsvLocalServiceIndexEntryId,

                watcher->iStatus, KErrCancel);

        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineImap4Agent::SynchroniseNewL: Connection was dropped, retry!" );

        }

    CleanupStack::PushL( op );

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

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

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineImap4Agent::SynchroniseNewL");

    }

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

// HandleImapConnectionEvent() from MMsvImapConnectionObserver

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

void CAlwaysOnlineImap4Agent::HandleImapConnectionEvent(

    TImapConnectionEvent aConnectionEvent )

    {

    AOLOG_IN( "CAlwaysOnlineImap4Agent::HandleImapConnectionEvent" );

    TInt trapErr = KErrNone;

    switch ( aConnectionEvent )

        {

        case ESynchronisationComplete:

            //we can reset retrycounter when sync has occurred. Because it can be

            //taken as success, so it would not be retrying for same connection anymore.

            iRetryCounter = 0;

            //this event can be used also to set last successful update

            SetLastSuccessfulUpdate();

            if ( iImap4StateFlags.Flag( EAlwaysOnlineImap4StayOnline ) /*iStayOnline*/ )

                {

                if ( iFilteredPopulateOpId == KErrNotFound )

                    {

                    // start fetch new mail operation

                    TRAP( trapErr, FetchNewMailL() );

                    if ( trapErr != KErrNone )

                        {

                        // try to start folder sync timer not the folder sync itself, because

                        // they were synced on connect already

                        TRAP( trapErr, StartFolderSyncTimerL() );

                        }

                    }

                }

            break;

        case EDisconnecting:

            break;

        case EConnectionCompleted:

            break;

        default:

            break;

        }

    TRAP_IGNORE( CallNewMessagesL() );

    }

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

// ChangeNextStateL

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

void CAlwaysOnlineImap4Agent::ChangeNextStateL()

    {

    AOLOG_IN( "CAlwaysOnlineImap4Agent::ChangeNextStateL" );

    AOLOG_WRMV( "start iState: ", EAoMailPluginStates, iState, EAoLogSt3 );

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

    if ( iState == EEmailAgentAutoDisconnecting &&

         iImap4StateFlags.Flag( EAlwaysOnlineImap4RemoveMeImmediately ) )

        {

        if ( !iImap4StateFlags.Flag( EAlwaysOnlineImap4DontRemoveOnDisconnect ) )

            {

            KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineImap4Agent::ChangeNextStateL() RemoveMeL 0x%x", iEntry->Entry().Id() );

            RemoveMe();

            return;

            }

        else

            {

            KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineImap4Agent::ChangeNextStateL() change 0x%x back to normal", iEntry->Entry().Id() );

            iImap4StateFlags.ClearFlag( EAlwaysOnlineImap4DontRemoveOnDisconnect );

            iImap4StateFlags.ClearFlag( EAlwaysOnlineImap4TemporaryConnectionObserver );

            iImap4StateFlags.ClearFlag( EAlwaysOnlineImap4DontReconnect );

            iImap4StateFlags.ClearFlag( EAlwaysOnlineImap4StayOnline );

            iImap4StateFlags.ClearFlag( EAlwaysOnlineImap4RemoveMeImmediately );

            }

        }

    //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 been saved with always online or mail

        // message notifications on.

        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

                    {

                    //CheckAndHandleScheduling started waitForStopTimer

                    StartWaitTimerL();

                    }

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

                }

            else

                {

                iState = EEmailAgentIdle;

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

                }

            break;

        //case EEmailAgentConnected:

        case EEmailAgentConnecting:

            DisconnectL( ETrue );

            break;

        case EEmailAgentPlainConnecting:

            SynchroniseNewL();

            break;

        case EEmailAgentSynchronising:

            FetchNewMailL(); //check filtering options and acts accordingly

            break;

        case EEmailAgentFetching:

            if ( IsTemporary() || ( iImap4StateFlags.Flag( EAlwaysOnlineImap4StayOnline ) &&

                !IsEmn() ) )

                {

                StartFolderSyncTimerL();

                }

            else

                {

                DisconnectL( ETrue );// Folder's not synchronized when EMN is on

                }

            break;

        case EEmailAgentConnectingToStayOnline:

            //if this has completed, we have to connect again

            ConnectIfAllowedL( iConnectAndStayOnlineOpId );

            break;

        case EEmailAgentConnectFailed:

        case EEmailAgentQueued:

        case EEmailAgentReconnecting:

        case EEmailAgentAutoDisconnecting:

        case EEmailAgentUserDisconnecting:

        case EEmailAgentConnTerminated://red key

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

            if ( IsReconnectAfterError() )

                {

                StartWaitTimerL();

                }

            else

                {

                DisconnectL( ETrue );// Folder's not synchronized when EMN is on