/*

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

*     Agent which holds an array of email protocol specific agents

*

*/

#include <MuiuMsvUiServiceUtilities.h>

#include <SenduiMtmUids.h>

#include <ImumInternalApi.h>            // CImumInternalApi

#include <ImumInSettingsData.h>         // CImumInSettingsData

#include <AlwaysOnlineManagerCommon.h>

#include "AlwaysOnlineEmailAgent.h"

#include "AlwaysOnlineImapAgent.h"

#include "AlwaysOnlinePopAgent.h"

#include "AlwaysOnlineEmailPluginTimer.h"

#include "AlwaysOnlineEmailEMNResolver.h"

#include "AlwaysOnlineEmailPluginLogging.h"

#include "AlwaysOnlineEmailLoggingTools.h"

const TInt KAOHalfSecond = 500000;

const TInt KEmailAgentArrayGranularity = 2;

// How many times we try to load mail settings before giving up.

const TInt KMailSettingsRetryCount     = 3;

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

// CAlwaysOnlineEmailAgent::CAlwaysOnlineEmailAgent()

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

CAlwaysOnlineEmailAgent::CAlwaysOnlineEmailAgent(

    CMsvSession& aMsvSession,

    MAlwaysOnlineStatusQueryInterface& aAlwaysOnlineManager)

    :

    iAlwaysOnlineManager( aAlwaysOnlineManager ),

    iSession( aMsvSession ),

    iEmnResolver( NULL )

    {

    }

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

// CAlwaysOnlineEmailAgent::~CAlwaysOnlineEmailAgent()

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

CAlwaysOnlineEmailAgent::~CAlwaysOnlineEmailAgent()

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::~CAlwaysOnlineEmailAgent" );

    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgent::~CAlwaysOnlineEmailAgent");

    if ( iMailAgentArray )

        {

        iMailAgentArray->ResetAndDestroy();

        }

    delete iMailAgentArray;

    delete iClientMtmRegistry;

    delete iEmnResolver;

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgent::~CAlwaysOnlineEmailAgent");

    }

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

// CAlwaysOnlineEmailAgent::NewL()

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

CAlwaysOnlineEmailAgent* CAlwaysOnlineEmailAgent::NewL(

    CMsvSession& aMsvSession,

    MAlwaysOnlineStatusQueryInterface& aAlwaysOnlineManager )

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::NewL" );

    CAlwaysOnlineEmailAgent* self = new (ELeave)CAlwaysOnlineEmailAgent(

        aMsvSession, aAlwaysOnlineManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CAlwaysOnlineEmailAgent::ConstructL

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

void CAlwaysOnlineEmailAgent::ConstructL()

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::ConstructL" );

    iClientMtmRegistry = CClientMtmRegistry::NewL( iSession );

    iMailAgentArray = new (ELeave) CAOEmailAgentArray(

        KEmailAgentArrayGranularity );

    iEmnResolver = CAlwaysOnlineEmailEMNResolver::NewL();

    }

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

// CAlwaysOnlineEmailAgent::StartL()

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

void CAlwaysOnlineEmailAgent::StartL()

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::StartL" );

    RefreshMailAgentArrayL();

    ActivateOnlineMailboxesL();

    }

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

// CAlwaysOnlineEmailAgent::SuspendNWOperationsL()

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

void CAlwaysOnlineEmailAgent::SuspendNWOperationsL()

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::SuspendNWOperationsL" );

    const TInt count = iMailAgentArray->Count();

    for ( TInt loop = 0; loop < count; loop++ )

        {

        iMailAgentArray->At( loop )->Suspend();

        }

    }

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

// CAlwaysOnlineEmailAgent::ResumeNWOperationsL()

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

void CAlwaysOnlineEmailAgent::ResumeNWOperationsL()

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::ResumeNWOperationsL" );

    const TInt count = iMailAgentArray->Count();

    for ( TInt loop = 0; loop < count; loop++ )

        {

        iMailAgentArray->At( loop )->ResumeL();

        }

    }

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

// CAlwaysOnlineEmailAgent::RoamingEventL()

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

void CAlwaysOnlineEmailAgent::RoamingEventL()

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::RoamingEventL" );

    const TInt count = iMailAgentArray->Count();

    for ( TInt loop = 0; loop < count; loop++ )

        {

        iMailAgentArray->At( loop )->HandleRoamingEventL();

        }

    }

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

