/*

* Copyright (c) 2008 - 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:  Class to handle content publishing for widget

*

*/

#include <cmailhandlerplugin.mbg>

#include <ecom/ecom.h>

#include <StringLoader.h>

#include <emailwidget.rsg>

#include <AknUtils.h>

#include <apgcli.h>

#include <centralrepository.h>

#include <starterdomaincrkeys.h>

#include "emailtrace.h"

#include "CFSMailClient.h"

#include "CFSMailBox.h"

#include "CFSMailFolder.h"

#include "cmailcpshandler.h"

#include "cmailcpssettings.h"

#include "cmailcpsif.h"

#include "cmailmessagedetails.h"

#include "cmailmailboxdetails.h"

#include "cmailcpsifconsts.h"

#include "FreestyleEmailUiConstants.h"

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

// CMailCpsHandler::CMailCpsHandler

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

//

CMailCpsHandler::CMailCpsHandler( MFSNotificationHandlerMgr& aOwner ) : CFSNotificationHandlerBase( aOwner )

    {

    FUNC_LOG;

    }

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

// CMailCpsHandler::NewL

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

//

CMailCpsHandler* CMailCpsHandler::NewL( MFSNotificationHandlerMgr& aOwner )

    {

    FUNC_LOG;

    CMailCpsHandler* self = new(ELeave) CMailCpsHandler( aOwner );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMailCpsHandler::ConstructL

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

//

void CMailCpsHandler::ConstructL()

    {

    FUNC_LOG;

    CFSNotificationHandlerBase::ConstructL();

    iEnv = CEikonEnv::Static( );

    SetObserving( ETrue );

    // Instantiate helper classes

    // Leaves if ContentPublishing service not found

    iLiwIf = CMailCpsIf::NewL(this);

    // Leaves if CenRep file not found

    iSettings = CMailCpsSettings::NewL( MailClient() );

    InitializeL();

    iSettings->StartObservingL( this );

    }

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

// CMailCpsHandler::~CMailCpsHandler

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

//

CMailCpsHandler::~CMailCpsHandler()

    {

    FUNC_LOG;

    delete iLiwIf;

    delete iSettings;

    iAccountsArray.ResetAndDestroy();

    }

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

// CMailCpsHandler::Reset

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

//

void CMailCpsHandler::Reset()

    {

    FUNC_LOG;

    iAccountsArray.ResetAndDestroy();

    }

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

// CMailCpsHandler::InitializeL

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

//

void CMailCpsHandler::InitializeL()

    {

    FUNC_LOG;

    // Get current configuration from settings interface,

    // and pass it on to actual publisher interface

    iLiwIf->SetConfiguration( iSettings->Configuration() );

    TInt iiMax( iSettings->Mailboxes().Count() );

    for ( TInt ii = 0; ii < iiMax; ii++ )

        {

        CFSMailBox* mailbox( NULL );

        mailbox = MailClient().GetMailBoxByUidL( iSettings->Mailboxes()[ii] );

        TInt mailboxId(0);

        if (mailbox)

            {

            mailboxId = mailbox->GetId().Id();

            }

        if ( !mailboxId )

            {

            // Remove box from settings

            iSettings->RemoveMailboxL( ii );

            // Array indexing changes now since one item was deleted

            ii--;

            }

        else

            {

            CleanupStack::PushL( mailbox );

            CMailMailboxDetails* mailboxDetails = CreateMailboxDetailsL( *mailbox );

            CleanupStack::PushL( mailboxDetails );

            TBuf<KMaxDescLen> cid;

            TInt next(1);

            // Check if same mailbox is already in iAccountsArray once or more

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

                {               

                TInt id = (TInt)iAccountsArray[i]->iMailboxId.Id();

                if (id == mailboxId)

                    {

                    next++;

                    }

                }

            iSettings->GetContentId(mailboxId, next, cid);          

            mailboxDetails->SetWidgetInstance(cid);

            iAccountsArray.AppendL( mailboxDetails );

            CleanupStack::Pop( mailboxDetails );                            

            CleanupStack::PopAndDestroy( mailbox );            

            }

        }

    }

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

// CMailCpsHandler::CreateMailboxDetailsL

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

//

CMailMailboxDetails* CMailCpsHandler::CreateMailboxDetailsL( CFSMailBox& aMailbox )

    {

    FUNC_LOG;

    // Create instance to return

    CMailMailboxDetails* details = 

        CMailMailboxDetails::NewL( aMailbox.GetId(), aMailbox.GetName() );

    return details;

    }

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

// CMailCpsHandler::SettingsChangedCallback

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

//

void CMailCpsHandler::SettingsChangedCallback()

    {

    FUNC_LOG;

    Reset();

    // Trying to keep callback interface non-leaving

    TRAP_IGNORE( InitializeL() );

    // Update widget contents after settings change

    TRAP_IGNORE( UpdateFullL() );

    }

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

// CMailCpsHandler::UpdateFullL

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

//

void CMailCpsHandler::UpdateFullL()

    {

    FUNC_LOG;

    for (TInt instance = 0; instance < iLiwIf->GetWidgetInstanceCount(); instance++)

        {

        if ( iLiwIf->AllowedToPublish(instance) )

            {

            UpdateMailboxesL(instance, iLiwIf->iInstIdList[instance]->Des());

            }

        }

    }

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

// CMailCpsHandler::UpdateMailboxesL

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

//

void CMailCpsHandler::UpdateMailboxesL(TInt aInstance, const TDesC& aContentId)

    {

    FUNC_LOG;

    TInt row(1); // start from first row

    TInt mailbox(0);

    for ( mailbox = 0; mailbox < iAccountsArray.Count(); mailbox++ )

        {           

        TInt compare = aContentId.Compare(*iAccountsArray[mailbox]->iWidgetInstance);

        if (!compare)

            {

            break;

            }

        }

    // Update fields from left to right

    UpdateMailBoxIconL( mailbox, aInstance, row );

    UpdateMailboxNameL( mailbox, aInstance, row );

	UpdateIndicatorIconL( mailbox, aInstance, row );

	row++;

	UpdateMessagesL( mailbox, aInstance, 1, row);

	row++;

	UpdateMessagesL( mailbox, aInstance, 2, row);

    }

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

// CMailCpsHandler::UpdateMailboxNameL

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

//

void CMailCpsHandler::UpdateMailboxNameL( const TInt aMailBoxNumber,

                                          const TInt aWidgetInstance,

                                          const TInt aRowNumber )

    {

    FUNC_LOG;

    TFSMailMsgId mailBoxId;

    TFSMailMsgId folderId;

    TBool mailBoxFound(EFalse);

    if ( aMailBoxNumber < iAccountsArray.Count() )

        {

        mailBoxId = iAccountsArray[aMailBoxNumber]->iMailboxId;

        CFSMailBox* mailbox( NULL );

        mailbox = MailClient().GetMailBoxByUidL( mailBoxId );

        if(mailbox)

            {

            mailBoxFound = ETrue;

            TFSMailMsgId folderId( mailbox->GetStandardFolderId( EFSInbox ) );

            delete mailbox;

            TBuf<KMaxDescLen> accountName;

            accountName.Append(*iAccountsArray[aMailBoxNumber]->iMailboxName);

            TInt unreadCount(GetUnreadCountL(iAccountsArray[aMailBoxNumber]->iMailboxId));

            if ( unreadCount > 0 )

                {

                // Use localisation format when displaying also unread messages

                // Arrays must be used when loc string contains indexed parameters

                CDesCArrayFlat* strings = new CDesCArrayFlat( 1 );

                CleanupStack::PushL( strings );

                strings->AppendL( accountName ); // replace "%0U" with mailbox name

                CArrayFix<TInt>* ints = new(ELeave) CArrayFixFlat<TInt>( 1 );

                CleanupStack::PushL( ints );

                ints->AppendL( unreadCount ); // replace "%1N" with number of unread messages

                HBufC* mailboxAndCount = StringLoader::LoadLC( R_EMAILWIDGET_TEXT_MAILBOX_AND_MAILCOUNT, 

                                                               *strings,

                                                               *ints );

                iLiwIf->PublishActiveMailboxNameL(

				        aWidgetInstance,

                        aRowNumber, *mailboxAndCount,

                        iAccountsArray.Count(),

                        mailBoxId, folderId); 

                CleanupStack::PopAndDestroy(mailboxAndCount);

                CleanupStack::PopAndDestroy(ints);

                CleanupStack::PopAndDestroy(strings);

                }

            else

                {

                // show only mailbox name

                iLiwIf->PublishActiveMailboxNameL(

				        aWidgetInstance,

                        aRowNumber, accountName,

                        iAccountsArray.Count(),

                        mailBoxId, folderId);  

                }

            }

        }

    else if(!mailBoxFound)

        {

        // Publishing empty descriptor for rows that should not contain

        // anything on widget UI.

        iLiwIf->PublishActiveMailboxNameL( aWidgetInstance, 

		                                   aRowNumber,

										   KNullDesC,

										   NULL,

										   mailBoxId,

										   folderId );

        }

    }

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

// CMailCpsHandler::UpdateMessagesL

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

//

void CMailCpsHandler::UpdateMessagesL( const TInt aMailBoxNumber,

                                       const TInt aWidgetInstance,

                                       const TInt aMessageNumber,

                                       const TInt aRow )

    {

    FUNC_LOG;    

    TBool mailBoxFound(EFalse);

    if ( aMailBoxNumber < iAccountsArray.Count() )

        {

        TFSMailMsgId mailBoxId;

        mailBoxId = iAccountsArray[aMailBoxNumber]->iMailboxId;

        CFSMailBox* mailbox( NULL );

        mailbox = MailClient().GetMailBoxByUidL( mailBoxId );

        if(mailbox)

            {

            mailBoxFound = ETrue;

            TFSMailMsgId parentFolder( mailbox->GetStandardFolderId( EFSInbox ) );

            // Check that folder is correct

            CFSMailFolder* folder = MailClient().GetFolderByUidL( mailBoxId, parentFolder );

            if ( !folder )

                {

				UpdateEmptyMessagesL( aWidgetInstance, aRow );

                return;

                }

            CleanupStack::PushL( folder );

            TInt msgCount = folder->GetMessageCount();

            if(msgCount<1)

                {

                UpdateEmptyMessagesL( aWidgetInstance, aRow );

                CleanupStack::PopAndDestroy( folder );

                return;

                }

            folder->SetFolderType(EFSInbox);

            // Update folder if provided, otherwise use current folder

            RPointerArray<CFSMailMessage> folderMessages(1);

            CleanupClosePushL( folderMessages );

            TFSMailDetails details( EFSMsgDataEnvelope );

            RArray<TFSMailSortCriteria> sorting;

            CleanupClosePushL( sorting );

            TFSMailSortCriteria sortCriteria;

            sortCriteria.iField = EFSMailSortByDate;

            sortCriteria.iOrder = EFSMailDescending;

            sorting.Append( sortCriteria );

            // List all or maximum number of messages   

            MFSMailIterator* iterator = folder->ListMessagesL( details, sorting );

            CleanupDeletePushL( iterator ); // standard CleanupStack::PushL does not work with non-C-class pointer  

            TFSMailMsgId dummy;

            iterator->NextL( dummy, aMessageNumber, folderMessages);

            TInt count (folderMessages.Count());

            if(!count)

                {

                UpdateEmptyMessagesL( aWidgetInstance, aRow );

                CleanupStack::PopAndDestroy( iterator );

                CleanupStack::PopAndDestroy( &sorting );

                CleanupStack::PopAndDestroy( &folderMessages );

                CleanupStack::PopAndDestroy( folder );

                return;

                }

            TFSMailMsgId msgId = folderMessages[aMessageNumber - 1]->GetMessageId();

            CFSMailMessage* msg( NULL );

            msg = MailClient().GetMessageByUidL( mailBoxId, parentFolder, msgId, EFSMsgDataEnvelope );

            CleanupDeletePushL( msg );

            // Get sender information

            TBuf<KMaxDescLen> sender( NULL );

            CFSMailAddress* fromAddress = msg->GetSender();

            if ( fromAddress )

                {

                if ( IsValidDisplayName(fromAddress->GetDisplayName()) )

                    {

                    sender.Append(fromAddress->GetDisplayName());

                    }

                else

                    {

                    sender.Append(fromAddress->GetEmailAddress());

                    }

                }

            // Get message time and format it correctly 

            TTime msgTime = msg->GetDate();

            HBufC* timeString( NULL );

            timeString = GetMessageTimeStringL( msgTime );

            CleanupDeletePushL( timeString );     

            // Publish message details           

            PublishMessageL( aWidgetInstance, 

                              *msg,

                              sender,

                              *timeString,

                              aRow );

            CleanupStack::PopAndDestroy( timeString );

            CleanupStack::PopAndDestroy( msg );

            CleanupStack::PopAndDestroy( iterator );

            CleanupStack::PopAndDestroy( &sorting );

            CleanupStack::PopAndDestroy( &folderMessages );

            CleanupStack::PopAndDestroy( folder );

            }

        }

    else if(!mailBoxFound)

        {

        UpdateEmptyMessagesL( aWidgetInstance, aRow );

        }

    }

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

// CMailCpsHandler::GetMessageTimeStringL

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

//

HBufC* CMailCpsHandler::GetMessageTimeStringL( TTime aMessageTime )

    {

    FUNC_LOG;

    // Get current local time

    TTime currentTime;

    currentTime.HomeTime();

    // Get universal time offset and add it to message time

    TLocale locale;    

    TTimeIntervalSeconds universalTimeOffset( locale.UniversalTimeOffset() );

    aMessageTime += universalTimeOffset;      

    // If daylight saving is on, add one hour offset to message time

    if ( locale.QueryHomeHasDaylightSavingOn() )

        {

        TTimeIntervalHours daylightSaving( 1 );

        aMessageTime += daylightSaving;

        }

    // Get datetime objects and compare dates

    TDateTime currentDate = currentTime.DateTime();

    TDateTime messageDate = aMessageTime.DateTime();

    HBufC* formatString( NULL );

    if ( currentDate.Year() == messageDate.Year() 

        && currentDate.Month() == messageDate.Month() 

        && currentDate.Day() == messageDate.Day())

        {

        // Message arrived today

        formatString = StringLoader::LoadLC( R_QTN_TIME_USUAL_WITH_ZERO );       

        }

    else

        {

        // Message arrived earlier than today

        formatString = StringLoader::LoadLC( R_QTN_DATE_WITHOUT_YEAR_WITH_ZERO );

        }

    // Format time string using chosen time or date formatString

    TBuf<KMaxShortDateFormatSpec*2> timeString;

    TRAP_IGNORE( aMessageTime.FormatL( timeString, formatString->Des() ) );

    CleanupStack::PopAndDestroy( formatString );

    // If format fails, result is empty

    HBufC* result = timeString.Alloc();

    TPtr ptr = result->Des();

    AknTextUtils::DisplayTextLanguageSpecificNumberConversion( ptr );

    return result;

}

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

// CMailCpsHandler::PublishMessageL

//

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

//

void CMailCpsHandler::PublishMessageL( TInt aWidgetInstance, CFSMailMessage& aMessage,

                                        const TDesC& aSenderName, const TDesC& aTime, TInt aRow )

    {

    FUNC_LOG;

    TFSMailMsgId msgId( aMessage.GetMessageId() );

    iLiwIf->PublishMailboxIconL( aWidgetInstance, aRow, GetMailIcon( &aMessage ), msgId );

    iLiwIf->PublishMailDetailL( aWidgetInstance, aRow, aSenderName, ESender );

    iLiwIf->PublishMailDetailL( aWidgetInstance, aRow, aTime, ETime );

    }

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

// CMailCpsHandler::UpdateEmptyMessagesL

//

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

//

void CMailCpsHandler::UpdateEmptyMessagesL( const TInt aWidgetInstance,

                                            const TInt aRow )

    {

    FUNC_LOG;   

    TFSMailMsgId mailBoxId; // id not essential here

    iLiwIf->PublishMailDetailL(

            aWidgetInstance,

            aRow,