/*

* Copyright (c) 2008 - 2010 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 <startupdomainpskeys.h>

#include "emailtrace.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++ )

            {

            break;

            }

        }

    }

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

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

    if ( aMailBoxNumber < iAccountsArray.Count() )

        {

        TFSMailMsgId mailBoxId;

        mailBoxId = iAccountsArray[aMailBoxNumber]->iMailboxId;

        CFSMailBox* mailbox( NULL );

        mailbox = MailClient().GetMailBoxByUidL( mailBoxId );

        if(mailbox)

            {

            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 || (msgCount == 1 && aRow == 3))

                {

                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 || (count == 1 && aRow == 3))

                {

                UpdateEmptyMessagesL( aWidgetInstance, aRow );