/*

* Copyright (c) 2007 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: This file implements class CFSNotificationHandlerBase.

*

*/

#include <centralrepository.h>

#include "emailtrace.h"

#include "cfsmailclient.h"

#include "fsnotificationhandlermgr.h"

#include "fsnotificationhandlerbase.h"

#include "cmailhandlerpluginpanic.h"

#include "commonemailcrkeys.h"

#include "freestyleemailcenrepkeys.h"

#include "FreestyleEmailUiConstants.h"

const TInt KTimerDelay = 20;

// ======== MEMBER FUNCTIONS ========

CFSNotificationHandlerBase::CFSNotificationHandlerBase(

    MFSNotificationHandlerMgr& aOwner ) :

    iOwner( aOwner ),

    iObserving( EFalse )

    {

    FUNC_LOG;

    }

void CFSNotificationHandlerBase::ConstructL()

    {

    FUNC_LOG;

    iTimer = CNewMailNotificationTimer::NewL( *this );

    }

CFSNotificationHandlerBase::~CFSNotificationHandlerBase()

    {

    FUNC_LOG;

    REComSession::DestroyedImplementation( iDestructorKey );

    delete iTimer;

    iNewInboxEntries.Reset(); 

    }

CFSMailClient& CFSNotificationHandlerBase::MailClient() const

    {

    FUNC_LOG;

    return iOwner.MailClient();

    }

void CFSNotificationHandlerBase::EventL( TFSMailEvent aEvent, TFSMailMsgId aMailbox,

                                         TAny* aParam1, TAny* aParam2, TAny* aParam3 )

    {

    FUNC_LOG;

    if ( !iObserving )

        {

        return;

        }   

    HandleEventL( aEvent, aMailbox, aParam1, aParam2, aParam3 );

    }

void CFSNotificationHandlerBase::SetObserving( TBool aNewValue )

    {

    FUNC_LOG;

    iObserving = aNewValue;

    }

