/*

* 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 <emailobserverinterface.hrh>

#include <emailobserverplugin.h>

#include <memaildata.h>

#include <memailmailboxdata.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 "cmailexternalaccount.h"

#include "cmailcpsifconsts.h"

#include "FreestyleEmailUiConstants.h"

#include "cmailpluginproxy.h"

#include "cmailhandlerpluginpanic.h"

using namespace EmailInterface;

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

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

    InitializeExternalAccountsL();

    iSettings->StartObservingL( this );

    }

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

// CMailCpsHandler::~CMailCpsHandler

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

//

CMailCpsHandler::~CMailCpsHandler()

    {

    FUNC_LOG;

    delete iLiwIf;

    delete iSettings;

    iAccountsArray.ResetAndDestroy();

    iExternalPlugins.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();

            }

            {

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

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

//

void CMailCpsHandler::InitializeExternalAccountsL()

    {

    FUNC_LOG;

    // Read external account data from settings

    RPointerArray<CMailExternalAccount> extAccounts;

    CleanupClosePushL( extAccounts );

    iSettings->GetExtMailboxesL( extAccounts );

    // Delete removed plugins

    RemoveUnusedPluginsL( extAccounts );

    // Instantiate new plugins

    AddNewPluginsL( extAccounts );

    // Set accounts under correct pluginProxies

    SelectAndUpdateExtAccountsL( extAccounts );

    __ASSERT_DEBUG( extAccounts.Count() == 0, Panic( ECmailHandlerPluginPanicNoFailedState ) );

    CleanupStack::PopAndDestroy();

    }

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

// CMailCpsHandler::RemoveUnusedPluginsL

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

//

void CMailCpsHandler::RemoveUnusedPluginsL( RPointerArray<CMailExternalAccount>& aAccounts )

    {

    FUNC_LOG;

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

        {

        if ( !IsPluginInArray( iExternalPlugins[i]->PluginId(), aAccounts ) )

            {

            // all plugin's accounts have been removed from widget settings, unloading resources

            CMailPluginProxy* proxy = iExternalPlugins[i];

            iExternalPlugins.Remove(i--); // also change the loop index

            delete proxy;

            }

        }

    }

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

// CMailCpsHandler::AddNewPluginsL

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

//

void CMailCpsHandler::AddNewPluginsL( RPointerArray<CMailExternalAccount>& aAccounts )

    {

    FUNC_LOG;

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

        {

        if ( !IsPluginInArray( aAccounts[i]->PluginId(), iExternalPlugins ) )

            {

            // new plugin instantiation

            INFO_1("Instantiating plugin 0x%x", aAccounts[i]->PluginId() );

            CMailPluginProxy* proxy = CMailPluginProxy::NewL( aAccounts[i]->PluginId(), *iLiwIf );

            CleanupStack::PushL( proxy );

            iExternalPlugins.AppendL( proxy );

            CleanupStack::Pop( proxy );

            }

        }

    }

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

// CMailCpsHandler::UpdateExtAccountsL

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

//

void CMailCpsHandler::SelectAndUpdateExtAccountsL( RPointerArray<CMailExternalAccount>& aAccounts )

    {

    FUNC_LOG;

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

        {

        iExternalPlugins[i]->SelectAndUpdateAccountsL( aAccounts );

        }

    }

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

// CMailCpsHandler::IsPluginInArray

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

//

TBool CMailCpsHandler::IsPluginInArray( const TInt aPluginId, RPointerArray<CMailExternalAccount>& aAccounts )

    {

    FUNC_LOG;

    TBool found( EFalse );

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

        {

        if ( aAccounts[i]->PluginId() == aPluginId )

            {

            found = ETrue;

            }

        }

    return found;

    }

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

// CMailCpsHandler::IsPluginInArray

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

//

TBool CMailCpsHandler::IsPluginInArray( const TInt aPluginId, RPointerArray<CMailPluginProxy>& aPlugins )

    {

    FUNC_LOG;

    TBool found( EFalse );

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

        {

        if ( aPlugins[i]->PluginId() == aPluginId )

            {

            found = ETrue;

            }

        }

    return found;

    }

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

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

    TRAP_IGNORE( InitializeExternalAccountsL() );

    // Update widget contents after settings change

    TRAP_IGNORE( UpdateFullL() );

    CleanWaitingForNewMailbox();

    }

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

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

    // Look up 3rd party plugin that handles this account

    CMailPluginProxy* plugin = GetExtPluginL( aContentId );

    if ( plugin ) // handle external 3rd party accounts 

        {

        // Publish its data

        plugin->UpdateAccountL( aContentId );

        }

    else // handle internal accounts

        {   

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

        TInt mailbox(0);

        TBool found( EFalse );

        // try to find mailbox with matching contentId

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

            {

            if ( !aContentId.Compare( *iAccountsArray[mailbox]->iWidgetInstance ) )

                {

                INFO_1("iAccountsArray.Count() == %d", iAccountsArray.Count());

                found = ETrue;

                break;

                }

            }

        // if contentId found from array, update the mailbox

        if ( found )

            {

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

            }

        else

            {

            // Clean mailbox name

            iLiwIf->PublishActiveMailboxNameL( aInstance, 1, KNullDesC );

            // Clean mailbox icon

            TFSMailMsgId mailBoxId; // id not essential here        

            iLiwIf->PublishMailboxIconL( aInstance, 1, KNullIcon, mailBoxId);

            // Clean indicator icon

            iLiwIf->PublishIndicatorIconL( aInstance, 1, KNullIcon);

            // Clean message rows

            UpdateEmptyMessagesL( aInstance, 2 );

            UpdateEmptyMessagesL( aInstance, 3 );

            }

        }

    }

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

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

                CleanupStack::PopAndDestroy(mailboxAndCount);

                CleanupStack::PopAndDestroy(ints);

                CleanupStack::PopAndDestroy(strings);

                }

            else

                {

                // show only mailbox name

                iLiwIf->PublishActiveMailboxNameL(

				        aWidgetInstance,

                        aRowNumber, accountName);

                }

            }

        }

    else if(!mailBoxFound)

        {

        // Publishing empty descriptor for rows that should not contain

        // anything on widget UI.

        iLiwIf->PublishActiveMailboxNameL( aWidgetInstance,

		                                   aRowNumber,

										   KNullDesC);

        }

    }

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

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