/*

* Copyright (c) 2004 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:   The purpose of this class is to observe if there are messages

*                in the Email.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <MuiuMsvUiServiceUtilities.h>  // MsvUiServiceUtilities

#include <msvstd.hrh>

#include <mtclreg.h>                    // For CClientMtmRegistry

#include <miuthdr.h>

#include <ImumInternalApi.h>            // CImumInternalApi

#include <ImumInSettingsKeys.h>         // TImumInSettings

#include <ImumInSettingsData.h>         // CImumSettingsData

#include <muiuemailtools.h>

#include <SendUiConsts.h>   // KSenduiMtmSyncMLEmailUid 

#include "CNcnNotifApiObserver.h"

#include "NcnModelBase.h"

#include "CNcnMsvSessionHandler.h"

#include "NcnTimer.h"

#include <NcnListInternalCRKeys.h>

#include <muiumsvuiserviceutilitiesinternal.h> // Messaging utilites

#include <messaginginternalcrkeys.h>

// ================= LOCAL CONSTANTS =======================

namespace

    {

    // Timer iteration delay in microseconds

    const TUint KTimerIterationDelay = 1 * 1000 * 1000;

    // Mail technology type

    const TUid KMailTechnologyTypeUid = { 0x10001671 };

    }

// ======================== INTERNAL HELPER CLASS ==============================

CNcnNotifApiObserver::TNcnMailBoxStatus::TNcnMailBoxStatus( 

    TMsvId aMailBox )

    : iMailBox( aMailBox ),

      iMTMType( KNullUid ),

      iMailBoxTechnologyType( KNullUid),

      iPublishedNewEmailCount( 0 ),

      iHighestEMailMsvId( 0 ),

      iHighestIMAPId(0),

      iLatestMessageArrival(0),

      iUnreadCheckpointMsvId( 0 ),

      iPublishedCheckpointMsvId( 0 ),

      iPublishedCheckpointIMAPId(0),

      iPublishedCheckpointTimeStamp(0),

      iNewMessageIds( 5 ),

      iNotified( ETrue ),

      iIcon(ETrue),

      iTone(ETrue),

      iNote(ETrue),

      iShowIcon(ETrue)

    {

    }

TInt CNcnNotifApiObserver::TNcnMailBoxStatus::Compare(

    const TNcnMailBoxStatus& aFirst, 

    const TNcnMailBoxStatus& aSecond )

    {

    if ( aFirst.iMailBox < aSecond.iMailBox )

        {

        return -1;

        }        

    else if ( aFirst.iMailBox > aSecond.iMailBox )

        {

        return 1;

        }

    else

        {

        return 0;

        }                        

    }

TBool CNcnNotifApiObserver::TNcnMailBoxStatus::Match( 

    const TNcnMailBoxStatus& aFirst, 

    const TNcnMailBoxStatus& aSecond )

    {

    TBool ret = EFalse;

    if( aFirst.iMailBox == aSecond.iMailBox )

        {

        ret = ETrue;

        }

    return ret;

    }

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

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

// CNcnNotifApiObserver default constructor

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

//

CNcnNotifApiObserver::CNcnNotifApiObserver( 

    CNcnModelBase& aModel )

    : iModel( aModel ),

      iMsvSession(NULL)

    {    

    }

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

// CNcnNotifApiObserver::ConstructL

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

//

void CNcnNotifApiObserver::ConstructL()

    {

    NCN_RDEBUG( _L("CNcnNotifApiObserver::ConstructL - Entry") );    

    // listen to msv session handler

    iModel.MsvSessionHandler().AddObserverL( this );

    NCN_RDEBUG( _L("CNcnNotifApiObserver::ConstructL - Exit") );

    }

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

// CNcnNotifApiObserver::NewL

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

//

CNcnNotifApiObserver* CNcnNotifApiObserver::NewL( 

    CNcnModelBase& aModel )

    {

    // Create the observer instance

    CNcnNotifApiObserver* self = 

        new (ELeave) CNcnNotifApiObserver( aModel );

    // Call the construct safely

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CNcnNotifApiObserver::~CNcnNotifApiObserver

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

//

CNcnNotifApiObserver::~CNcnNotifApiObserver()

    {

    delete iTimer;

    iMailBoxStatusArray.Close();

    // stop listening to msv session handler

    iModel.MsvSessionHandler().RemoveObserver( this );

    }

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

// CNcnNotifApiObserver::HandleMsvSessionReadyL

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

//

void CNcnNotifApiObserver::HandleMsvSessionReadyL( CMsvSession& aMsvSession )

    {

    // Load all mailboxes

    LoadMailboxesL( aMsvSession );

    //We take a pointer to msv session. Needed only in special circumstances

    iMsvSession = &aMsvSession;

    }

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

// CNcnNotifApiObserver::HandleMsvSessionClosedL

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

//    

void CNcnNotifApiObserver::HandleMsvSessionClosedL()

    {

    NCN_RDEBUG( _L("CNcnNotifApiObserver::HandleMsvSessionClosedL") );

    iMailBoxStatusArray.Close();

    // Reset email counters

    iTotalNewMailCount = 0;

    iNotifiedNewMailCount = 0;    

    // Inform notifier

    iModel.NcnNotifier().SetNotification(

        MNcnNotifier::ENcnEmailNotification,

        iTotalNewMailCount );

    }

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

// CNcnNotifApiObserver::HandleMsvEntryCreatedL

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

//

void CNcnNotifApiObserver::HandleMsvEntryCreatedL( const TMsvId& aMsvId )

    {

    //Get the atrrbiutes

    TUid aMtmType = KNullUid;

    TUid aTechnologyType = KNullUid;

    TInt error = GetMailBoxesAttributesL(aMsvId, aMtmType, aTechnologyType);

    // if entry is an email service entry

    if( error == KErrNone && IsMailTechnologyType( aTechnologyType ) )

        {

        // add mail box

        NCN_RDEBUG_INT2( _L("CNcnNotifApiObserver::HandleMsvEntryCreatedL - Box %d created with MTM %d"), aMsvId, aMtmType.iUid );

        AddMailBoxL( aMsvId, aMtmType, aTechnologyType );

        }

    // otherwise inspect the entry more carefully

    else

        {                

        CMsvSession& msvSession = iModel.MsvSessionHandler().MsvSessionL();

        // get service id and entry

        TMsvId serviceId;

        TMsvEntry entry;        

        TInt err = msvSession.GetEntry( aMsvId, serviceId, entry );

        // if entry was found

        if( err == KErrNone )

            {

            // if entry is an email

            if( IsEMailEntry( entry ) && ( entry.New() && entry.Unread() ) )

                {

                // handle new email

                HandleNewEMailMsvEntryL( entry );

                }    

            }            

        }

    }

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

// CNcnNotifApiObserver::HandleMsvEntryDeletedL

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

//    

void CNcnNotifApiObserver::HandleMsvEntryDeletedL( const TMsvId& aMsvId )

    {

    // just try to remove mail box

    // invalid ids are ignored by the method

    RemoveMailBox( aMsvId );

    // Also try to delete email entry

    HandleDeletedEMailMsvEntryL( aMsvId );

    }

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

// CNcnNotifApiObserver::HandleNewEMailMsvEntryL

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

//

void CNcnNotifApiObserver::HandleNewEMailMsvEntryL( const TMsvEntry& aEntry )

    {

    NCN_RDEBUG_INT( _L("[ncnlist] CNcnNotifApiObserver::HandleNewEMailMsvEntryL - entry = %d\n"), aEntry.Id() );    

    // find the mailbox

    TNcnMailBoxStatus& mailboxStatus = MailBoxStatusL( aEntry.iServiceId );

    // find entry in mailbox new email list

    TInt index = mailboxStatus.iNewMessageIds.Find( aEntry.Id() );

    // if there is no such entry in list yet 

    if( index == KErrNotFound )

        {

        //Some messages do not require notifications when they arrive (they are old messages)

        //In this method those messages are spotted

        if ( IsNotificationNeededForThisMessageL( mailboxStatus, aEntry ) == FALSE )

	        {

	        NCN_RDEBUG_INT( _L( "[ncnlist] CNcnNotifApiObserver::HandleNewEMailMsvEntryL - entry %d does not require notification!" ), aEntry.Id() );

			return;

	        }

        //Notification is needed, add it to our list

        NCN_RDEBUG_INT( _L( "[ncnlist] CNcnNotifApiObserver::HandleNewEMailMsvEntryL - entry %d added to list\n" ), aEntry.Id() );

        // append entry id to the list of new messages in box

        mailboxStatus.iNewMessageIds.Append( aEntry.Id() );

        //Email icon should be shown to indicate new email for this mailbox

        mailboxStatus.iShowIcon = ETrue;

        NCN_RDEBUG_INT2(

            _L( "CNcnNotifApiObserver::HandleNewEMailMsvEntryL - new messages in box %d: %d" ),

            mailboxStatus.iMailBox,

            mailboxStatus.iNewMessageIds.Count() );

        // update highest msv entry if needed

        if( aEntry.Id() > mailboxStatus.iHighestEMailMsvId )

            {

            mailboxStatus.iHighestEMailMsvId = aEntry.Id();

            }

        // update highest IMAP uid if needed

        NCN_RDEBUG(_L( "CNcnNotifApiObserver::HandleNewEMailMsvEntryL - Making an TMsvEmailEntry from TEntry" ) );

        TMsvEmailEntry emailEntry(aEntry);

		NCN_RDEBUG_INT(_L( "CNcnNotifApiObserver::HandleNewEMailMsvEntryL - Messages IMAP UID %d" ), emailEntry.UID() );

        if( emailEntry.UID() > mailboxStatus.iHighestIMAPId  )

            {

            NCN_RDEBUG_INT( _L( "CNcnNotifApiObserver::HandleNewEMailMsvEntryL - Message has highest IMAP UID so far %d" ), emailEntry.UID() );

            mailboxStatus.iHighestIMAPId = emailEntry.UID();            	

            }

        // update latest message time if needed

#ifdef _DEBUG

		TBuf<50> 	tempTime;

		_LIT(KBMDebugTimeFormat, "%-B%:0%J%:1%T%:2%S%.%*C4%:3%+B");		

		aEntry.iDate.FormatL(tempTime, KBMDebugTimeFormat);

		NCN_RDEBUG_INT( _L("CNcnNotifApiObserver::HandleNewEMailMsvEntryL messages time stamp: %S"), &tempTime);

#endif

        if( aEntry.iDate > mailboxStatus.iLatestMessageArrival )

            {

            NCN_RDEBUG( _L( "CNcnNotifApiObserver::HandleNewEMailMsvEntryL - Message has latest arrival time" ) );

            mailboxStatus.iLatestMessageArrival = aEntry.iDate;

            }

        }

    // entry exists in the list

    else

        {

        NCN_RDEBUG_INT( _L( "[ncnlist] CNcnNotifApiObserver::HandleNewEMailMsvEntryL - entry %d already in list\n" ), aEntry.Id() );

        }

    }

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

// CNcnNotifApiObserver::HandleDeletedEMailMsvEntryL

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

//

void CNcnNotifApiObserver::HandleDeletedEMailMsvEntryL( const TMsvId& aEntryId )

    {

    NCN_RDEBUG( _L( "CNcnNotifApiObserver::HandleDeletedEMailMsvEntryL - deleted email entry" ) );

    TInt count( iMailBoxStatusArray.Count() );

    // Run all boxes through

    while( count > 0)

        {

        // decrease count

        count--;

        // get reference to mailbox

        TNcnMailBoxStatus& mailboxStatus = iMailBoxStatusArray[count];

        // try to find the id in boxes new message id list

        TInt index = mailboxStatus.iNewMessageIds.Find( aEntryId );

        // if entry was found

        if( index != KErrNotFound )

            {

            // remove entry id

            mailboxStatus.iNewMessageIds.Remove( index );

            NCN_RDEBUG_INT2(

                _L( "CNcnNotifApiObserver::HandleDeletedEMailMsvEntryL - new messages in box %d: %d" ),

                mailboxStatus.iMailBox,

                mailboxStatus.iNewMessageIds.Count() );

            // and if id is less than equal to last published it

            // affects the amount of published new emails

            if( aEntryId <= mailboxStatus.iPublishedCheckpointMsvId )

                {

                // decrease amount of published new emails

                mailboxStatus.iPublishedNewEmailCount--;

                NCN_RDEBUG_INT2(

                    _L( "CNcnNotifApiObserver::HandleDeletedEMailMsvEntryL - published new messages in box %d: %d" ),

                    mailboxStatus.iMailBox,

                    mailboxStatus.iPublishedNewEmailCount );

                // update notification, it might not be valid anymore if

                // published emails have been deleted

                UpdateNotification( EFalse, mailboxStatus.iIcon, mailboxStatus.iTone, mailboxStatus.iNote );

                }

           // and finally we must update the boxes highest values, they might have changed			

			NCN_RDEBUG( _L( "CNcnNotifApiObserver::HandleDeletedEMailMsvEntryL - Updating new 'highest' values" ));                     

            FindHighest_MsvId_ImapId_LatestTime(mailboxStatus.iMailBox,

            									mailboxStatus.iHighestEMailMsvId ,

            									mailboxStatus.iHighestIMAPId,

            									mailboxStatus.iLatestMessageArrival);       

            }

        } 

    }

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

// CNcnNotifApiObserver::HandleMsvMediaChangedL

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

//    

#ifdef _DEBUG

void CNcnNotifApiObserver::HandleMsvMediaChangedL( const TDriveNumber& aDriveNumber )

#else

void CNcnNotifApiObserver::HandleMsvMediaChangedL( const TDriveNumber& /*aDriveNumber */)

