/*
* Copyright (c) 2005 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:  Contact lists manager
*
*/

// INCLUDE FILES
#include <e32std.h>

#include "CPEngContactListManager.h"

#include "CPEngContactListModBase.h"
#include "CPEngContactListSettings.h"
#include "CPEngSessionSlotId.h"

#include "MPEngListLibFactory.h"

#include "PresenceDebugPrint.h"

#include "PEngContactIdsTools.h"

#include "MPEngStorageManager.h"


//Default granurality for list of lists
const TInt KListOfListsGranurality = 3;


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

// -----------------------------------------------------------------------------
// CPEngContactListManager::CPEngContactListManager()
// -----------------------------------------------------------------------------
//
CPEngContactListManager::CPEngContactListManager( MPEngListLibFactory& aFactory )
        : CPEngContactListManagerBase( aFactory ),
        iAllLists( KListOfListsGranurality ),
        iSynchronizedLists( KListOfListsGranurality )
    {
    }


// -----------------------------------------------------------------------------
// CPEngContactListManager::ConstructL()
// -----------------------------------------------------------------------------
//
void CPEngContactListManager::ConstructL( const CPEngSessionSlotId& aSessionSlot )
    {
    CPEngContactListManagerBase::ConstructL( aSessionSlot );
    HandleSettingsUpdateL();
    }


// -----------------------------------------------------------------------------
// CPEngContactListManager::NewL()
// -----------------------------------------------------------------------------
//
CPEngContactListManager* CPEngContactListManager::NewL(
    MPEngListLibFactory& aFactory,
    const CPEngSessionSlotId& aSessionSlot )
    {
    CPEngContactListManager* self = NewLC( aFactory, aSessionSlot );
    CleanupStack::Pop();  //self
    return self;
    }


// -----------------------------------------------------------------------------
// CPEngContactListManager::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPEngContactListManager* CPEngContactListManager::NewLC(
    MPEngListLibFactory& aFactory,
    const CPEngSessionSlotId& aSessionSlot )
    {
    CPEngContactListManager* self =
        new ( ELeave ) CPEngContactListManager( aFactory );

    CleanupClosePushL( *self );
    self->ConstructL( aSessionSlot );
    return self;
    }


// Destructor
CPEngContactListManager::~CPEngContactListManager()
    {
    iAllLists.Reset();
    iSynchronizedLists.Reset();
    }



// =============================================================================
// ===============Function from MPEngContactListManager =======================
// =============================================================================

// -----------------------------------------------------------------------------
// CPEngContactListManager::Close()
// -----------------------------------------------------------------------------
//
void CPEngContactListManager::Close()
    {
    iAccessCount--;
    if ( iAccessCount == 0 )
        {
        iFactory.RemoveCntListManager( this );
        delete this;
        }
    }


// -----------------------------------------------------------------------------
// CPEngContactListManager::ContactListL()
// -----------------------------------------------------------------------------
//
MPEngContactListAdvance& CPEngContactListManager::ContactListL(
    const TDesC& aContactList )
    {
    return LoadContactListModelL( aContactList, EFalse, EFalse );
    }


// -----------------------------------------------------------------------------
// CPEngContactListManager::PEngActiveContactLists()
// -----------------------------------------------------------------------------
//
const MDesCArray& CPEngContactListManager::AllContactListsL() const
    {
    return iAllLists;
    }


// -----------------------------------------------------------------------------
// CPEngContactListManager::PEngActiveContactLists()
// -----------------------------------------------------------------------------
//
const MDesCArray& CPEngContactListManager::SynchronizedContactLists() const
    {
    return iSynchronizedLists;
    }


// -----------------------------------------------------------------------------
// CPEngContactListManager::ContactListSettingsL()
// -----------------------------------------------------------------------------
//
MPEngContactListProperties& CPEngContactListManager::ContactListSettingsL(
    const TDesC& aContacList )
    {
    CPEngContactListSettings* settings = ContactListSettingsOrNull( aContacList );
    if ( !settings )
        {
        User::Leave( KErrNotFound );
        }

    return *settings;
    }

// -----------------------------------------------------------------------------
// CPEngContactListManager::SetAsDefaultCntListL()
// -----------------------------------------------------------------------------
//
void CPEngContactListManager::SetAsDefaultCntListL(
    const TDesC& aContactList )
    {
    // find contact list and set it as new default contact list
    MPEngContactListProperties& settings = ContactListSettingsL( aContactList );


    // is it already default contact list
    if ( settings.IsDefault() )
        {
        settings.DeletePropertyL( KPEngNewDefaultContactList,
                                  KPEngCntLstPropertyNativeCached );
        return;
        }


    // update settings
    settings.SetPropertyL( KPEngNewDefaultContactList,
                           KPEngCntLstPropertyNativeCached,
                           ETrue );

    settings.SetPropertyL( KPEngPropertiesUpdateNeeded,
                           KPEngCntLstPropertyNativeCached,
                           ETrue );

    // update settings in the current default contact list
    MPEngContactListProperties* defaultCntList = DefaultCntListSettingsOrNull();
    if ( defaultCntList )
        {
        defaultCntList->SetPropertyL( KPEngNewDefaultContactList,
                                      KPEngCntLstPropertyNativeCached,
                                      KErrCancel );
        }
    }


