/*

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

*     Contains mailbox specified always online logic

*

*/

//<Qmail>

#include <cmmanager.h>

//</Qmail>

#include "emailtrace.h"

#include "IpsSosAOMboxLogic.h"

//<QMail>

#include "IpsSosAOSettingsHandler.h"

//</QMail>

#include "IpsSosAOSchedulerUtils.h"

#include "IpsSosAOPlugin.hrh"

#include "IpsSosAOImapPopLogic.h"

//<QMail>

const TInt KAOSecondsInMinute = 60;

//</QMail>

const TInt KIpsSosAOMboxLogicMinGra = 1;

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

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

//

CIpsSosAOMBoxLogic::CIpsSosAOMBoxLogic( 

        CMsvSession& aSession, 

        TMsvId aMailboxId ) :

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

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

	//<QMail>

    iFetchMsgArray( KIpsSosAOMboxLogicMinGra ), iAgent( NULL ),

    iIsRoaming( EFalse )

	//</QMail>

    {

    FUNC_LOG;

    }

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

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

//

CIpsSosAOMBoxLogic::~CIpsSosAOMBoxLogic()

    {

    FUNC_LOG;

    delete iTimer;

	//<QMail>

	//</QMail>

    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 );

	//<QMail>

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

    //</QMail>

    }

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

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

//   

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;

    //<Qmail>

    //</Qmail>

    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;

	//<QMail>

    CIpsSosAOSettingsHandler* settings = NULL;

    TRAP_IGNORE( settings = 

            CIpsSosAOSettingsHandler::NewL(iSession, iMailboxId));

    if( settings )

        {

        IpsServices::TIpsSetDataEmnStates state = IpsServices::EMailEmnOff;

        state = settings->EmailNotificationState();

        if ( state == IpsServices::EMailEmnOff )

            {

            ret = EFalse;

            }

        delete settings;

        }

	//</QMail>

    return ret;

    }

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

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

// 

//<QMail>

void CIpsSosAOMBoxLogic::GetEmailAddress(  

    TBuf<KIpsSosAOTextBufferSize>& aEmailAddress ) const

    {

    FUNC_LOG;

    CIpsSosAOSettingsHandler* settings = NULL;

    TRAPD( err, settings = CIpsSosAOSettingsHandler::NewL(

            iSession, iMailboxId) );

    if( settings )

        {

        HBufC* addr = NULL;

        TRAP(err, addr = settings->EmailAddressL());

        if( addr )

            {

            __ASSERT_DEBUG( ( 

                    addr->Length() <= KIpsSosAOTextBufferSize ), 

                    User::Panic( KIpsSosAOPanicLit, KErrGeneral) );

            if ( addr->Length() <= KIpsSosAOTextBufferSize )

                {

                aEmailAddress.Copy( *addr );

                }

            delete addr;

            }   

        delete settings;

        }

	//<QMail>

    }

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

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

//<QMail>

void CIpsSosAOMBoxLogic::SetEmnReceivedFlagL( TBool aNewValue )

    {

    CIpsSosAOSettingsHandler* settings = 

            CIpsSosAOSettingsHandler::NewL(

                iSession, iMailboxId );

    CleanupStack::PushL(settings);

    settings->SetEmnReceivedButNotSyncedFlag( aNewValue );

    CleanupStack::PopAndDestroy(settings);

	//</QMail>

    }

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

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

//

TBool CIpsSosAOMBoxLogic::IsMailboxRoamingStoppedL()

    {

    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 && 

          ( (iIsRoaming && CanConnectIfRoamingL())||

             !iIsRoaming ) )

        {

        event = EEventNop;

        iAgent->LoadSettingsL();

        iTimer->Cancel();

        iTimer->After( KIpsSosAOStartDelaySeconds );

        iState = EStateWaitSyncStart;

        }

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

        {

        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

					//<QMail>

                    CIpsSosAOSettingsHandler* settings = 

                             CIpsSosAOSettingsHandler::NewL(iSession, iMailboxId);

                    CleanupStack::PushL(settings);

                    CIpsSosAOSchedulerUtils* scheduler = 

                        CIpsSosAOSchedulerUtils::NewLC( *settings );

                    TTimeIntervalSeconds seconds;

                    TIpsSosAOConnectionType type = 

                            scheduler->SecondsToNextMark( seconds );

					//</QMail>

                    if ( type == EAOCConnectAfter )

                        {

                        iState = EStateWaitSyncStart;

                        iTimer->After( seconds );

                        SetEmnReceivedFlagL( ETrue );

                        }

                    else

                        {

                        iError = KErrNone;

                        iAgent->StartSyncL();

                        iState = EStateSyncOngoing;

                        }

					//<QMail>

                    CleanupStack::PopAndDestroy( 2, settings );

					//</QMail>

                    }

                // 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;

	//<Qmail>

    CIpsSosAOSettingsHandler* settings = 

             CIpsSosAOSettingsHandler::NewL(iSession, iMailboxId);

    CleanupStack::PushL(settings);

	//</Qmail>     

    if ( iState == EStateSyncOngoing )

        {

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

            {

            ++iErrorCounter;

            }

        else

            {

            iError = KErrNone;

            iErrorCounter = 0;