/*

* 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:  Field Type selector

*

*/

#include <CVPbkFieldTypeSelector.h>

// Virtual Phonebook

#include <TVPbkFieldVersitProperty.h>

#include <MVPbkBaseContactField.h>

#include <MVPbkFieldType.h>

#include <VPbkUtil.h>

#include <VPbkFieldType.hrh>

#include <VPbkError.h>

#include <MVPbkContactFieldData.h>

#include <MVPbkContactFieldUriData.h>

#include <VPbkFieldTypeSelectorFactory.h>

#include <MVPbkStoreContactFieldCollection.h>

// System includes

#include <barsread.h>

#include <s32strm.h>

#include <s32mem.h>

#include <spsettings.h>

#include <spentry.h>

#include <spproperty.h>

/// Unnamed namespace for local definitions

namespace {

/// Field type selector static data

namespace KFieldTypeSelectorStatic

    {

    const TUint8 KVersionNumber = 1;

    }

/// Buffer sizes

namespace KFieldTypeSelectorExternalizeSizes

    {

    const TInt KVersionNumberSize = 1;

    const TInt KTypeCountSize = 2;

    const TInt KExtensionLengthSize = 2;

    const TInt KNonVersitTypeSize = 4;

    }

/**

 * Compares entry service name to scheme.

 * 

 * @param aEntry entry to be analyzed

 * @param aScheme to be compared with

 */

TBool CompareService(CSPEntry& aEntry, const TDesC& aScheme)

    {

    const TDesC& name = aEntry.GetServiceName();

    if (name.CompareF(aScheme) == KErrNone)

        {

        return ETrue;

        }

    return EFalse;

    }

/**

 * Compares entry based no contact action type.

 * 

 * @param aContactActionType contact action type

 * @param aEntry service entry

 * @param aScheme scheme

 */

TBool CompareContactActionType(

        TInt aContactActionType, CSPEntry& aEntry, const TDesC& aScheme)

    {

    TBool result = EFalse;

    const CSPProperty* prop = NULL;

    if (aContactActionType == 

            VPbkFieldTypeSelectorFactory::EInstantMessagingSelector)

        {

        if (aEntry.GetProperty(prop, ESubPropertyIMLaunchUid) == KErrNone)

            {

            result = CompareService(aEntry, aScheme);

            }

        }

    if (aContactActionType == 

            VPbkFieldTypeSelectorFactory::EVOIPCallSelector)

        {

        if (aEntry.GetProperty(prop, EPropertyServiceAttributeMask) == KErrNone)

            {

            TInt value = 0;

            prop->GetValue(value);

            if (value & ESupportsInternetCall)

                {

                result = CompareService(aEntry, aScheme);

                }

            }

        }

    return result;

    }

} /// namespace

struct CVPbkFieldTypeSelector::TSelectionProperty

    {

    /**

     * Resets selection properties.

     */

    void Reset();

    /// Own: selector version

    TUint8 iSelectorVersion;

    /// Own: Versit properties

    RArray<TVPbkFieldVersitProperty> iVersitProperties;

    /// Own: Exclude parameters for versit properties

    TVPbkFieldTypeParameters iExcludedTypeParameters;

    /// Own: Non-Versit types

    RArray<TVPbkNonVersitFieldType> iNonVersitTypes;

    /// Own: Versit property extension names store

    VPbkEngUtils::CTextStore* iTextStore;

    };

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

// CVPbkFieldTypeSelector::CVPbkFieldTypeSelector

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

//

void CVPbkFieldTypeSelector::TSelectionProperty::Reset()

    {

    iVersitProperties.Reset();

    iExcludedTypeParameters.Reset();

    iNonVersitTypes.Reset();

    delete iTextStore;

    iTextStore = NULL;

    }

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

// CVPbkFieldTypeSelector::CVPbkFieldTypeSelector

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

//

CVPbkFieldTypeSelector::CVPbkFieldTypeSelector

        ( const MVPbkFieldTypeList& aFieldTypeList ) :

            iFieldTypeList( aFieldTypeList )

    {

    }

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