// -----------------------------------------------------------------------------
// CPEngContactListManager::CreateContactListL()
// -----------------------------------------------------------------------------
//
MPEngContactListProperties& CPEngContactListManager::CreateContactListL(
    const TDesC& aContactList,
    TPEngContactListBaseSettings& aBaseSettings )
    {
    // check if such a list not exist already
    if ( ContactListSettingsOrNull( aContactList ) )
        {
        User::Leave( KErrAlreadyExists );
        }


    // add new contact list settings
    CPEngContactListSettings* newList = CPEngContactListSettings::NewLC(
                                            aContactList,
                                            aBaseSettings,
                                            *this );
    if ( aBaseSettings.iContactListNameAutoUpdate )
        {
        // get user name
        TChar domainSeparator( '@' );
        TInt offset( iSessionId->UserId().LocateF( domainSeparator ) );
        TPtrC userName( KErrNotFound == offset ? iSessionId->UserId()
                        : iSessionId->UserId().Left( offset ) );

        newList->UpdateListServerNameL( userName, iUserDomain );
        }


    InsertContactListSettingsL( *newList );
    CleanupStack::Pop(); // newList

    // update array of lists and store settings
    HandleSettingsUpdateL();
    StoreSettingsL();

    return *newList;
    }


// -----------------------------------------------------------------------------
// CPEngContactListManager::DeleteContactListL()
// -----------------------------------------------------------------------------
//
void CPEngContactListManager::DeleteContactListL( const TDesC& aContactList )
    {
    if ( ContactListModelOrNull( aContactList ) )
        {
        User::Leave( KErrInUse );
        }


    CPEngContactListSettings* cntList = ContactListSettingsOrNull( aContactList );
    if ( !cntList )
        {
        User::Leave( KErrNotFound );
        }


    cntList->SetPropertyL( KPEngContactListDeleteNeeded,
                           KPEngCntLstPropertyNativeCached,
                           ETrue );
    }


// -----------------------------------------------------------------------------
// CPEngContactListManager::ChangeContactListTypeL()
// -----------------------------------------------------------------------------
//
void CPEngContactListManager::ChangeContactListTypeL(
    const TDesC& aContactList,
    TPEngContactListType aContactListType )
    {
    // find contact list settings
    CPEngContactListSettings* settings = ContactListSettingsOrNull( aContactList );
    if ( !settings )
        {
        User::Leave( KErrNotFound );
        }

    if ( settings->BaseSettings().iContactListType == aContactListType )
        {
        // type is same, nothing to do
        return;
        }

    // load model
    CPEngContactListModBase* model = &LoadContactListModelL( aContactList,
                                                             EFalse,
                                                             ETrue );
    // update storage type of the model
    model->ChangeStorageTypeL( CPEngContactListModBase::StoreTypeForListType( aContactListType ) );
    settings->UpdateListTypeL( aContactListType );
    }


// -----------------------------------------------------------------------------
// CPEngContactListManager::ReleaseCntListModel()
// -----------------------------------------------------------------------------
//
void CPEngContactListManager::ReleaseCntListModel( const TDesC& aContactList )
    {
    CPEngContactListModBase* model = ContactListModelOrNull( aContactList );
    if ( model )
        {
        model->Close();
        }
    }



// =============================================================================
// =============== from CPEngContactListManagerBase ============================
// =============================================================================


// -----------------------------------------------------------------------------
// CPEngContactListManager::HandleSettingsUpdateL()
// -----------------------------------------------------------------------------
//
void CPEngContactListManager::HandleSettingsUpdateL( void )
    {
    CPEngContactListManagerBase::HandleSettingsUpdateL();


    iAllLists.Reset();
    iSynchronizedLists.Reset();


    TInt count ( iContactListSettings.Count() );
    for ( TInt x( 0 ) ; x < count ; x++ )
        {
        CPEngContactListSettings* listSettings = iContactListSettings[ x ];

        iAllLists.AppendL( listSettings->Name() );

        if ( listSettings->Synchronized() )
            {
            iSynchronizedLists.AppendL( listSettings->Name() );
            }
        }


    // look for models of the contact lists which has been deleted and remove them
    count = iContactLists.Count() - 1;
    for ( ; count >= 0 ; --count )
        {
        if ( !( & ( iContactLists[ count ]->Settings() ) ) )
            {
            // intance removes itself from array in its destructor
            iContactLists[ count ]->Close();
            }
        }
    }

//  End of File