TBool CFSNotificationHandlerBase::MsgIsUnread( CFSMailMessage& aMessage ) const

    {

    FUNC_LOG;

    TBool read( aMessage.IsFlagSet( EFSMsgFlag_Read ) );

    TBool read_locally( aMessage.IsFlagSet( EFSMsgFlag_Read_Locally ) );

    if ( !read && !read_locally )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

TBool CFSNotificationHandlerBase::MessagesCauseNotificationL( TFSMailMsgId aMailboxId,

                                                              TFSMailMsgId aParentFolderId,

                                                              const RArray<TFSMailMsgId>& aMsgIdList )

    {

    FUNC_LOG;

    CFSMailFolder* parentFolder(

        MailClient().GetFolderByUidL( aMailboxId, aParentFolderId ) );

    if ( !parentFolder )

        {

        // by some reason the folder could not be found..

        return EFalse;

        }

    CleanupStack::PushL( parentFolder );

    CFSMailMessage* newestMsg( NULL );

    TRAPD( notFoundError,

           newestMsg =

               NewestMsgInFolderL( *parentFolder ) );

    if ( notFoundError == KErrNotFound )

        {

        // For some odd reason we are not able to get the newest

        // message from the folder. This should not be possible

        // as we just received notification of a new message.

        // Possibly something has moved/deleted the message?

        return EFalse;

        }

    User::LeaveIfError( notFoundError );

    TTime dateOfNewest( newestMsg->GetDate() );

    delete newestMsg;

    newestMsg = NULL;

    CleanupStack::PopAndDestroy( parentFolder );

    const TInt entriesCount( aMsgIdList.Count() );

    TInt index( entriesCount-1 );

    // go from back of list, as messages are coming from earliest to latest..

    while ( index >= 0 ) 

        {

        // Let's get the message. We need to check from it that

        // it is really unread. This info is stored in the

        // flags. Also check that the message is newest.

        // EFSMsgDataEnvelope is used as TFSMailDetails 

        // so that we get enough data.

        CFSMailMessage*

            currentMessage( MailClient().GetMessageByUidL(

                aMailboxId, 

                aParentFolderId,

                aMsgIdList[index], 

                EFSMsgDataEnvelope ) );

        if ( currentMessage )

            {

            const TTime dateOfCurrentMsg( currentMessage->GetDate() );

            const TBool msgIsUnread( MsgIsUnread( *currentMessage ) );

            delete currentMessage;

            currentMessage = NULL;

            if ( msgIsUnread &&

                 ( dateOfCurrentMsg >= dateOfNewest ) )

                {

                // At least one of the messages is unread and newest.

                return ETrue;

                }

            }

        --index;

        }

    return EFalse;

    }

TBool CFSNotificationHandlerBase::Observing() const

    {

    FUNC_LOG;

    return iObserving;

    }

TBool CFSNotificationHandlerBase::CapabilitiesToContinueL(

    TFSMailEvent aEvent,

    TFSMailMsgId aMailbox,

    TAny* /*aParam1*/,

    TAny* /*aParam2*/,

    TAny* /*aParam3*/ ) const

    {

    FUNC_LOG;

    if ( aEvent != TFSEventMailboxDeleted )

        {

        CFSMailBox* mailBox( MailClient().GetMailBoxByUidL( aMailbox ) );

        if ( !mailBox )

            {

            User::Leave( KErrArgument );

            }

        if ( mailBox->HasCapability( EFSMBoxCapaNewEmailNotifications ) )

            {

            delete mailBox;

            return EFalse;

            }

        else

            {

            delete mailBox;

            return ETrue;

            }

        }

    else

        {

        return ETrue;

        }

    }

void CFSNotificationHandlerBase::HandleEventL(

    TFSMailEvent aEvent,

    TFSMailMsgId aMailbox,

    TAny* aParam1,

    TAny* aParam2,

    TAny* /*aParam3*/ )

    {

    FUNC_LOG;

    // Only event TFSEventNewMail means that the mail is completely new.

    if ( aEvent == TFSEventNewMail )

        {

        // In case of TFSEventNewMail we have parent folder id

        // in aParam2

        TFSMailMsgId* parentFolderId( NULL );

        parentFolderId = static_cast< TFSMailMsgId* >( aParam2 );

        if ( !parentFolderId )

            {

            User::Leave( KErrArgument );

            }

        // Set the notification on only in cases that the new mail is

        // in folder of type EFSInbox

        if ( iOwner.GetFolderTypeL( aMailbox, parentFolderId ) == EFSInbox )

            {

            RArray<TFSMailMsgId>* newEntries(

                static_cast< RArray<TFSMailMsgId>* >( aParam1 ) );

            TInt count = newEntries->Count();

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

                {

                TFSMailMsgId msgId = newEntries->operator []( i );

                TNewMailInfo info( msgId, aMailbox, *parentFolderId ); 

                iNewInboxEntries.AppendL( info );

                }

            if (iTimer->IsActive() )

                {

                iTimer->Cancel();

                }

            iTimer->After( KTimerDelay );

            }

         else

            {

            // If messages are in some other folder than in inbox

            // they have no effect on the notification

            }

        }

    else

        {

        // No other events than new mail are handled. For example

        // moving of messages and changing message status has no

        // effect on the notification.

        }

    }

void CFSNotificationHandlerBase::TimerExpiredL()

    {

    // process collected insert requests

    RArray<TFSMailMsgId> msgIds;

    CleanupClosePushL( msgIds );

    TFSMailMsgId mailBoxId;

    TFSMailMsgId parentFolderId;

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

        {

        TNewMailInfo& info = iNewInboxEntries[ i ];

        if ( mailBoxId.IsNullId() && parentFolderId.IsNullId() )

            {

            // starting new group is starting to collect

            mailBoxId = info.iMailBox;

            parentFolderId = info.iParentFolderId;

            }

        if ( mailBoxId == info.iMailBox && parentFolderId == info.iParentFolderId )

            {

            // collect message ids for the same mailbox and parent folder

            msgIds.Append( info.iMsgId );

            }

        else

            {

            // process collected message ids for the same mailbox and parent folder

            if ( msgIds.Count()&& MessagesCauseNotificationL( mailBoxId, parentFolderId, msgIds ) )

                {

                TurnNotificationOn();

                }

            // clear data and start collecting again

            msgIds.Reset();

            mailBoxId = TFSMailMsgId();

            parentFolderId = TFSMailMsgId();

            }

        }

    // process collected message ids for the same mailbox and parent folder

    if ( msgIds.Count() && MessagesCauseNotificationL( mailBoxId, parentFolderId, msgIds ) )

        {

        TurnNotificationOn();

        }

    // clear processed entries

    msgIds.Reset();

    CleanupStack::PopAndDestroy( &msgIds );

    iNewInboxEntries.Reset();    

    }

CFSMailMessage* CFSNotificationHandlerBase::NewestMsgInFolderL(

    CFSMailFolder& aFolder ) const

    {

    FUNC_LOG;

    // Load info only necessary for sorting by date into the messages.

    TFSMailDetails details( EFSMsgDataDate );

    // Want to sort mails so that the newest is in the beginning

    TFSMailSortCriteria criteriaDate;

    criteriaDate.iField = EFSMailSortByDate;

    criteriaDate.iOrder = EFSMailDescending;

    RArray<TFSMailSortCriteria> sorting;

    CleanupClosePushL( sorting );

    // First criteria appended would be the primary criteria

    // but here we don't have any other criteria

    sorting.Append( criteriaDate );

    MFSMailIterator* iterator = aFolder.ListMessagesL( details, sorting );

    // Resetting array of sort criteria already here because

    // the iterator does not need it anymore.

    CleanupStack::PopAndDestroy( &sorting );

    // CleanupStack::PushL doesn't work for M-class

    CleanupDeletePushL( iterator ); 

    RPointerArray<CFSMailMessage> messages;

    CleanupClosePushL( messages );

    // Let's get only the first and therefore the newest message.

    TInt amount( 1 );

    iterator->NextL( TFSMailMsgId(), amount, messages );    

    if ( messages.Count() < 1 )

        {

        messages.ResetAndDestroy();

        User::Leave( KErrNotFound );

        }

    CFSMailMessage* outcome = messages[0];

    messages.Remove( 0 ); // remove from array to prevent destruction of element

    messages.ResetAndDestroy();

    CleanupStack::PopAndDestroy( &messages ); 

    CleanupStack::PopAndDestroy( iterator );

    return outcome;

    }

CNewMailNotificationTimer::CNewMailNotificationTimer( MFSTimerObserver& aObserver ) :

    CTimer( EPriorityIdle ), iObserver( aObserver )

    {

    FUNC_LOG;

    }

void CNewMailNotificationTimer::ConstructL()

    {

    FUNC_LOG;

    CTimer::ConstructL();

    CActiveScheduler::Add( this );

    }

CNewMailNotificationTimer* CNewMailNotificationTimer::NewL(

        MFSTimerObserver& aObserver )

    {

    FUNC_LOG;

    CNewMailNotificationTimer* self =

        new( ELeave ) CNewMailNotificationTimer( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CNewMailNotificationTimer::~CNewMailNotificationTimer()

    {

    FUNC_LOG;

    Cancel();

    }

void CNewMailNotificationTimer::DoCancel()

    {

    FUNC_LOG;

    // Cancel Base class

    CTimer::DoCancel(); 

    }

void CNewMailNotificationTimer::RunL()

    {

    FUNC_LOG;

    iObserver.TimerExpiredL();

    }

TInt CNewMailNotificationTimer::RunError(TInt aError)

    {

    if( aError )

        {

        INFO_1( "CNewMailNotificationTimer::RunError( aError: %d )", aError );

        }

    return KErrNone;

    }

void Panic( TCmailhandlerPanic aPanic )

    {

    _LIT( KPanicText, "emailhandlerplugin" );

    User::Panic( KPanicText, aPanic );

    }

// End of file