/*

* 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 <scs/cleanuputils.h> // CleanupResetAndDestroyPushL

#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"

#include "fsemailserverpskeys.h"

using namespace EmailInterface;

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

// CMailCpsHandler::CMailCpsHandler

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

//

CMailCpsHandler::CMailCpsHandler( MFSNotificationHandlerMgr& aOwner ): 

    CFSNotificationHandlerBase( aOwner ),

    iWaitingForNewMailbox( NULL ),

    iWaitingForNewWidget(),

    iUpdateHelper( NULL )

    {

    FUNC_LOG;

    iWaitingForNewWidget.SetPluginId( KNullUid );

    iWaitingForNewWidget.SetId( 0 );

    }

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

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

    TInt err = RProperty::Define( KPSUidEmailServerCategory, 

                                  KIntMailboxCount, 

                                  RProperty::EInt );

    if ( err != KErrAlreadyExists && err != KErrNone )

        {

        User::LeaveIfError( err );

        }

    // set mailbox initial count 

    TInt intCount = TotalIntMailboxCount();

    User::LeaveIfError( RProperty::Set( KPSUidEmailServerCategory, KIntMailboxCount, intCount ) );

    }

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

// CMailCpsHandler::~CMailCpsHandler

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

//

CMailCpsHandler::~CMailCpsHandler()

    {

    FUNC_LOG;

    delete iUpdateHelper;

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

    INFO_1("iSettings->Mailboxes().Count() = %d", iiMax );

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

        {

        CFSMailBox* mailbox( NULL );

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

        TInt mailboxId(0);

        if (mailbox)

            {

            CleanupStack::PushL( mailbox );

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

            if ( mailboxId )

                {

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

            }

        }

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

    }

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

// CMailCpsHandler::InitializeExternalAccountsL

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

//

void CMailCpsHandler::InitializeExternalAccountsL()

    {

    FUNC_LOG;

    // Read external account data from settings

    RPointerArray<CMailExternalAccount> extAccounts;

    CleanupResetAndDestroyPushL( extAccounts );  // owning - GetExtMailboxesL transfers ownership

    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( &extAccounts );

    }

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

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

    TInt count = iLiwIf->GetWidgetInstanceCount();

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

        {

        iLiwIf->SetUpdateNeeded( i, ETrue );

        }

    TRAP_IGNORE( UpdateFullL() );

    CleanWaitingForNewMailbox();

    }

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

// CMailCpsHandler::SetUpdateNeeded

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

//

void CMailCpsHandler::SetUpdateNeeded( const TFSMailMsgId aMailbox )

    {

    FUNC_LOG;

    TInt count = iSettings->WidgetCountByMailbox( aMailbox.Id() );

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

        {

        TBuf<KMaxDescLen> cid;

        iSettings->GetContentId( aMailbox.Id(), i + 1, cid );

        TInt widgetInstance = iLiwIf->GetWidgetInstanceId( cid );

        if ( widgetInstance != KErrNotFound )

            {

            iLiwIf->SetUpdateNeeded( widgetInstance, ETrue );

            }

        }

    }

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

// CMailCpsHandler::UpdateFullL

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

//

void CMailCpsHandler::UpdateFullL()

    {

    FUNC_LOG;

    if ( !iUpdateHelper )

        {

        iUpdateHelper = CMailCpsUpdateHelper::NewL( this );

        }

    iUpdateHelper->UpdateL();

    }

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

// CMailCpsHandler::DoUpdateFullL

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

//

void CMailCpsHandler::DoUpdateFullL()

    {

    FUNC_LOG;

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

        {

        if ( iLiwIf->AllowedToPublish(instance) )

            {

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

            }

        }

    }

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

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

        {

        if ( iLiwIf->UpdateNeeded( aInstance ) )

            {

            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[mailbox] mailbox = %d", mailbox);

                    found = ETrue;

                    break;

                    }

                }

            // if contentId found from array, update the mailbox

            if ( found )

                {

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

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

                {

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

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

                }

            iLiwIf->SetUpdateNeeded( aInstance, EFalse );

            }

        }

    }

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

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

        }

    }

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