/*

* Copyright (c) 2004-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 field factory

*

*/

// INCLUDES

// From VirtualPhonebook

#include "CFieldFactory.h"

#include "CFieldTypeMap.h"

#include "CFieldInfo.h"

#include <TVPbkFieldVersitProperty.h>

#include <MVPbkFieldType.h>

#include <RLocalizedResourceFile.h>

#include <VPbkDataCaging.hrh>

#include <VPbkCntModelRes.rsg>

// System includes

#include <cntdef.hrh>

#include <cntitem.h>

#include <barsread.h>

namespace {

// CONSTANTS

_LIT(KCntExtResFile, "VPbkCntModelRes.rsc");

}

namespace VPbkCntModel {

TBool ContainsField( CFieldsInfo& aFieldsInfo, 

        const CContactItemField& aField )

    {

    const TInt count = aFieldsInfo.Count();

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

        {

        if ( aFieldsInfo[i]->IsEqualType( aField ) )

            {

            return ETrue;

            }

        }

    return EFalse;

    }    

/**

 * Maps a Versit type to a Contact Model field.

 */

NONSHARABLE_CLASS(CFieldFactory::TFieldAndTypeTuple)

    {

    public:

        TFieldAndTypeTuple(const MVPbkFieldType& aFieldType, 

                          const CContactItemField& aNativeField);

    public:

        const MVPbkFieldType& iFieldType;

        const CContactItemField& iNativeField;

    };

CFieldFactory::TFieldAndTypeTuple::TFieldAndTypeTuple

        (const MVPbkFieldType& aFieldType, 

         const CContactItemField& aNativeField) :

    iFieldType(aFieldType),

    iNativeField(aNativeField)

    {

    }

// CFieldFactory implementation

CFieldFactory::CFieldFactory()

    {

    }

inline void CFieldFactory::ConstructL(

        const CFieldTypeMap& aFieldTypeMap, 

        const CContactItem& aSystemTemplate,

        const MVPbkFieldTypeList& aMasterFieldTypeList,

        RFs& aFs )

    {

    // open the golden template extension resource file

    // for filtering some fields that are not allowed to create.

    VPbkEngUtils::RLocalizedResourceFile resFile;

    resFile.OpenLC(aFs, KVPbkRomFileDrive, KDC_RESOURCE_FILES_DIR, 

        KCntExtResFile );

    // Create fields infos that are not allowed to create from the factory

    TResourceReader reader;

    reader.SetBuffer( resFile.AllocReadLC( R_CNTUI_NON_CREATABLE_FIELD_DEFNS ));

    CFieldsInfo* fieldsInfo = CFieldsInfo::NewL( reader );

    CleanupStack::PopAndDestroy(); // reader buffer

    CleanupStack::PushL( fieldsInfo );

    const CContactItemFieldSet& fieldSet = aSystemTemplate.CardFields();

    const TInt fieldCount = fieldSet.Count();

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

        {

        const CContactItemField& nativeField = fieldSet[i];

        if ( !ContainsField( *fieldsInfo, nativeField ) )

            {

            DoInsertMappingTupleL(aMasterFieldTypeList, 

                    aFieldTypeMap, nativeField);

            }

        }

    CleanupStack::PopAndDestroy( fieldsInfo );

    iMaxMatchPriority = aMasterFieldTypeList.MaxMatchPriority();

    // add field and type mappings that are not in the system template

    reader.SetBuffer( resFile.AllocReadLC( 

            R_CNTUI_NON_SYSTEM_TEMPLATE_FIELD_DEFNS ));

    CFieldsInfo* nonSystemTemplatefieldsInfo = CFieldsInfo::NewL( reader );

    CleanupStack::PopAndDestroy(2); // reader buffer, resFile

    CleanupStack::PushL( nonSystemTemplatefieldsInfo );

    for (TInt j = 0; j < nonSystemTemplatefieldsInfo->Count() ; ++j )

        {

        const CFieldInfo* fieldInfo = (*nonSystemTemplatefieldsInfo)[j];

        CContactItemField* field = fieldInfo->CreateFieldL();

        CleanupStack::PushL(field);

        DoInsertMappingTupleL(aMasterFieldTypeList, 

                aFieldTypeMap, *field);

        // append field to array of non system template fields        

        iNonSystemTemplateFields.AppendL(field);

        CleanupStack::Pop(field);

        }

    CleanupStack::PopAndDestroy( nonSystemTemplatefieldsInfo );

    }

CFieldFactory* CFieldFactory::NewL(

        const CFieldTypeMap& aFieldTypeMap, 

        CContactItem* aSystemTemplate, 

        const MVPbkFieldTypeList& aMasterFieldTypeList,

        RFs& aFs )

    {

    CFieldFactory* self = new(ELeave) CFieldFactory;

    CleanupStack::PushL(self);

    self->ConstructL(aFieldTypeMap, *aSystemTemplate, aMasterFieldTypeList, 

        aFs );

    CleanupStack::Pop(self);

    // Take ownership after all initialisation that can leave is done

    self->iSystemTemplate = aSystemTemplate;

    return self;

    }

CFieldFactory::~CFieldFactory()

    {

    iFieldAndTypeMapping.Close();

    iNonSystemTemplateFields.ResetAndDestroy();

    delete iSystemTemplate;

    }

CContactItemField* CFieldFactory::CreateFieldLC

        (const MVPbkFieldType& aFieldType) const