// CAlwaysOnlineEmailAgent::HomeNetworkEventL()

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

void CAlwaysOnlineEmailAgent::HomeNetworkEventL()

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::HomeNetworkEventL" );

    const TInt count = iMailAgentArray->Count();

    for ( TInt loop = 0; loop < count; loop++ )

        {

        iMailAgentArray->At( loop )->HandleHomeNetworkEventL();

        }

    }

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

// CAlwaysOnlineEmailAgent::HandleOutOfDiskL()

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

void CAlwaysOnlineEmailAgent::HandleOutOfDiskL()

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::HandleOutOfDiskL" );

    const TInt count = iMailAgentArray->Count();

    for ( TInt loop = 0; loop < count; loop++ )

        {

        iMailAgentArray->At( loop )->HandleOutOfDiskEventL();

        }

    }

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

// CAlwaysOnlineEmailAgent::HandleEMNMessageL()

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

void CAlwaysOnlineEmailAgent::HandleEMNMessageL(

    const TDesC8& aParameters )

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::HandleEMNMessageL" );

    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgent::HandleEMNL");

    TEMNElement elements;

    if ( iEmnResolver->ParameterDispatchTEMNElement(

        aParameters, elements ) == KErrNone )

        {

        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgent::HandleEMNL(): Find EMN mailbox" );

        CAlwaysOnlineEmailAgentBase* mailbox =

            iEmnResolver->FindEMNMailbox( elements.mailbox, *iMailAgentArray );

        if ( mailbox )

            {

            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgent::HandleEMNL(): EMN mailbox found" );

            mailbox->ConnectL();

            }

        else

            {

            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgent::HandleEMNL(): EMN mailbox not found" );

            }

        }

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgent::HandleEMNL");

    }

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

// CAlwaysOnlineEmailAgent::GetMailboxesLC()

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

CMsvEntrySelection* CAlwaysOnlineEmailAgent::GetMailboxesLC()

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::GetMailboxesLC" );

    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgent::GetMailboxesLC");

    CMsvEntrySelection* mailboxSelection =

        MsvUiServiceUtilities::GetListOfAccountsWithMTML(

            iSession, KSenduiMtmImap4Uid );

	CleanupStack::PushL( mailboxSelection );

    CMsvEntrySelection* pop3Selection =

        MsvUiServiceUtilities::GetListOfAccountsWithMTML(

            iSession, KSenduiMtmPop3Uid );

	CleanupStack::PushL( pop3Selection );

    const TInt count = pop3Selection->Count();

    TInt loop = 0;

    for ( loop = 0; loop < count; loop++ )

        {

        mailboxSelection->AppendL( (*pop3Selection)[loop] );

        }

    CleanupStack::PopAndDestroy( pop3Selection );

    pop3Selection = NULL;

    // remove mailboxes from mailboxSelection which are already in iMailAgentArray

    for ( loop = mailboxSelection->Count() - 1; loop >= 0; loop-- )

        {

        if ( FindMailbox( (*mailboxSelection)[loop] ) )

            {

            // already in iMailAgentArray, delete it

            mailboxSelection->Delete( loop );

            }

        }

    // mailboxSelection in CleanupStack

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgent::GetMailboxesLC");

    return mailboxSelection;

	}

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

// CAlwaysOnlineEmailAgent::RefreshMailAgentArrayLC

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

