/*

* Copyright (c) 2002-2007 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:  The virtual phonebook default attribute manager

*

*/

#include "CDefaultAttributeManager.h"

#include "CDefaultAttributeOperation.h"

// From Virtual Phonebook

#include <CVPbkContactManager.h>

#include <MVPbkContactOperation.h>

#include <VPbkStoreUriLiterals.h>

#include <MVPbkContactStoreList.h>

#include <TVPbkContactStoreUriPtr.h>

#include <MVPbkStoreContact.h>

#include <CVPbkContactFieldCollection.h>

#include <CVPbkDefaultAttribute.h>

// From VPbkCntModel

#include "CContactStore.h"

#include "CContact.h"

#include "VPbkCntModelUid.h"

// From Contacts Model

#include <cntitem.h>

namespace VPbkCntModel {

namespace {

	struct TFieldTypePair

	    {

	    TInt iProperty;

	    TInt iUid;

	    };

	static const TFieldTypePair fieldTypeMap[] =

	    {

	    /// default phone number field type

	    {EVPbkDefaultTypePhoneNumber, KIntVPbkDefaultFieldPref},

	    /// default video number field type

	    {EVPbkDefaultTypeVideoNumber, KIntVPbkDefaultFieldVideo},

	    /// default sms field type

	    {EVPbkDefaultTypeSms, KIntVPbkDefaultFieldSms},

	    /// default mms field type

	    {EVPbkDefaultTypeMms, KIntVPbkDefaultFieldMms},

	    /// default email field type

	    {EVPbkDefaultTypeEmail, KIntVPbkDefaultFieldPref},

	    /// default email over sms field type

	    {EVPbkDefaultTypeEmailOverSms, KIntVPbkDefaultFieldEmailOverSms},

	    /// default poc field type

	    {EVPbkDefaultTypePOC, KIntVPbkDefaultFieldPoc},

	    /// default voip field type

	    {EVPbkDefaultTypeVoIP, KIntVPbkDefaultFieldVoip},

        /// default chat field type

        {EVPbkDefaultTypeChat, KIntVPbkDefaultFieldChat},

        /// default url field type

        {EVPbkDefaultTypeOpenLink, KIntVPbkDefaultFieldOpenLink},

	    // Always the last one

	    {EVPbkLastDefaultType, 0}

	    };

	TFieldType FindFieldTypeForProperty(TVPbkDefaultType aProperty)

	    {

	    for (TInt i = 0; fieldTypeMap[i].iProperty != EVPbkLastDefaultType;

	         ++i)

	        {

	        if (aProperty == fieldTypeMap[i].iProperty)

	            {

	            return TFieldType::Uid(fieldTypeMap[i].iUid);

	            }

	        }

	    return KNullUid;

	    }  

    TBool IsFieldType( const TContactField& aField, TUid aUid )

        {

        for (TInt i = 0; i < aField.NativeField()->

                ContentType().FieldTypeCount(); ++i )

            {

            if ( aField.NativeField()->ContentType().FieldType( i )  ==

                    aUid )

                {

                return ETrue;

                }

            }

        return EFalse;

        }    

} // unnamed namespace

CDefaultAttributeManager::CDefaultAttributeManager(

        CVPbkContactManager& aContactManager) :

    iContactManager(aContactManager)

    {

    }

inline void CDefaultAttributeManager::ConstructL()

    {

    }

CDefaultAttributeManager* CDefaultAttributeManager::NewL(TAny* aParam)