    {

    CContactItemField* result = NULL;

    const CContactItemField* field = FindField(aFieldType);

    if (field)

        {

        result = CContactItemField::NewLC(*field);

        }

    return result;

    }

const CContactItemField* CFieldFactory::FindField(const MVPbkFieldType& aFieldType) const

    {

    const CContactItemField* contactItemField = NULL;

    const TInt count = iFieldAndTypeMapping.Count();

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

        {

        if (iFieldAndTypeMapping[i].iFieldType.IsSame(aFieldType))

            {

            contactItemField = &iFieldAndTypeMapping[i].iNativeField;

            break;

            }

        }

    return contactItemField;

    }

TInt CFieldFactory::FieldTypeCount() const

    {

    return iFieldAndTypeMapping.Count();

    }

const MVPbkFieldType& CFieldFactory::FieldTypeAt(TInt aIndex) const

    {

    return iFieldAndTypeMapping[aIndex].iFieldType;

    }

TBool CFieldFactory::ContainsSame(const MVPbkFieldType& aFieldType) const

    {

    TBool result = EFalse;

    const TInt count = iFieldAndTypeMapping.Count();

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

        {

        if (iFieldAndTypeMapping[i].iFieldType.IsSame(aFieldType))

            {

            result = ETrue;

            break;

            }

        }

    return result;

    }

TInt CFieldFactory::MaxMatchPriority() const

    {

    return iMaxMatchPriority;

    }

const MVPbkFieldType* CFieldFactory::FindMatch(

        const TVPbkFieldVersitProperty& aMatchProperty,

        TInt aMatchPriority) const

    {

    const MVPbkFieldType* result = NULL;

    const TInt count = iFieldAndTypeMapping.Count();

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

        {

        if (iFieldAndTypeMapping[i].iFieldType.Matches(aMatchProperty, aMatchPriority))

            {

            result = &iFieldAndTypeMapping[i].iFieldType;

            break;

            }

        }

    return result;

    }

const MVPbkFieldType* CFieldFactory::FindMatch

    (TVPbkNonVersitFieldType aNonVersitType) const

    {

    const MVPbkFieldType* result = NULL;

    const TInt count = iFieldAndTypeMapping.Count();

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

        {

        if (iFieldAndTypeMapping[i].iFieldType.NonVersitType() == aNonVersitType)

            {

            result = &iFieldAndTypeMapping[i].iFieldType;

            }

        }

    return result;

    }

const MVPbkFieldType* CFieldFactory::Find(

        TInt aFieldTypeResId) const

    {

    const MVPbkFieldType* result = NULL;

    const TInt count = iFieldAndTypeMapping.Count();

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

        {

        if (iFieldAndTypeMapping[i].iFieldType.FieldTypeResId() == aFieldTypeResId)

            {

            result = &iFieldAndTypeMapping[i].iFieldType;

            break;

            }

        }

    return result;

    }

void CFieldFactory::InsertInMasterFieldTypeOrderL( TFieldAndTypeTuple& aMapping,

        const MVPbkFieldTypeList& aMasterFieldTypeList )

    {

    // Insert field type mapping in the order defined in master field type

    // list.

    TInt newTypeIndex = IndexOfTypeInMasterList( aMapping.iFieldType, 

        aMasterFieldTypeList );

    const TInt count = iFieldAndTypeMapping.Count();

    TBool mappingInserted = EFalse;

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

        {

        TInt curTypeIndex = IndexOfTypeInMasterList

            ( iFieldAndTypeMapping[i].iFieldType, aMasterFieldTypeList );

        if ( newTypeIndex < curTypeIndex )

            {

            iFieldAndTypeMapping.InsertL( aMapping, i );

            mappingInserted = ETrue;

            }

        }

    if ( !mappingInserted )

        {

        iFieldAndTypeMapping.AppendL( aMapping );

        }

    }

TInt CFieldFactory::IndexOfTypeInMasterList( const MVPbkFieldType& aType,

        const MVPbkFieldTypeList& aMasterFieldTypeList )

    {

    const TInt count = aMasterFieldTypeList.FieldTypeCount();

    TInt result = KErrNotFound;

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

        {

        if ( aMasterFieldTypeList.FieldTypeAt( i ).IsSame( aType ) )

            {

            result =  i;

            }

        }

    return result;

    }

void CFieldFactory::DoInsertMappingTupleL(

        const MVPbkFieldTypeList& aMasterFieldTypeList,

        const CFieldTypeMap& aFieldTypeMap,

        const CContactItemField& aField)

    {

    const TInt maxMatchPriority = aMasterFieldTypeList.MaxMatchPriority();

    for (TInt matchPriority = 0; matchPriority <= maxMatchPriority; 

            ++matchPriority)

        {

        // retrieves the VPbk field type for this contact model field

        const MVPbkFieldType* genericType = aFieldTypeMap.GenericFieldType(

            aField, matchPriority);

        if (genericType)

            {

            // Field mappings must be in the correct order because this

            // class is also the supported field types of the store.

            // Field types are inserted into same order as in the master

            // field type list. This way FindMatch works correctly.

            TFieldAndTypeTuple fieldAndTypeTuple(*genericType, aField);

            InsertInMasterFieldTypeOrderL( fieldAndTypeTuple, 

                    aMasterFieldTypeList );

            break;

            }

        }

    }

}  // namespace VPbkCntModel

// end of file