/*

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

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

    }

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

// CMailCpsSettings::CMailCpsSettings

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

//

CMailCpsSettings::CMailCpsSettings( CFSMailClient& aMailClient ) :

    CActive( EPriorityStandard ),

    iMailClient( aMailClient ),

    iCenRep( NULL ),

    iConfigData( 0 )

    {

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

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

    LoadConfigurationL(); // internal configuration data

    }

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

// CMailCpsSettings::RunL

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

//

void CMailCpsSettings::RunL()

    {

    FUNC_LOG;

    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

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

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

    TInt value( 0 );

    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

    TInt dFound( KErrNotFound );

        {

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

            { 

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

            }

            {

            iMailboxArray.Remove(i);

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

            }

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

        {

        if ( ! cenrepMailboxesExistence[i] ) 

            {

            TFSMailMsgId mailbox; 

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

                {

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

                }

                {

                    }

                }

                {

                User::Leave( KErrNotFound );

                }

        }

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

            }