    {

    TParam& param = *static_cast<TParam*>(aParam);

    CDefaultAttributeManager* self = new(ELeave) CDefaultAttributeManager(

        param.iContactManager);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CDefaultAttributeManager::~CDefaultAttributeManager()

    {

    }

MVPbkContactOperationBase* CDefaultAttributeManager::ListContactsL(

        TUid /*aAttributeType*/,

        MVPbkContactFindObserver& /*aObserver*/)

    {

    __ASSERT_DEBUG(EFalse, User::Leave(KErrNotSupported));

    return NULL;

    }

MVPbkContactOperationBase* CDefaultAttributeManager::ListContactsL(

        const MVPbkContactAttribute& /*aAttribute*/,

        MVPbkContactFindObserver& /*aObserver*/)

    {

    __ASSERT_DEBUG(EFalse, User::Leave(KErrNotSupported));

    return NULL;

    }

MVPbkContactOperation* CDefaultAttributeManager::CreateListContactsOperationL(

            TUid aAttributeType, 

            MVPbkContactFindObserver& aObserver)

    {

    MVPbkContactOperation* result = NULL;

    if (aAttributeType == CVPbkDefaultAttribute::Uid())

        {

        CVPbkDefaultAttribute* attribute = CVPbkDefaultAttribute::NewL(

            CVPbkDefaultAttribute::KDefaultTypeNotDefined);

        CleanupStack::PushL(attribute);

        result = CreateListContactsOperationL(*attribute, aObserver);

        CleanupStack::PopAndDestroy(attribute);

        }

    return result;   

    }

MVPbkContactOperation* CDefaultAttributeManager::CreateListContactsOperationL(

    const MVPbkContactAttribute& aAttribute, 

    MVPbkContactFindObserver& aObserver)

    {

    MVPbkContactOperation* result = NULL;

    if (aAttribute.AttributeType() == CVPbkDefaultAttribute::Uid())

        {

        const CVPbkDefaultAttribute& attribute =

                static_cast<const CVPbkDefaultAttribute&>(aAttribute);

        MVPbkContactStore* store = iContactManager.ContactStoresL().Find(

                                                   KVPbkDefaultCntDbURI());

        if (store)

            {

            CContactStore& cntStore = *static_cast<CContactStore*>(store);

            result = CDefaultAttributeOperation::NewListLC(

                cntStore,

                attribute,

                aObserver);

            result->StartL();                

            CleanupStack::Pop();

            }

        else

            {

            User::Leave(KErrNotSupported);

            }

        }

    return result;     

    }

TBool CDefaultAttributeManager::HasContactAttributeL(

        TUid aAttributeType,

        const MVPbkStoreContact& aContact) const

    {

    TBool result = EFalse;

    if (aAttributeType == CVPbkDefaultAttribute::Uid())

        {

        const CContact* contact = dynamic_cast<const CContact*>(&aContact);

        if (contact)

            {

            CContactItemFieldSet& fields = contact->NativeContact()->CardFields();

            const TInt count = fields.Count();

            for (TInt i = 0; i < count && !result; ++i)

                {

                // Loop through all defaults and check if field contains

                // that type. If any field of contact contains any default

                // we can break.

                for (TInt n = 0;

                	fieldTypeMap[n].iProperty != EVPbkLastDefaultType;

                	++n)

                	{

					TFieldType fieldType = TFieldType::Uid(fieldTypeMap[n].iUid);

                    if (fields[i].ContentType().ContainsFieldType(fieldType))

                        {

                        result = ETrue;

                        break;

                        }

                	}

                }

            }

        }

    return result;

    }

TBool CDefaultAttributeManager::HasContactAttributeL(

        const MVPbkContactAttribute& aAttribute,

        const MVPbkStoreContact& aContact) const

    {

    TBool result = EFalse;

    if (aAttribute.AttributeType() == CVPbkDefaultAttribute::Uid())

        {

        // Make sure that aContact is from CntModel store

        const CContact* contact = dynamic_cast<const CContact*>(&aContact);

        if (contact)

            {

            const CVPbkDefaultAttribute& attribute =

                    static_cast<const CVPbkDefaultAttribute&>(aAttribute);

            if (attribute.DefaultType() == CVPbkDefaultAttribute::KDefaultTypeNotDefined)

                {

    	        // If default type is not defined, we try to match any default field

                result = HasContactAttributeL(aAttribute.AttributeType(), aContact);

                }

            else

                {

                // There is already dynamic_cast

                TFieldType fieldType = FindFieldTypeForProperty(attribute.DefaultType());

                CContactItemFieldSet& fields = contact->NativeContact()->CardFields();

                const TInt count = fields.Count();

                for (TInt i = 0; i < count && !result; ++i)

                    {

                    if (fields[i].ContentType().ContainsFieldType(fieldType))

                        {

                        result = ETrue;

                        break;

                        }

                	}

                }

            }

        }

    return result;

    }

TBool CDefaultAttributeManager::HasFieldAttributeL(

        TUid aAttributeType,

        const MVPbkStoreContactField& aField) const

    {   

    TBool result = EFalse;

    // Make sure that aField is from CntModel store

    if (aAttributeType == CVPbkDefaultAttribute::Uid())

        {

        const TContactField* field = dynamic_cast<const TContactField*>(&aField);

        if ( field )

            {

            // Loop through all defaults and check if field contains

            // that type.

            for (TInt n = 0;

            	fieldTypeMap[n].iProperty != EVPbkLastDefaultType;

            	++n)

            	{

				TFieldType fieldType = TFieldType::Uid(fieldTypeMap[n].iUid);

                if (field->NativeField()->ContentType().ContainsFieldType(fieldType))

                    {

                    result = ETrue;

                    break;

                    }

            	}

            }

        }

    return result;

    }

TBool CDefaultAttributeManager::HasFieldAttributeL(

        const MVPbkContactAttribute& aAttribute,

        const MVPbkStoreContactField& aField) const

    {    

    TBool result = EFalse;

    if (aAttribute.AttributeType() == CVPbkDefaultAttribute::Uid())

        {

        const TContactField* field = dynamic_cast<const TContactField*>(&aField);

        if ( field )

            {

            const CVPbkDefaultAttribute& attribute =

                    static_cast<const CVPbkDefaultAttribute&>( aAttribute );

            if ( attribute.DefaultType() == 

                        CVPbkDefaultAttribute::KDefaultTypeNotDefined )

                {

                result = HasFieldAttributeL( aAttribute.AttributeType(), 

                                                                aField );

                }

            else

                {

				TFieldType fieldType = 

				        FindFieldTypeForProperty( attribute.DefaultType() );

                // If checking for email default we have to check that field is email 

                // field, because default phone and email has same id 

                // KIntVPbkDefaultFieldPref Field has specified default

                if ( field->NativeField()->

                            ContentType().ContainsFieldType(fieldType) )

                    {                    

                    // Only Email field can be set as email default

                    if ( attribute.DefaultType() == EVPbkDefaultTypeEmail )

                        {

                        if ( IsFieldType( *field, KUidContactFieldEMail ) )

                            {

                            result = ETrue;

                            }

                        }

                    else if ( attribute.DefaultType() == EVPbkDefaultTypePhoneNumber )

                        {

                        // Phone number default and field is not email field

                        if  ( !IsFieldType( *field, KUidContactFieldEMail ) )

                            {

                            result = ETrue;

                            }

                        }

                    else

                        {

                        result = ETrue;

                        }

                    }

                }

            }

        }

    return result;

    }

MVPbkContactOperationBase* CDefaultAttributeManager::SetContactAttributeL(

        const MVPbkContactLink& /*aContactLink*/,

        const MVPbkContactAttribute& aAttribute,

        MVPbkSetAttributeObserver& /*aObserver*/)

    {

    MVPbkContactOperationBase* result = NULL;

    if ( aAttribute.AttributeType() == CVPbkDefaultAttribute::Uid() )

        {

        User::Leave( KErrNotSupported );

        }

    return result;

    }

MVPbkContactOperationBase* CDefaultAttributeManager::SetFieldAttributeL(

        MVPbkStoreContactField& aField,

        const MVPbkContactAttribute& aAttribute,

        MVPbkSetAttributeObserver& aObserver )

    {

    MVPbkContactOperation* result = NULL;

    if ( aAttribute.AttributeType() == CVPbkDefaultAttribute::Uid() )

        {

        TContactField* field = dynamic_cast<TContactField*>( &aField );

        if ( field )

            {

            const CVPbkDefaultAttribute& attribute =

                    static_cast<const CVPbkDefaultAttribute&>( aAttribute );

            if ( attribute.DefaultType() == 

                        CVPbkDefaultAttribute::KDefaultTypeNotDefined )

                {

                User::Leave( KErrArgument );

                }

            else

                {

                // Safe to cast because the field is contact model field

                CContactStore& store = static_cast<CContactStore&>(

                    aField.ParentObject().ContactStore() );

                result = CDefaultAttributeOperation::NewSetLC(

                    store, aField, attribute, aObserver );

                result->StartL();

                CleanupStack::Pop(); // result

                }

            }

        }

    return result;

    }

MVPbkContactOperationBase* CDefaultAttributeManager::RemoveContactAttributeL(

        const MVPbkContactLink& /*aContactLink*/,

        const MVPbkContactAttribute& aAttribute,

        MVPbkSetAttributeObserver& /*aObserver*/)

    {

    MVPbkContactOperationBase* result = NULL;

    if ( aAttribute.AttributeType() == CVPbkDefaultAttribute::Uid() )

        {

        User::Leave( KErrNotSupported );

        }

    return result;

    }

MVPbkContactOperationBase* CDefaultAttributeManager::RemoveContactAttributeL(

        const MVPbkContactLink& /*aContactLink*/,

        TUid aAttributeType,

        MVPbkSetAttributeObserver& /*aObserver*/)

    {

    MVPbkContactOperationBase* result = NULL;

    if ( aAttributeType == CVPbkDefaultAttribute::Uid() )

        {

        User::Leave( KErrNotSupported );

        }

    return result;

    }

MVPbkContactOperationBase* CDefaultAttributeManager::RemoveFieldAttributeL(

        MVPbkStoreContactField& aField,

        const MVPbkContactAttribute& aAttribute,

        MVPbkSetAttributeObserver& aObserver )

    {

    MVPbkContactOperation* result = NULL;

    if ( dynamic_cast<TContactField*>(&aField) )

        {        

        if ( aAttribute.AttributeType() == CVPbkDefaultAttribute::Uid() )

            {

            const CVPbkDefaultAttribute& attribute =

                    static_cast<const CVPbkDefaultAttribute&>( aAttribute );

            MVPbkContactStore* store = iContactManager.ContactStoresL().Find(

                                                       KVPbkDefaultCntDbURI() );

            if ( store )

                {

                VPbkCntModel::CContactStore& cntStore = 

                            *static_cast<CContactStore*>( store );

                result = CDefaultAttributeOperation::NewRemoveLC(

                        cntStore, aField, attribute, aObserver );

                result->StartL();

                CleanupStack::Pop(); // result

                }

            else

                {

                User::Leave( KErrNotSupported );

                }

            }

        }

    return result;

    }

MVPbkContactOperationBase* CDefaultAttributeManager::RemoveFieldAttributeL(

        MVPbkStoreContactField& aField,

        TUid aAttributeType,

        MVPbkSetAttributeObserver& aObserver )

    {

    MVPbkContactOperationBase* result = NULL;

    if ( dynamic_cast<TContactField*>(&aField) )

        {        

        if ( aAttributeType == CVPbkDefaultAttribute::Uid() )

            {

            CVPbkDefaultAttribute* attribute = CVPbkDefaultAttribute::NewL(

                    CVPbkDefaultAttribute::KDefaultTypeNotDefined );

            CleanupStack::PushL( attribute );

            result = RemoveFieldAttributeL( aField, *attribute, aObserver );

            CleanupStack::PopAndDestroy( attribute );

            }

        }

    return result;

    }

MVPbkStoreContactFieldCollection* CDefaultAttributeManager::FindFieldsWithAttributeLC(

        TUid aAttributeType,

        MVPbkStoreContact& aContact ) const

    {

    CVPbkContactFieldCollection* result = NULL;

    if (dynamic_cast<CContact*>( &aContact ) &&

        aAttributeType == CVPbkDefaultAttribute::Uid() )

        {         

        result = CVPbkContactFieldCollection::NewLC(aContact);

        const TInt count = aContact.Fields().FieldCount();

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

            {

            MVPbkStoreContactField& field = aContact.Fields().FieldAt( i );

            if ( HasFieldAttributeL(aAttributeType, field) )

                {

                MVPbkStoreContactField* clone = field.CloneLC();

                result->AppendL( clone );

                CleanupStack::Pop(); // clone

                }

            }

        }

    return result;    

    }        

MVPbkStoreContactFieldCollection* CDefaultAttributeManager::FindFieldsWithAttributeLC(

        const MVPbkContactAttribute& aAttribute,

        MVPbkStoreContact& aContact) const

    {