#endif

	{

    //The entrys that we have in the iMailBoxStatusArray are no longer valid

    //the array must be rebuild.   

    NCN_RDEBUG_INT( _L("[ncnlist] CNcnNotifApiObserver::HandleMsvMediaChangedL - Media changed to drive: %d"), aDriveNumber );

    //Reset the mail box array

    iMailBoxStatusArray.Reset();

    // Reset email counters

    iTotalNewMailCount = 0;

    iNotifiedNewMailCount = 0;    

    // Inform notifier

    iModel.NcnNotifier().SetNotification( MNcnNotifier::ENcnEmailNotification, iTotalNewMailCount );

    //Load the mail boxes. Old MsvSession is still valid after media changes

    if( iMsvSession != NULL )

	    {

	    LoadMailboxesL( *iMsvSession );	

	    }

	}

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

// CNcnNotifApiObserver::HandleMsvMediaAvailableL

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

//    

#ifdef _DEBUG

void CNcnNotifApiObserver::HandleMsvMediaAvailableL( const TDriveNumber& aDriveNumber )

#else

void CNcnNotifApiObserver::HandleMsvMediaAvailableL( const TDriveNumber& /*aDriveNumber*/ )

#endif

	{

	//Clean up message store from unhealthy mail boxes

    NCN_RDEBUG_INT( _L("[ncnlist] CNcnNotifApiObserver::HandleMsvMediaAvailableL - Media available in drive: %d"), aDriveNumber );

    // Create interface object

    CIMAEmailApi* api = CreateEmailApiLC( iMsvSession );

    // Force message store cleanup

    NCN_RDEBUG( _L("[ncnlist] CNcnNotifApiObserver::HandleMsvMediaAvailableL - Cleanup unhealthy mailboxes") );

    api->HealthServicesL().CleanupUnhealthyMailboxes();

    CleanupStack::PopAndDestroy( api );

    api = NULL;

	}

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