// CVPbkFieldTypeSelector::~CVPbkFieldTypeSelector

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

//

CVPbkFieldTypeSelector::~CVPbkFieldTypeSelector()

    {

    SelectionPropertyReset();

    }

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

// CVPbkFieldTypeSelector::NewL

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

//

EXPORT_C CVPbkFieldTypeSelector* CVPbkFieldTypeSelector::NewL

        ( TResourceReader& aReader, const MVPbkFieldTypeList& aFieldTypeList )

    {

    CVPbkFieldTypeSelector* self =

        new ( ELeave ) CVPbkFieldTypeSelector( aFieldTypeList );

    CleanupStack::PushL( self );

    self->ConstructL( aReader );

    CleanupStack::Pop( self );

    return self;

    }

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

// CVPbkFieldTypeSelector::NewL

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

//

EXPORT_C CVPbkFieldTypeSelector* CVPbkFieldTypeSelector::NewL

        ( const MVPbkFieldTypeList& aFieldTypeList )

    {

    CVPbkFieldTypeSelector* self =

        new ( ELeave ) CVPbkFieldTypeSelector( aFieldTypeList );

    CleanupStack::PushL( self );

    self->CommonConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CVPbkFieldTypeSelector::NewL

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

//

EXPORT_C CVPbkFieldTypeSelector* CVPbkFieldTypeSelector::NewL

        ( const CVPbkFieldTypeSelector& aSelector )

    {

    CVPbkFieldTypeSelector* self =

        new ( ELeave ) CVPbkFieldTypeSelector( aSelector.iFieldTypeList );

    CleanupStack::PushL( self );

    self->ConstructL( aSelector );

    CleanupStack::Pop( self );

    return self;

    }

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

// CVPbkFieldTypeSelector::CommonConstructL

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

//

void CVPbkFieldTypeSelector::CommonConstructL()

    {

    }

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

// CVPbkFieldTypeSelector::ConstructL

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

//

inline void CVPbkFieldTypeSelector::ConstructL( TResourceReader& aReader )

    {

    CommonConstructL();

    DoAppendL( aReader );

    }

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

// CVPbkFieldTypeSelector::ConstructL

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

//

inline void CVPbkFieldTypeSelector::ConstructL

        ( const CVPbkFieldTypeSelector& aSelector )

    {

    CommonConstructL();

    iContactActionType = aSelector.iContactActionType;

    TInt i = 0;

    TInt count = aSelector.iSelectionProperties.Count();

    while (--count >= 0)

        {

        TSelectionProperty fromProperty = aSelector.iSelectionProperties[count];

        // create property to copy to

        TSelectionProperty selectionProperty;

        selectionProperty.iTextStore = new (ELeave) VPbkEngUtils::CTextStore;

        CleanupStack::PushL(selectionProperty.iTextStore);

        selectionProperty.iSelectorVersion = fromProperty.iSelectorVersion;

        const TInt versitPropertyCount = fromProperty.iVersitProperties.Count();

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

            {

            User::LeaveIfError( selectionProperty.iVersitProperties.Append

                ( fromProperty.iVersitProperties[i] ) );

            TVPbkFieldVersitProperty& property =

                selectionProperty.iVersitProperties[

                    selectionProperty.iVersitProperties.Count()-1];

            if ( property.ExtensionName().Length() > 0 )

                {

                property.SetExtensionName

                    ( selectionProperty.iTextStore->AddL( property.ExtensionName() ) );

                }

            }

        // copy exclude params

        TUint32* slots = fromProperty.iExcludedTypeParameters.FieldTypeParameters();

        TUint32* targetSlots = selectionProperty.iExcludedTypeParameters.FieldTypeParameters();

        for (TInt i = 0; 

             i < fromProperty.iExcludedTypeParameters.Size();

             ++i)

            {

            targetSlots[i] = slots[i];

            }

        const TInt nonVersitTypeCount = fromProperty.iNonVersitTypes.Count();

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

            {

            User::LeaveIfError( selectionProperty.iNonVersitTypes.Append

                ( fromProperty.iNonVersitTypes[i] ) );

            }

        iSelectionProperties.AppendL(selectionProperty);

        CleanupStack::Pop(selectionProperty.iTextStore);

        }

    }

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

// CVPbkFieldTypeSelector::ExternalizeLC

// Field type selector pack format 1:

//

// stream := StreamVersion SelectorVersion VersitPropertyCount

//           NonVersitTypeCount VersitProperty* NonVersitType*

// StreamVersion := TUint8

// SelectorVersion := TUint8

// VersitPropertyCount := TUint16

// NonVersitTypeCount := TUint16

// VersitProperty := PropertyData ExtensionNameLength ExtensionName

// PropertyData := sizeof(TVPbkFieldVersitProperty)

// ExtensionNameLength := TUint16

// ExtensionName := char*

// NonVersitType := TInt32

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

//

EXPORT_C HBufC8* CVPbkFieldTypeSelector::ExternalizeLC() const

    {

    const TInt bufferSize = CalculateBufferSize();

    HBufC8* buffer = HBufC8::NewLC( bufferSize );

    TPtr8 bufPtr( buffer->Des() );

    RDesWriteStream writeStream( bufPtr );

    writeStream.PushL();

    DoFillBufferL( writeStream );

    writeStream.CommitL();

    CleanupStack::PopAndDestroy( &writeStream );

    return buffer;

    }

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

// CVPbkFieldTypeSelector::InternalizeL

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

//

EXPORT_C void CVPbkFieldTypeSelector::InternalizeL

        ( const TDesC8& aBuffer )

    {

    SelectionPropertyReset();

    RDesReadStream readStream( aBuffer );

    readStream.PushL();

    // Pack format version number

    const TInt vsn = readStream.ReadUint8L();

    __ASSERT_ALWAYS( vsn == KFieldTypeSelectorStatic::KVersionNumber,

            VPbkError::Panic( VPbkError::EInvalidTypeParameter ) );

    const TInt selectionPropertyCount = readStream.ReadUint16L();

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

        {

        TSelectionProperty selectionProperty;

        selectionProperty.iTextStore = new (ELeave) VPbkEngUtils::CTextStore;

        CleanupStack::PushL(selectionProperty.iTextStore);

        // VPBK_FIELD_TYPE_SELECTOR version number.

        selectionProperty.iSelectorVersion = readStream.ReadUint8L();

        // Read count of types

        TInt versitCount = readStream.ReadUint16L();

        TInt excludeParamsSize = 0;

        if (selectionProperty.iSelectorVersion >= EVPbkFieldTypeSelectorV2)

            {

            excludeParamsSize = readStream.ReadUint16L();

            }

        TInt nonVersitCount = readStream.ReadUint16L();

        // Read types

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

            {

            // Read basic Versit property

            TVPbkFieldVersitProperty property;

            TPckg<TVPbkFieldVersitProperty> versitPckg( property );

            readStream.ReadL( versitPckg, versitPckg.Size() ); 

            // Read ext name

            TInt extNameLength = readStream.ReadUint16L();

            if ( extNameLength > 0 )

                {

                HBufC8* extName = HBufC8::NewLC( extNameLength );

                TPtr8 extNamePtr( extName->Des() );

                readStream.ReadL( extNamePtr, extNameLength );

                if ( extName->Length() > 0 )

                    {

                    property.SetExtensionName( selectionProperty.iTextStore->AddL( *extName ) );

                    }

                CleanupStack::PopAndDestroy( extName ); // extName

                }

            selectionProperty.iVersitProperties.AppendL( property );

            }

        TUint32* slots = selectionProperty.iExcludedTypeParameters.FieldTypeParameters();

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

            {

            slots[i] = readStream.ReadUint32L();

            }

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

            {

            TVPbkNonVersitFieldType type = 

                static_cast<TVPbkNonVersitFieldType>( readStream.ReadInt32L() );

            selectionProperty.iNonVersitTypes.AppendL( type );

            }

        iSelectionProperties.AppendL(selectionProperty);

        CleanupStack::Pop(selectionProperty.iTextStore);

        }

    iContactActionType = readStream.ReadInt32L();

    CleanupStack::PopAndDestroy( &readStream );

    }

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

// CVPbkFieldTypeSelector::MatchingVersitProperty

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

//

EXPORT_C const TVPbkFieldVersitProperty*

    CVPbkFieldTypeSelector::MatchingVersitProperty(

        const MVPbkFieldType& aFieldType ) const

    {

    const TVPbkFieldVersitProperty* ret = NULL;

    TInt count = iSelectionProperties.Count();

    while (--count >= 0 && ret == NULL)

        {

        TSelectionProperty selectionProperty = iSelectionProperties[count];

        const TInt versitPropertyCount = selectionProperty.iVersitProperties.Count();

        for (TInt i = 0; i < versitPropertyCount && !ret; ++i )

            {

            const TInt maxMatchPriority =

                aFieldType.VersitProperties().Count() - 1;

            for ( TInt matchPriority = 0;

                    matchPriority <= maxMatchPriority; ++matchPriority )

                {

                if ( selectionProperty.iVersitProperties[i].Matches(

                        aFieldType.VersitProperties()[matchPriority] ) )

                    {

                    ret = &selectionProperty.iVersitProperties[i];

                    break;

                    }

                }

            }

        }

    return ret;

    }

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

// CVPbkFieldTypeSelector::MatchingNonVersitType

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

//

EXPORT_C TVPbkNonVersitFieldType CVPbkFieldTypeSelector::MatchingNonVersitType(

        const MVPbkFieldType& aFieldType ) const

    {

    TVPbkNonVersitFieldType ret = EVPbkNonVersitTypeNone;

    TInt count = iSelectionProperties.Count();

    while (--count >= 0 && ret == EVPbkNonVersitTypeNone)

        {

        TSelectionProperty selectionProperty = iSelectionProperties[count];    

        const TInt nonVersitTypeCount = selectionProperty.iNonVersitTypes.Count();

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

            {

            if ( selectionProperty.iNonVersitTypes[i] == aFieldType.NonVersitType() )

                {

                ret = selectionProperty.iNonVersitTypes[i];

                break;

                }

            }

        }

    return ret;

    }

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

// CVPbkFieldTypeSelector::FieldTypeList

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

//

const MVPbkFieldTypeList&

        CVPbkFieldTypeSelector::FieldTypeList() const

    {

    return iFieldTypeList;

    }

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

// CVPbkFieldTypeSelector::AppendL

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

//

void CVPbkFieldTypeSelector::AppendL( TResourceReader& aReader )

    {

    DoAppendL( aReader );

    }

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

// CVPbkFieldTypeSelector::SetContactActionType

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

//

void CVPbkFieldTypeSelector::SetContactActionType(TInt aContactActionType)

    {

    iContactActionType = aContactActionType;

    }

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

// CVPbkFieldTypeSelector::IsFieldIncluded

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

//

TBool CVPbkFieldTypeSelector::IsFieldIncluded

        ( const MVPbkBaseContactField& aField ) const

    {

    const TInt maxMatchPriority = iFieldTypeList.MaxMatchPriority();

    for ( TInt matchPriority = 0;

            matchPriority <= maxMatchPriority; ++matchPriority )

        {

        const MVPbkFieldType* ft = aField.MatchFieldType( matchPriority );

        if ( ft && IsFieldTypeIncluded( *ft ) && IsFieldDataIncluded(aField))

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CVPbkFieldTypeSelector::AddressFieldsIncluded

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

//

EXPORT_C TInt CVPbkFieldTypeSelector::AddressFieldsIncluded

        ( const MVPbkStoreContactFieldCollection& aFields ) const

    {

    TBool addressGeneric = EFalse;

    TBool addressHome = EFalse;

    TBool addressWork = EFalse;

    for ( TInt i = 0; i < aFields.FieldCount(); ++i )

    	{