void CAlwaysOnlineEmailAgent::RefreshMailAgentArrayL()

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::RefreshMailAgentArrayL" );

    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgent::RefreshMailAgentArrayL");

    // delete first mailboxes from the iMailAgentArray, which does not exists anymore.

    TInt cnt = iMailAgentArray->Count();

    TBool isHealthy = EFalse;

    TBool setActive = EFalse;

    TMsvId mailboxId;

    TMsvEntry tEntry;

    TMsvId service;

    CImumInternalApi* emailApi = CreateEmailApiLC( &iSession );

    KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgent::RefreshMailAgentArrayL() Mail Agents in array: %d", cnt);

    TInt i;

    for ( i = cnt; i > 0; i-- )

        {

        mailboxId = ( *iMailAgentArray )[i-1]->MailboxId();

        isHealthy = emailApi->HealthServicesL().IsMailboxHealthy( mailboxId );

        if ( isHealthy )

            {

            setActive = IsMailAgentActiveL( mailboxId );

            KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgent::RefreshMailAgentArrayL() setActive = %d", setActive);

            }

        //remove if mailbox has been deleted, AO setting disabled,

        //EMN turned off or mailbox is not healthy.

        if ( !setActive || !isHealthy ||

             iSession.GetEntry( mailboxId, service, tEntry ) != KErrNone )

            {

            KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgent::RefreshMailAgentArrayL() Deleting agent for mailbox: %d", mailboxId);

            delete iMailAgentArray->At( i-1 );

            iMailAgentArray->Delete( i-1 );

            }

        }

    // then add new mailboxes...

    CMsvEntrySelection* mailboxes = GetMailboxesLC();

    const TInt count = mailboxes->Count();

    KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgent::RefreshMailAgentArrayL() New mailboxes count: %d", count);

    for ( i = 0; i < count; i++ )

        {

        mailboxId = mailboxes->At( i );

        isHealthy = emailApi->HealthServicesL().IsMailboxHealthy( mailboxId );

        if ( isHealthy && IsMailAgentActiveL( mailboxId ) )

            {

            KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgent::RefreshMailAgentArrayL() Adding agent for mailbox: %d", (*mailboxes)[i]);

            AddMailboxL( ( *mailboxes )[i] );

            }

        }

    CleanupStack::PopAndDestroy( 2, emailApi ); // CSI: 12,47 # nothing wrong here

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgent::RefreshMailAgentArrayL");

    }

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

// CAlwaysOnlineEmailAgent::AddMailboxL

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

CAlwaysOnlineEmailAgentBase* CAlwaysOnlineEmailAgent::AddMailboxL(

    TMsvId aMailboxId )

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::AddMailboxL" );

    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgent::AddMailboxL");

    CAlwaysOnlineEmailAgentBase* mailAgent = NULL;

    if ( !FindMailbox( aMailboxId ) )

        {

        TMsvEntry tEntry;

        TMsvId service;

        if ( iSession.GetEntry( aMailboxId, service, tEntry ) == KErrNone &&

             tEntry.iType == KUidMsvServiceEntry )

            {

            if ( tEntry.iMtm == KSenduiMtmImap4Uid )

                {

                mailAgent = CAlwaysOnlineImap4Agent::NewL(

                    iSession, *iClientMtmRegistry, aMailboxId,

                    iAlwaysOnlineManager, *this );

                CleanupStack::PushL( mailAgent );

                iMailAgentArray->AppendL( mailAgent ); // takes ownership

                CleanupStack::Pop( mailAgent );

                }

            else if ( tEntry.iMtm == KSenduiMtmPop3Uid )

                {

                mailAgent = CAlwaysOnlinePop3Agent::NewL(

                    iSession, *iClientMtmRegistry, aMailboxId,

                    iAlwaysOnlineManager, *this );

                CleanupStack::PushL( mailAgent );

                iMailAgentArray->AppendL( mailAgent ); // takes ownership

                CleanupStack::Pop( mailAgent );

                }

            }

        }

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgent::AddMailboxL");

    return mailAgent;

    }

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

// CAlwaysOnlineEmailAgent::ActivateOnlineMailboxesL

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

void CAlwaysOnlineEmailAgent::ActivateOnlineMailboxesL()

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::ActivateOnlineMailboxesL" );

    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgent::ActivateOnlineMailboxesL");

    const TInt count = iMailAgentArray->Count();

    for ( TInt loop = 0; loop < count; loop++ )

        {

        (*iMailAgentArray)[loop]->StartL();

        }//for

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgent::ActivateOnlineMailboxesL");

    }

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

// CAlwaysOnlineEmailAgent::FindMailbox

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

CAlwaysOnlineEmailAgentBase* CAlwaysOnlineEmailAgent::FindMailbox(

    TMsvId aMailboxId )

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::FindMailbox" );

    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgent::FindMailbox");

    // Get number of agents

    const TInt count = iMailAgentArray->Count();

    CAlwaysOnlineEmailAgentBase* mailAgent = NULL;

    // Search through the agents, until correct is found

    for ( TInt loop = 0; loop < count && !mailAgent; loop++ )

        {

        if ( aMailboxId == (*iMailAgentArray)[loop]->MailboxId() )

            {

            mailAgent = (*iMailAgentArray)[loop];

            }

        }

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgent::FindMailbox");

    // Return the pointer

    return mailAgent;

    }

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

