/*

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

*     Contains mailbox specified always online logic

*

*/

//<cmail> internal dependency removed

/*#ifdef _DEBUG

#include "../../internal/IpsSosAOPluginTester/inc/IpsSosAOPluginTester.hrh"

#endif // _DEBUG*/

//</cmail>

#include <cmmanager.h>

#include "emailtrace.h"

#include "IpsSosAOMboxLogic.h"

#include "IpsSosAOSchedulerUtils.h"

#include "IpsSosAOPlugin.hrh"

#include "IpsSosAOImapPopLogic.h"

const TInt KIpsSosAOMboxLogicMinGra = 1;

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

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

//

CIpsSosAOMBoxLogic::CIpsSosAOMBoxLogic( 

        CMsvSession& aSession, 

        TMsvId aMailboxId ) :

    iSession( aSession ), iMailboxId( aMailboxId ), iState( EStateError ),

    iErrorCounter( 0 ), iError( KErrNone ), iTimer( NULL ),

    {

    FUNC_LOG;

    }

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

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

//

CIpsSosAOMBoxLogic::~CIpsSosAOMBoxLogic()

    {

    FUNC_LOG;

    delete iTimer;

    delete iAgent;

    iFetchMsgArray.Close();

    }

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

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

//

CIpsSosAOMBoxLogic* CIpsSosAOMBoxLogic::NewL( 

        CMsvSession& aSession,

        TMsvId aMailboxId )

    {

    FUNC_LOG;

    CIpsSosAOMBoxLogic* self = new (ELeave) CIpsSosAOMBoxLogic( 

            aSession,  aMailboxId );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

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

//

void CIpsSosAOMBoxLogic::ConstructL()

    {

    FUNC_LOG;

    iTimer = CIpsSosAOPluginTimer::NewL( CActive::EPriorityStandard, *this );

    iAgent = CIpsSosAOBaseAgent::CreateAgentL( iSession, *this, iMailboxId );

    LoadSettingsL();

    }

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

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

//   

void CIpsSosAOMBoxLogic::TimerFiredL()

    {

    FUNC_LOG;

    HandleEventAndSwitchStateL( EEventTimerFired );

    }

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

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

//   

void CIpsSosAOMBoxLogic::OperationCompletedL( TInt aError )

    {

    FUNC_LOG;

    iError = aError;

    HandleEventAndSwitchStateL( EEventOperationCompleted );

    iError = KErrNone;

    }

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

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

//  

void CIpsSosAOMBoxLogic::SendCommandL( TInt aCommand )

    {

    FUNC_LOG;

    switch ( aCommand )

        {

        case ECommandStart:

            HandleEventAndSwitchStateL( EEventStart );

            break;

        case ECommandStop:

            HandleEventAndSwitchStateL( EEventStopAndRemoveOps );

            break;

        case ECommandSuspend:

            HandleEventAndSwitchStateL( EEventSuspendOperations );

            break;

        case ECommandContinue:

            HandleEventAndSwitchStateL( EEventContinueOperations );

            break;

        case ECommandStartSync:

            HandleEventAndSwitchStateL( EEventStartSync );

            if ( iState != EStateSyncOngoing )

                {

                User::Leave( KErrGeneral );

                }

            break;

        case ECommandStartedRoaming:

            iIsRoaming = ETrue;

            if ( !CanConnectIfRoamingL() )

                {

                HandleEventAndSwitchStateL( EEventStopAndRemoveOps );

                }

            break;

        case ECommandStoppedRoaming:

            iIsRoaming = EFalse;

            HandleEventAndSwitchStateL( EEventStart );

            break;

        case ECommandCancelAndDisconnect:

            iAgent->CancelAllAndDisconnectL();

            CalculateToNextIntervalL();

            break;

        case ECommandCancelDoNotDiconnect:

            if ( iAgent->GetState() != CIpsSosAOBaseAgent::EStateCompleted ||

                    iAgent->GetState() != CIpsSosAOBaseAgent::EStateIdle  )

                {

                iAgent->CancelAllAndDoNotDisconnect();

                CalculateToNextIntervalL();

                }

            break;

        case ECommandClearDoNotDisconnect:

            iAgent->ClearDoNotDisconnect();

            break;

        case ECommandDoNotDisconnect:

            iAgent->DoNotDisconnect();

            break;

        default:

            break;

        }

    }

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

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

//  

void CIpsSosAOMBoxLogic::FetchMessagesL( const RArray<TMsvId> aArray )

    {

    FUNC_LOG;

    LoadSettingsL();

    for ( TInt i = 0; i < aArray.Count(); i++ )

        {

        iFetchMsgArray.AppendL( aArray[i] );

        }

    HandleEventAndSwitchStateL( EEventFetchMessages );

    }

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

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

//  

TMsvId CIpsSosAOMBoxLogic::GetMailboxId()

    {

    FUNC_LOG;

    return iMailboxId;

    }

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

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

//  

CIpsSosAOBaseAgent& CIpsSosAOMBoxLogic::GetAgent() const

    {

    FUNC_LOG;

    return *iAgent;

    }

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

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

// 

TBool CIpsSosAOMBoxLogic::IsEmnOn() const

    {

    FUNC_LOG;

    TBool ret = ETrue;

    TIpsSetDataEmnStates state = EMailEmnOff;

    if ( iExtendedSettings )

        {

        state = iExtendedSettings->EmailNotificationState();

        }

    if ( state == EMailEmnOff )

        {

        ret = EFalse;

        }

    return ret;

    }

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

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

// 

void CIpsSosAOMBoxLogic::GetEmailAddress(  

    {

    FUNC_LOG;

    const TDesC& addr = iExtendedSettings->EmailAddress();

    __ASSERT_DEBUG( ( 

            addr.Length() <= KIpsSosAOTextBufferSize ), 

            User::Panic( KIpsSosAOPanicLit, KErrGeneral) );

    if ( addr.Length() <= KIpsSosAOTextBufferSize )

        {

        aEmailAddress.Copy( addr );

        }

    }

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

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

//<cmail>

//</cmail>

    {

    LoadSettingsL();

    iExtendedSettings->SetEmnReceivedButNotSyncedFlag( aNewValue );

    iDataApi->SaveExtendedSettingsL(

        *iExtendedSettings );

    }

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

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

//

//<cmail>

TBool CIpsSosAOMBoxLogic::IsMailboxRoamingStoppedL()

//</cmail>

    {

    TBool ret = EFalse;

    if ( iIsRoaming && !CanConnectIfRoamingL() )

        {

        ret = ETrue;

        }

    return ret;

    }

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

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

//  

void CIpsSosAOMBoxLogic::HandleEventAndSwitchStateL( 

        TInt aEvent )

    {

    FUNC_LOG;

    TInt event = aEvent;

    TInt cycles = 0;

    if ( event == EEventStart && iState == EStateError && 

            CanConnectIfRoamingL() )

        {

        event = EEventNop;

        iAgent->LoadSettingsL();

        iTimer->Cancel();

        iTimer->After( KIpsSosAOStartDelaySeconds );

        iState = EStateWaitSyncStart;

        }

    while ( event != EEventNop && iState != EStateError )

        {

//<cmail> removing flags    

/*#ifdef IPSSOSIMAPPOLOGGING_ON

        WriteDebugData( event );

#endif*/

//</cmail>

        switch ( event )

            {

            case EEventTimerFired:

                event = HandleTimerFiredL();

              break;

            case EEventStartSync:

                if ( iState == EStateWaitSyncStart )

                    {         

                    iError = KErrNone;

                    iAgent->StartSyncL();

                    iState = EStateSyncOngoing;

                    }

                else if ( iState == EStateIdleAndWaitCommands )

                    {

                    // start sync command in idle state is currently 

                    // received when emn arrives, checking scheduling 

                    // if user have selected week days / hours in setting

                    CIpsSosAOSchedulerUtils* scheduler = 

                        CIpsSosAOSchedulerUtils::NewLC( *iExtendedSettings );

                    TTimeIntervalSeconds seconds;

                    if ( type == EAOCConnectAfter )

                        {

                        iState = EStateWaitSyncStart;

                        iTimer->After( seconds );

                        //<cmail>

                        SetEmnReceivedFlagL( ETrue );

                        //</cmail>

                        }

                    else

                        {

                        iError = KErrNone;

                        iAgent->StartSyncL();

                        iState = EStateSyncOngoing;

                        }

                    }

                // ignore in other states

                event = EEventNop;

                break;

            case EEventFetchMessages:

                if ( ( iState == EStateWaitSyncStart || 

                       iState == EStateIdleAndWaitCommands ) &&

                        iFetchMsgArray.Count() > 0 )

                    {

                    iError = KErrNone;

                    iAgent->StartFetchMessagesL( iFetchMsgArray );

                    iFetchMsgArray.Reset();

                    iState = EStateFetchOngoing;

                    }

                else 

                    {

                    // ignore event in other states

                    iFetchMsgArray.Reset();

                    }

                event = EEventNop;

                break;

            case EEventOperationCompleted:

                event = HandleOperationCompletionL();

                break;

            case EEventSuspendOperations:

                SuspendOperations();

                iState = EStateSuspended;

                event = EEventNop;

                break;

            case EEventContinueOperations:

                if ( iState == EStateSuspended )

                    {

                    iTimer->After( KIpsSosAOContinueWaitTime );

                    }

                else

                    {

                    event = EEventNop;

                    }

                // ignore if in other states

                break;

            case EEventStopAndRemoveOps:

                // notify deletion

                iAgent->CancelAllAndDisconnectL();

                iTimer->Cancel();

                iState = EStateError;

                event = EEventNop;

                break;

            case EEventStart:

            default:

                // ignore other events

                event = EEventNop;

                break;

            }

        // TO Prevent forever loop (and freezing) 

        // if there is programming error in state machine logic

        __ASSERT_ALWAYS( ( 

                cycles < KIpsSosAOMaxStateCycles ), 

                User::Panic( KIpsSosAOPanicLit, KErrGeneral) );

        ++cycles;

        }

    }

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

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

// 

TInt CIpsSosAOMBoxLogic::GetCurrentState() const

    {

    FUNC_LOG;

    return iState;

    }

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

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

// 

TInt CIpsSosAOMBoxLogic::GetCurrentError() const

    {

    FUNC_LOG;

    return iError;

    }

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

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

// 

TInt CIpsSosAOMBoxLogic::HandleTimerFiredL()

    {

    FUNC_LOG;

    // panic if we are in wrong state;

    __ASSERT_DEBUG( ( iState == EStateWaitSyncStart || 

            iState == EStateSuspended ), 

            User::Panic( KIpsSosAOPanicLit, KErrGeneral) );

    // handle emn

    TInt event = EEventNop;

    CIpsSosAOBaseAgent::TAgentState agentState = iAgent->GetState();

    if ( iState == EStateSuspended &&

        ( agentState == CIpsSosAOBaseAgent::EStateConnectAndSyncOnHold || 

          agentState == CIpsSosAOBaseAgent::EStatePopulateOnHold ) )

        {

        iAgent->ContinueHoldOperations();

        iState = EStateSyncOngoing;

        }

    else if ( iState == EStateSuspended && 

            agentState == CIpsSosAOBaseAgent::EStateFetchOnHold )

        {

        iAgent->ContinueHoldOperations();

        iState = EStateFetchOngoing;

        }

    else

        {

        event = CheckSchedulingAndSwitchStateL();

        }

    // in other states, timer event is ignored

    return event;

    }

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

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

// 

TInt CIpsSosAOMBoxLogic::HandleOperationCompletionL()

    {

    FUNC_LOG;

    TInt event = EEventNop;

    if ( iState == EStateSyncOngoing )

        {

        if ( !( iError == KErrNone || iError == KErrCancel ) )

            {

            ++iErrorCounter;

            }

        else

            {

            iError = KErrNone;

            iErrorCounter = 0;

            }

        //<cmail>

        if ( iError != KErrNone && 

                IsErrorFatalL( iError ) )

        //</cmail>

            {

            iAgent->CancelAllAndDisconnectL();

            // switch ao off

            iExtendedSettings->SetAlwaysOnlineState( EMailAoOff );

            // emn not swithced of if its going to be "always on" in

            // future

            iExtendedSettings->SetEmnReceivedButNotSyncedFlag( EFalse );

            iDataApi->SaveExtendedSettingsL(

                *iExtendedSettings );

            iState = EStateError;

            iErrorCounter = 0;

            }

        else if ( iError != KErrNone && 

                iErrorCounter < KIpsSosAOMaxReTryTimes )

            {

            // not fatal error

            TIpsSetDataAoStates state = iExtendedSettings->AlwaysOnlineState();