// CNcnNotifApiObserver::HandleMsvMediaAvailableL

// Media Unavailable Check if current drive is Not C 

// then set it back to Phone memory.

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

//    

void CNcnNotifApiObserver::HandleMsvMediaUnavailableL( )

	{

		NCN_RDEBUG( _L("[ncnlist] CNcnNotifApiObserver::HandleMsvMediaUnavailable - Media Unavailable") );

		// get session

		CMsvSession& msvSession = iModel.MsvSessionHandler().MsvSessionL(); 

		NCN_RDEBUG( _L( "CNcnMsvSessionHandler::HandleSessionEventL - EMsvMediaUnavailable, Check Current message store drive." ));

		TInt CurrentDrive = TInt(msvSession.CurrentDriveL());

		RFs fs;	

		User::LeaveIfError(fs.Connect());

		CleanupClosePushL(fs);

		TDriveNumber SystemDrive = fs.GetSystemDrive();	

		CleanupStack::PopAndDestroy();//fs

		if(CurrentDrive != SystemDrive)

		   MsvUiServiceUtilitiesInternal::ChangeMessageStoreToPhoneL(*iMsvSession);

	}

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

// CNcnNotifApiObserver::MarkUnread

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

//

void CNcnNotifApiObserver::MarkUnreadL( const TMsvId& aId )

    {

    NCN_RDEBUG_INT( _L("[ncnlist] CNcnNotifApiObserver::MarkUnreadL - box %d marked unread."), aId );

    // find the mailbox

    TNcnMailBoxStatus& mailboxStatus = MailBoxStatusL( aId );

    // reset amounts    

    mailboxStatus.iPublishedNewEmailCount = 0;

    // clear new message ids

    mailboxStatus.iNewMessageIds.Reset();

    mailboxStatus.iNewMessageIds.Compress();

    // move unread checkpoint to the highest id

    mailboxStatus.iUnreadCheckpointMsvId = mailboxStatus.iHighestEMailMsvId;

    }

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

// CNcnNotifApiObserver::PublishNewMessages

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

//    

void CNcnNotifApiObserver::PublishNewMessagesL( const TMsvId& aId )

    {

    // find the mailbox

    TNcnMailBoxStatus& mailboxStatus = MailBoxStatusL( aId );

    // clear notification flag

    mailboxStatus.iNotified = EFalse;

    mailboxStatus.iRefreshRequested = ETrue;

    NCN_RDEBUG_INT( _L("[ncnlist] CNcnNotifApiObserver::PublishNewMessagesL Initializing counter for box %d."),

        mailboxStatus.iMailBox );

    // if timer is not already spawned

    if( !iTimer )

        {

        iTimer = CNcnTimer::NewL( *this );

        iTimer->After( KTimerIterationDelay );

        }

    else

    	{

    	iTimer->Cancel();

    	iTimer->After( KTimerIterationDelay );

    	}

    }

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

// CNcnNotifApiObserver::SpawnTimer

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

//