// DeleteMailbox

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

TBool CAlwaysOnlineEmailAgent::DeleteMailbox( TMsvId aMailboxId )

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::DeleteMailbox" );

    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgent::DeleteMailbox");

    const TInt count = iMailAgentArray->Count();

    for ( TInt loop = 0; loop < count; loop++ )

        {

        if ( aMailboxId == (*iMailAgentArray)[loop]->MailboxId() )

            {

            delete iMailAgentArray->At( loop );

            iMailAgentArray->Delete( loop );

            return ETrue;

            }

        }

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgent::DeleteMailbox");

    return EFalse;

    }

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

//  CAlwaysOnlineEmailAgent::MailboxSetActivityL

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

void CAlwaysOnlineEmailAgent::MailboxSetActivityL(

    const TMsvId aMailboxId,

    const TBool  aState )

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::MailboxSetActivityL" );

    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgent::MailboxSetActiviytL");

    // Mailbox settings changed, update the array

    MailboxSettingsChangedL( aMailboxId );

    // Find the agent from array

    CAlwaysOnlineEmailAgentBase* agent = FindMailbox( aMailboxId );

    // Check that the agent is valid

    if ( agent )

        {

        if ( !aState )

            {

            // Suspend the agent

            agent->Suspend();

            }

        else

            {

            agent->ResumeL( ETrue );

            }

        }

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgent::MailboxSetActiviytL");

    }

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

// CAlwaysOnlineEmailAgent::MailboxSettingsChangedL

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

void CAlwaysOnlineEmailAgent::MailboxSettingsChangedL( TMsvId aMailboxId )

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::MailboxSettingsChangedL" );

    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgent::MailboxSettingsChangedL");

    RefreshMailAgentArrayL();

    CAlwaysOnlineEmailAgentBase* mailAgent = FindMailbox( aMailboxId );

    if ( mailAgent )

        {

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgent::MailboxSettingsChangedL() Calling StartL for: %d", aMailboxId);

        mailAgent->StartL();

        }

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgent::MailboxSettingsChangedL");

    }

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

// CAlwaysOnlineEmailAgent::RemoveMailAgentL

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

void CAlwaysOnlineEmailAgent::RemoveMailAgentL()

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::RemoveMailAgentL" );

    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgent::RemoveMailAgentL");

    RefreshMailAgentArrayL();

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgent::RemoveMailAgentL");

    }

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

// CAlwaysOnlineEmailAgent::SwitchOffAllAgentsL

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

void CAlwaysOnlineEmailAgent::SwitchOffAllAgentsL()

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::SwitchOffAllAgentsL" );

    KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgent::SwitchOffAllAgentsL() Deleting all agents from agent array!");

    while ( iMailAgentArray->Count() )

        {

        delete iMailAgentArray->At( 0 );

        iMailAgentArray->Delete( 0 );

        }

    }

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

// CAlwaysOnlineEmailAgent::IsMailAgentActiveL

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

TBool CAlwaysOnlineEmailAgent::IsMailAgentActiveL( TMsvId aMailboxId )

    {

    AOLOG_IN( "CAlwaysOnlineEmailAgent::IsMailAgentActiveL" );

    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgent::IsMailAgentActiveL");

    TMsvEntry entry;

    TMsvId service;

    TInt err = iSession.GetEntry( aMailboxId, service, entry );

    if ( err != KErrNone )

        {

        return EFalse;

        }

    TInt cnt = 0;

    CImumInternalApi* emailApi = CreateEmailApiLC( &iSession );

    CImumInSettingsData* settings = NULL;

    err = KErrNotFound;

    while ( err && cnt < KMailSettingsRetryCount )

        {

        // No need to push, since no leaving method called after

        TRAP( err, settings =

            emailApi->MailboxServicesL().LoadMailboxSettingsL( aMailboxId ) );

        if ( err || !settings )

            {

            // wait for half a second and try again

            RTimer timer;

            TRequestStatus timerStatus;

            timer.CreateLocal();

            timer.After( timerStatus, KAOHalfSecond );

            User::WaitForRequest(timerStatus); // CSI: 94 # not UI code

            cnt++;

            }

        }

    // Did we got settings or did we fail 3 times?

    if ( err && cnt == KMailSettingsRetryCount )

        {

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgent::IsMailAgentActiveL: failed to load settings, leaving. Err = %d", err );

        User::Leave( err );