/*

* 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:  handles interface to CenRep settings

*

*/

#include "emailtrace.h"

#include <e32base.h>

// CRepository

#include <centralrepository.h>

#include <connect/sbdefs.h>

// Email Framework APIs

//<cmail>

#include "cfsmailcommon.h"

#include "cfsmailclient.h"

#include "cfsmailbox.h"

#include "cfsmailfolder.h"

//</cmail>

#include "cmailcpssettings.h"

#include "cmailwidgetcenrepkeysinternal.h"

#include "cmailcpsifconsts.h"

#include "cmailexternalaccount.h"

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

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

// CMailCpsSettings::NewL

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

//

CMailCpsSettings* CMailCpsSettings::NewL( CFSMailClient& aMailClient )

    {

    FUNC_LOG;

    CMailCpsSettings* self =  new(ELeave) CMailCpsSettings( aMailClient );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMailCpsSettings::~CMailCpsSettings

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

//

CMailCpsSettings::~CMailCpsSettings()

    {

    FUNC_LOG;

    Cancel();

    iMailboxArray.Close();

    delete iBackupRestoreSubscriber;

    delete iCenRep;

    }

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

// CMailCpsSettings::CMailCpsSettings

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

//

CMailCpsSettings::CMailCpsSettings( CFSMailClient& aMailClient ) :

    CActive( EPriorityStandard ),

    iMailClient( aMailClient ),

    iCenRep( NULL ),

    iConfigData( 0 ),

    iRestoreStarted( EFalse ),

    iBackupOngoing( EFalse )

    {

    FUNC_LOG;

    CActiveScheduler::Add( this );

    }

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

// CMailCpsSettings::ConstructL

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

//

void CMailCpsSettings::ConstructL()

    {

    FUNC_LOG;

    // In case there is no repository available, following call will leave

    // Trapping is done by MailServer infrastructure, not by CPS handler

    // In practice, this is fatal to cps handling, and widget won't work

    iCenRep = CRepository::NewL( KCRUidCmailWidget );

    iBackupRestoreSubscriber = CPSSubscriber::NewL(

        *this, KUidSystemCategory, conn::KUidBackupRestoreKey );

    iBackupRestoreSubscriber->Subscribe();

    LoadSettingsL(); // mailboxes etc. user changeable data

    LoadConfigurationL(); // internal configuration data

    }

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

// CMailCpsSettings::RunL

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

//

void CMailCpsSettings::RunL()

    {

    FUNC_LOG;

    if ( !BackupOrRestoreMode() )

        {

        StartObservingL();

        LoadSettingsL(); // mailboxes etc. user changeable data

        LoadConfigurationL(); // internal configuration data

        iObserver->SettingsChangedCallback();

        }

    }

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

// CMailCpsSettings::DoCancel

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

//

void CMailCpsSettings::DoCancel()

    {

    FUNC_LOG;

    // Always returns KErrNone

    iCenRep->NotifyCancel( KCmailPartialKey, KCmailMask );

    }

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

// CMailCpsSettings::LoadSettingsL

// 

// synchronizes the iMailboxArray with Central repository settings

// only existing mailboxes are synchronized

// usecases 

// 1. delete widget from homesceen - removed item from cenrep array

// 2. add widget to homescreen - added item to the end of cenrep array

// 3. change mailbox for widget - changed value of cenrep array item 

// 4. remove mailbox from server - mailbox absence for array item 

// 5. add mailbox to the server (leads to widget adding)

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

void CMailCpsSettings::LoadSettingsL()

    {

    FUNC_LOG;

    TInt ret( KErrNone );

    // mailbox keys

    RArray<TUint> cenrepMailboxes; 

    CleanupClosePushL( cenrepMailboxes );

    RArray<TBool> cenrepMailboxesExistence; 

    CleanupClosePushL( cenrepMailboxesExistence );

    // cenrep keys

    RArray<TUint32> keys; 

    CleanupClosePushL( keys );

    GetMailboxNonZeroKeysL( keys );

    TInt dMax( keys.Count() );

    cenrepMailboxes.ReserveL( dMax ); // cenrep mailbox ids array

    cenrepMailboxesExistence.ReserveL( dMax ); // auxiliary if it was found in iMailboxArray looping

    // initialize array of mailbox keys

    TInt value( 0 );

    TInt i; // main loop

    TInt j; // auxiliary / inner loop

    for ( i = 0; i < dMax; i++ )

        {

         User::LeaveIfError( ret = iCenRep->Get( keys[i], value ));

         cenrepMailboxes.AppendL( static_cast<TUint>(value) );

         cenrepMailboxesExistence.AppendL( EFalse );

        }

    CleanupStack::PopAndDestroy(&keys); 

    // Sync array of cenrep keys with iMailboxArray

    // 1. remove from iMailboxArray what is not in cenrep, mark what is. Distinct existence. 

    // 2. remove mailbox ids not detected on the server

    TInt dFound( KErrNotFound );

    for ( i = iMailboxArray.Count()-1; i >= 0; i -- ) // iArray loop

        {

        dFound = cenrepMailboxes.Find( iMailboxArray[i].Id() );

        if ( KErrNotFound != dFound ) // if found in cenrep

            { 

                 // mailbox is in iMailboxArray and in cenrep => check provider

            INFO_1("Mailbox both in cenrep and iMailboxArray: i = %d ", i );

            if ( ! cenrepMailboxesExistence[dFound] )

                { 

                ret = CheckMailboxExistence( iMailboxArray[i] );

                if ( KErrNotFound == ret)

                    {

                    // mailbox was removed from provider => remove from cenrep also

                    // cenrepMailboxes indexed the same way as keys => finding key not needed 

                    ret = iCenRep->Reset( KCMailMailboxIdBase + i );

                    ret = iCenRep->Reset( KCMailPluginIdBase + i );

                    ret = iCenRep->Reset( KCMailWidgetContentIdBase + i );

                    INFO_1("Mailbox removed from cenrep: dFound %d ", dFound );

                    // remove also from all arrays

                    iMailboxArray.Remove(i);

                    cenrepMailboxes.Remove( dFound );

                    cenrepMailboxesExistence.Remove( dFound );

                    dMax--;

                    }

                else 

                    {

                    User::LeaveIfError(ret); // for instance if no memory

                    INFO_1("Mailbox provider check ok: dFound = %d ", dFound );

                    cenrepMailboxesExistence[dFound] = ETrue; // not remove to ensure indexes are the same as in keys

                    // handle also possible mailbox duplications

                    for (j = dFound+1; j<dMax; j++)

                        {

                        if ( cenrepMailboxes[dFound] == cenrepMailboxes[j] )

                            { 

                            cenrepMailboxesExistence[j] = ETrue; 

                            }

                        }

                    }

                 } // else already tested for existence

            }

        else // not found in cenrep

            {

            // mailbox was removed from cenrep => remove from iArray as well

            iMailboxArray.Remove(i);

            INFO_1("Mailbox removed from iMailboxArray: i = %d ", i );

            }

        } // iArray loop

    // Add mailboxes existing only in cenrep to iMailboxArray in correct order

    // or check and correct order of mailboxes (swap already dot checked, copy duplicated)

    for ( i = 0; i < dMax; i++ )

        {

        // firstly new mailboxes in cenrep needs to be added to iMailboxArray

        if ( ! cenrepMailboxesExistence[i] ) 

            {

            TFSMailMsgId mailbox; 

            // Find mailbox by this unefficient function because cenrep does not hold pluginID

            if ( KErrNone == ResolveMailbox( cenrepMailboxes[i], mailbox ) )

                {

                iMailboxArray.InsertL( mailbox, i );

                INFO_1("Mailbox added to iMailboxArray: i = %d ", i );

                // ensured iMailboxArray[i].Id() == cenrepMailboxes[i]

                }

            else // KErrNotFound

                {

                // remove not valid mailbox from cenrep arrays

                cenrepMailboxes.Remove( i );

                cenrepMailboxesExistence.Remove( i );

                // remove from cenrep

                ret = iCenRep->Reset( KCMailMailboxIdBase + i );

                ret = iCenRep->Reset( KCMailPluginIdBase + i );

                ret = iCenRep->Reset( KCMailWidgetContentIdBase + i );

                INFO_1("Mailbox removed from cenrep: i = %d ", i );

                // update loop control expression

                dMax--;

                i--;

                }

            continue; // ensured equation or removed item

            } // end of if mailbox not in cenrep

        // Check if iMailboxArray is in correct order on i position

        TInt jMax( iMailboxArray.Count() );

        j = i; // assume iMailboxArray[i].Id() == cenrepMailboxes[i]

        if ( ( i < jMax ) && ( iMailboxArray[i].Id() != cenrepMailboxes[i] ) )

            { // not in correct order try to swap

            for ( j = i+1; j < jMax; j++ )

                {

                if ( iMailboxArray[j].Id() == cenrepMailboxes[i] )

                    { // swap is better from efficiency point of view

                    TFSMailMsgId tmp( iMailboxArray[i] ); 

                    iMailboxArray[i] = iMailboxArray[j]; 

                    iMailboxArray[j] = tmp; 

                    break; // j < jMax here

                    }

                }

            // as previous code does not detect existence of repeating id occurence

            // the loop may not find the repeated mailbox id - then j=jMax

            } 

        // if cenrep has multiplied mailbox widgets then add them 

        if ( j >= jMax ) // swapping did not help or item is missing

            {

            // if i=j=jMax then missing duplicated iArray element

            // if j>i then iArray contains not used element

            // two widgets shows the same mailbox then take already used iMailboxArray value

            dFound = cenrepMailboxes.Find( cenrepMailboxes[i] );

            if ( dFound < i )

                {

                // the arrays are synchronized below up to i, duplication to correct i place

                iMailboxArray.InsertL( iMailboxArray[dFound], i ); 

                }

            else

                {

                // unable to synchronize the arrays - algorithm is wrong

                INFO_1("CMAIL: CMailCpsSettings::LoadSettingsL() : FATAL ALGORITHM ERROR - ARRAY NOT SYNCHRONIZED  i = %d ", i );

                User::Leave( KErrNotFound );

                }

            } // end of j >= jMax 

        } // end check order for i = 0..dMax loop 

    // if iMailboxArray has more items than cenrepMailboxes then remove these items

    for( i = iMailboxArray.Count()-1; i >= dMax; i-- )

        {

        iMailboxArray.Remove(i);

        }

    CleanupStack::PopAndDestroy(&cenrepMailboxesExistence);

    CleanupStack::PopAndDestroy(&cenrepMailboxes);

    }

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

// CMailCpsSettings::LoadConfigurationL

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

//

void CMailCpsSettings::LoadConfigurationL()

    {

    FUNC_LOG;

    TInt ret( KErrNone );

    TInt value( 0 );

    ret = iCenRep->Get( KCmailCPConfiguration, value );

    if ( !ret )

        {

        INFO_2("iConfigData: %d -> %d", iConfigData, value);

        iConfigData = static_cast<TInt32>( value );

        }

    }

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

// CMailCpsSettings::GetMailboxNonZeroKeysL

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

//

void CMailCpsSettings::GetMailboxNonZeroKeysL( RArray<TUint32>& aKeys )

    {

    FUNC_LOG;

    TInt ret = iCenRep->FindNeqL( KCmailPartialKeyRange, KCmailRangeMask, 0, aKeys );

    if ( ret != KErrNone && ret != KErrNotFound )

        {

        User::Leave( ret );

        }

    }

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

// CMailCpsSettings::GetMailboxNonZeroKeysL

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

//

void CMailCpsSettings::GetExtMailboxNonZeroKeysL( RArray<TUint32>& aKeys )

    {

    FUNC_LOG;

    TInt ret = iCenRep->FindNeqL( KCmailExtMailboxKeyRange, KCmailExtMailboxRangeMask, 0, aKeys );

    if ( ret != KErrNone && ret != KErrNotFound )

        {

        User::Leave( ret );

        }

    }

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

// CMailCpsSettings::ResolveMailbox

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

//

TInt CMailCpsSettings::ResolveMailbox( const TInt aMailboxId, TFSMailMsgId& aMsg )

    {

    FUNC_LOG;

    RPointerArray<CFSMailBox> mailboxarray;

    TInt err = iMailClient.ListMailBoxes( TFSMailMsgId(), mailboxarray );

	INFO_1("CMAIL CMailCpsSettings::ResolveMailbox():: ListMailBoxes() returns %d", err);

    if( !err ) // KErrNone = 0

        {

        err = KErrNotFound;

        aMsg.SetId( aMailboxId );

        const TInt iiMax( mailboxarray.Count() );

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

            {

            if ( mailboxarray[ii]->GetId().Id() == aMsg.Id() )

                {

                // Mailbox found

                aMsg.SetPluginId( mailboxarray[ii]->GetId().PluginId() );

                err = KErrNone; 

                break;

                }

            }

        }

    mailboxarray.ResetAndDestroy();

    return err;

    }

TInt CMailCpsSettings::CheckMailboxExistence( TFSMailMsgId& aMsg )

    {

    FUNC_LOG;

    CFSMailBox *mbox( NULL );

    TRAPD(err, mbox = iMailClient.GetMailBoxByUidL(aMsg));

    if ( mbox ) // mail box exists

        {

        delete mbox;

        return KErrNone;

        }

    if ( ( KErrNotFound == err ) || ( KErrNone == err ) )

        {

    // mail box not exists, chek if it is not in different plugin 

    // very safe, maybe return KErrNotFound would be enough

        return ResolveMailbox( aMsg.Id(), aMsg );

        }

    return err;

    }

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

// CMailCpsSettings::StartObservingL

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

//

void CMailCpsSettings::StartObservingL( MMailCpsSettingsCallback* aObserver )

    {

    FUNC_LOG;

    iObserver = aObserver;

    StartObservingL();

    }

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

// CMailCpsSettings::StartObservingL

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

//

void CMailCpsSettings::StartObservingL()

    {

    FUNC_LOG;

    TInt ret = iCenRep->NotifyRequest( KCmailPartialKey, KCmailMask, iStatus );

    if ( ret )

        {

        User::Leave( ret );

        }

    SetActive();

    }

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

// CMailCpsSettings::StopObserving

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

//

void CMailCpsSettings::StopObserving()

    {

    FUNC_LOG;

    Cancel();

    // observer not owned by settings

    iObserver = NULL;

    }

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

// CMailCpsSettings::Mailboxes

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

//

RArray<TFSMailMsgId>& CMailCpsSettings::Mailboxes()

    {

    FUNC_LOG;

    return iMailboxArray;

    }

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

// CMailCpsSettings::ExternalMailboxes

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

//

void CMailCpsSettings::GetExtMailboxesL( RPointerArray<CMailExternalAccount>& aAccounts )

    {

    FUNC_LOG;

    RArray<TUint32> keys;

    CleanupClosePushL( keys );

    GetExtMailboxNonZeroKeysL( keys );

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

        {

        CMailExternalAccount* account = GetExtMailboxL( keys[i] );

        CleanupStack::PushL( account );

        aAccounts.AppendL( account );

        CleanupStack::Pop( account );

        }

    CleanupStack::PopAndDestroy(&keys); // keys

    }

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

// CMailCpsSettings::GetExtMailboxL

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

//

CMailExternalAccount* CMailCpsSettings::GetExtMailboxL( TInt aKey )

    {

    FUNC_LOG;

    TInt mailboxId( 0 );

    TInt pluginId( 0 );

    HBufC* contentIdBuf = HBufC::NewL( KMaxDescLen );

    TPtr contentId = contentIdBuf->Des();

    User::LeaveIfError( iCenRep->Get( aKey, mailboxId ) );

    User::LeaveIfError( iCenRep->Get( aKey + KCMailExtPluginIdOffset, pluginId ) );

    User::LeaveIfError( iCenRep->Get( aKey + KCMailExtWidgetCidOffset, contentId ) );

    return CMailExternalAccount::NewL(

        mailboxId, pluginId, contentIdBuf );

    }

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

// CMailCpsSettings::AddMailboxL

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

//

void CMailCpsSettings::AddMailboxL( const TFSMailMsgId aMailbox )

    {

    FUNC_LOG;

    // Ensure message is not already in settings

    RArray<TUint32> keys;

    CleanupClosePushL( keys );

    GetMailboxNonZeroKeysL( keys );

    const TInt iiMax( keys.Count() );

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

        {

        TInt value( 0 );

        iCenRep->Get( keys[ii], value );

        if( value == aMailbox.Id() )

            {

            // mailbox already in settings, simply return

            CleanupStack::PopAndDestroy( &keys );

            return;

            }

        }

    // Add mailbox to settings

    keys.Reset();

    TInt ret = iCenRep->FindEqL( KCmailPartialKeyRange, KCmailRangeMask, 0, keys );

    if ( ret != KErrNone && ret != KErrNotFound )

        {

        User::Leave( ret );

        }

    if( keys.Count() > 0 )

        {

        // Casting uint32 to int32 below is safe because following is always true: