/*

* Copyright (c) 2008 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:  Converts properties PIM <-> vCard

 *

*/

// CLASS HEADER

#include "cpimcardpropertyconverter.h"

// INTERNAL INCLUDES

#include "pimcommon.h"

#include "pimpanics.h"

#include "pimversit.h"

#include "cpimitem.h"

#include "cpimvcardparser.h"

#include "cpimcontactitem.h"

#include "cpimparserproperty.h"

#include "cpimcontactvalidator.h"

#include "cpimvcardparserparamarray.h"

#include "logger.h"

// EXTERNAL INCLUDES

#include <vcard.h>

#include <cntdef.h> // parameter literals

#include <tz.h>

#include <tzconverter.h>

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

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

// CPIMCardPropertyConverter::NewL

// Two-phased constructor.

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

//

CPIMCardPropertyConverter* CPIMCardPropertyConverter::NewL(

    const CPIMContactValidator& aValidator)

{

    JELOG2(EPim);

    CPIMCardPropertyConverter* self =

        new(ELeave) CPIMCardPropertyConverter(aValidator);

    return self;

}

// Destructor

CPIMCardPropertyConverter::~CPIMCardPropertyConverter()

{

    JELOG2(EPim);

}

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

// CPIMCardPropertyConverter::ConvertFieldL

// Inserts a Field from a PIM Contact Item to CParserVCard as a property.

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

//

void CPIMCardPropertyConverter::ConvertFieldL(const CPIMItem& aItem, // item to read the field from

        CParserVCard& aParser, // parser to insert the property to.

        TPIMContactField aField) // field to convert

{

    JELOG2(EPim);

    TInt valueCount = aItem.CountValuesL(aField);

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

    {

        switch (aField)

        {

        case EPIMContactAddr:

        {

            ConvertAddressFieldL(aItem, aParser, aField, i);

            break;

        }

        case EPIMContactBirthday:

        case EPIMContactRevision:

        case EPIMContactExtAnniversary:

        {

            ConvertDateFieldL(aItem, aParser, aField, i);

            break;

        }

        case EPIMContactEmail:

        case EPIMContactNote:

        case EPIMContactTel:

        case EPIMContactTitle:

        case EPIMContactUrl:

        case EPIMContactNickname:

        case EPIMContactExtSip:

        case EPIMContactExtDtmf:

        case EPIMContactExtWvUserId:

        case EPIMContactExtSpouse:

        case EPIMContactExtChildren:

        case EPIMContactExtAssistantName:

        case EPIMContactExtVoip:

        case EPIMContactExtPTT:

        case EPIMContactExtSWIS:

            // UID is required by VFX. Do not fix even though this is wrong

        case EPIMContactUid:

        {

            ConvertStringFieldL(aItem, aParser, aField, i);

            break;

        }

        case EPIMContactName:

        {

            ConvertNameFieldL(aItem, aParser, aField, i);

            break;

        }

        case EPIMContactOrg:

        case EPIMContactExtDepartment:

        {

            ConvertOrganisationalFieldsL(aItem, aParser, aField, i);

            break;

        }

        case EPIMContactPhoto:

        {

            ConvertPhotoFieldL(aItem, aParser, aField, i);

            break;

        }

        case EPIMContactClass:

        {

            ConvertClassFieldL(aItem, aParser, aField, i);

            break;

        }

        // PIM API vCard parser does not support converting formatted names

        // since the conversion is not unambiguous and an optional feature

        // for vCard parsers based on IMC vCard specification. Also, PIM

        // API internal specification version 4.3 does not allow

        // Contact.FORMATTED_NAME to be a supported fields in S60 implementations

        case EPIMContactFormattedName:

        case EPIMContactFormattedAddr:

        case EPIMContactPhotoUrl:

        case EPIMContactPublicKey:

        case EPIMContactPublicKeyString:

        default:

        {

            __ASSERT_DEBUG(EFalse, User::Panic(KPIMPanicCategory,

                                               EPIMPanicUnsupportedField));

            return;

        }

        }

    }

}

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

// CPIMCardPropertyConverter::ConvertPropertyL

// Inserts a proprety from a vCard to a PIM Contact Item as a field

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

//

CParserVCard* CPIMCardPropertyConverter::ConvertPropertyL(

    const CParserProperty& aProperty, // property to convert

    CPIMContactItem& aItem) // item to insert the field to

{

    JELOG2(EPim);

    TUid valueTypeUid = aProperty.Uid();

    TInt valueType = valueTypeUid.iUid;

    CParserVCard* retVal = NULL;

    // The following, rather ugly, cast makes it possible for us to access

    // the protected iArrayOfParams field.

    const CPIMParserProperty& property =

        static_cast<const CPIMParserProperty&>(aProperty);

    // CLASS field is converted before others

    if (aProperty.Name().CompareF(KVersitTokenClass) == 0)

    {

        ConvertClassPropertyL(property, aItem);

    }

    // If SOUND field holds parameter X-IRMC-N, it countains name reading fields

    else if ((aProperty.Name().CompareF(KVersitTokenSOUND) == 0)

             && (aProperty.Param(KVersitParam8NamePrn)))

    {

        ConvertNameReadingFieldL(property, aItem);

    }

    else

    {

        switch (valueType)

        {

        case KVersitPropertyBinaryUid:

        {

            ConvertPhotoPropertyL(property, aItem);

            break;

        }

        case KVersitPropertyCDesCArrayUid:

        {

            // name and address arrays

            ConvertCDesCArrayPropertyL(property, aItem);

            break;

        }

        case KVersitPropertyDateUid:

        case KVersitPropertyDateTimeUid:

        {

            // REV, BDAY, X-ANNIVERSARY

            ConvertDatePropertyL(property, aItem);

            break;

        }

        case KVersitPropertyHBufCUid:

        {

            ConvertStringPropertyL(property, aItem);

            break;

        }

        case KVCardPropertyAgentUid:

        {

            retVal = ConvertAgentPropertyL(property);

        }

        default:

        {

            // don't support, don't care

        }

        }

    }

    return retVal;

}

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

// CPIMCardPropertyConverter::CPIMCardPropertyConverter

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CPIMCardPropertyConverter::CPIMCardPropertyConverter(

    const CPIMContactValidator& aValidator) :

        iContactValidator(aValidator)

{

    JELOG2(EPim);

}

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

// CPIMCardPropertyConverter::ConvertAgentPropertyL

// Converts an agent property.

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

//

inline CParserVCard* CPIMCardPropertyConverter::ConvertAgentPropertyL(

    const CPIMParserProperty& aProperty) // property to convert

{

    JELOG2(EPim);

    CParserPropertyValueAgent* propertyValue =

        static_cast<CParserPropertyValueAgent*>(aProperty.Value());

    CParserVCard* value = propertyValue->Value();

    return value;

}

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

// CPIMCardPropertyConverter::AddParamHomeAndWorkL

// Adds parameters "HOME" and "WORK" if necessary to given property parameter

// array.

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

//

void CPIMCardPropertyConverter::AddParamHomeAndWorkL(TPIMAttribute aAttributes, // checked if it contains AttrHome or AttrWork

        CPIMVCardParserParamArray& aParamArray) // array to add the parameters to

{

    JELOG2(EPim);

    if ((aAttributes & EPIMContactAttrHome) != 0)

    {

        AddParserParameterL(aParamArray, KVersitParam8Home());

    }

    if ((aAttributes & EPIMContactAttrWork) != 0)

    {

        AddParserParameterL(aParamArray, KVersitParam8Work());

    }

}

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

// CPIMCardPropertyConverter::ConvertAddressFieldL

// Converts an address field from a PIM Contact Item to CParserVCard.

// The field is stored in the parser as a property.

// The address values are stored in CParserPropertyValue

// CParserProperty is created, given the value.

// Parameters are added, and finally the property is added to parser.

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

//

void CPIMCardPropertyConverter::ConvertAddressFieldL(const CPIMItem& aItem, // item to convert from

        CParserVCard& aParser, // parsers to write to

        TPIMContactField aField, // field to convert

        TInt aIndex) // index to the field

{

    JELOG2(EPim);

    // Add attributes if there are any

    TPIMAttribute attributes = aItem.getAttributes(aField, aIndex);

    CPIMVCardParserParamArray* paramArray =

        new(ELeave) CPIMVCardParserParamArray(3);

    CleanupStack::PushL(paramArray);

    AddParamHomeAndWorkL(attributes, *paramArray);

    const CDesCArray& itemAddrArray = aItem.GetStringArrayL(aField, aIndex);

    // Copy the array

    TInt elementCount = itemAddrArray.Count();

    CDesCArrayFlat* addrArray = new(ELeave) CDesCArrayFlat(elementCount);

    CleanupStack::PushL(addrArray);

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

    {

        if (itemAddrArray[i].Compare(KPIMNullArrayElement) == 0)

        {

            addrArray->AppendL(KNullDesC);

        }

        else

        {

            addrArray->AppendL(itemAddrArray[i]);

        }

    }

    CParserPropertyValue* propertyValue =

        new(ELeave) CParserPropertyValueCDesCArray(addrArray);

    // addrArray is now owned by propertyValue

    CleanupStack::Pop(addrArray);

    AddPropertyToParserL(propertyValue, KVersitTokenADR(), paramArray, aParser);

    // The paramArray and propertyValue are popped by the previous function call

}

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

// CPIMCardPropertyConverter::ConvertNameFieldL

// Converts a Name field from a PIM Contact Item to CParserVCard.

// The field is stored in the parser as a property.

// The name values are stored in CParserPropertyValue

// CParserProperty is created, given the value.

// Parameters are added, and finally the property is added to parser.

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

//

void CPIMCardPropertyConverter::ConvertNameFieldL(const CPIMItem& aItem, // item to convert from

        CParserVCard& aParser, // parsers to write to

        TPIMContactField aField, // field to convert

        TInt aIndex) // index to the field

{

    JELOG2(EPim);

    TBool readingFieldsPresent = EFalse;

    const CDesCArray& itemNameArray = aItem.GetStringArrayL(aField, aIndex);

    TInt elementCount = itemNameArray.Count();

    CDesCArray* readingArray = new(ELeave) CDesCArrayFlat(2);

    CleanupStack::PushL(readingArray);

    CDesCArray* nameArray = new(ELeave) CDesCArrayFlat(elementCount);

    CleanupStack::PushL(nameArray);

    // Names should be ordered as follows:

    // Family name, Given name, Middle name, Prefix, Suffix

    // so check TPIMContactNameElement that it is in the right order

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

    {

        // Skip extended name reading fields on here

        if (i == EPIMContactExtFamilyNameReading || i

                == EPIMContactExtGivenNameReading)

        {

            if (itemNameArray[i].Compare(KPIMNullArrayElement) != 0)

            {

                readingFieldsPresent = ETrue;

                readingArray->AppendL(itemNameArray[TPIMContactNameElement(i)]);

            }

            else

            {

                readingArray->AppendL(KNullDesC);

            }

        }

        // Replace null array elements with KNullDesC

        else if (itemNameArray[i].Compare(KPIMNullArrayElement) == 0)

        {

            nameArray->AppendL(KNullDesC);

        }

        else

        {

            nameArray->AppendL(itemNameArray[TPIMContactNameElement(i)]);

        }

    }

    CParserPropertyValue* propertyValue =

        new(ELeave) CParserPropertyValueCDesCArray(nameArray);

    // nameArray is now owned by propertyValue

    CleanupStack::Pop(nameArray);

    AddPropertyToParserL(propertyValue, KVersitTokenN(), NULL, aParser);

    // The paramArray and propertyValue are popped by the previous function call

    // Add name reading fields if they are present

    if (readingFieldsPresent)

    {

        // Create parameter array

        CPIMVCardParserParamArray* paramArray =

            new(ELeave) CPIMVCardParserParamArray(1);

        CleanupStack::PushL(paramArray);

        // Create pronunciation parameter and add it to the parameter array

        AddParserParameterL(*paramArray, KVersitParam8NamePrn());

        // Create a new proprety value from the reading names array

        CParserPropertyValue* readingPropValue =

            new(ELeave) CParserPropertyValueCDesCArray(readingArray);

        // nameArray is now owned by propertyValue

        CleanupStack::Pop(paramArray);

        CleanupStack::Pop(readingArray);

        CleanupStack::PushL(paramArray);

        AddPropertyToParserL(readingPropValue, KVersitTokenSOUND(), paramArray,

                             aParser);

        // The paramArray and propertyValue are popped

        // by the previous function call

    }

    else

    {

        // Clean the reading array

        CleanupStack::PopAndDestroy(readingArray);

    }

}

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

// CPIMCardPropertyConverter::ConvertCDesCArrayPropertyL

// Converts name and address arrays from a vCard to a PIM Contact Item

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

//

void CPIMCardPropertyConverter::ConvertCDesCArrayPropertyL(

    const CPIMParserProperty& aProperty, // property to convert

    CPIMContactItem& aItem) // item to insert the field to

{

    JELOG2(EPim);

    TPIMField field = aProperty.MatchContactField();

    if ((field != EPIMContactAddr) && (field != EPIMContactName) && (field

            != EPIMContactOrg) && (field != EPIMContactExtChildren))

    {

        // unsupported properties are silently discarded

        return;

    }

    CParserPropertyValueCDesCArray* propertyValue =

        static_cast<CParserPropertyValueCDesCArray*>(aProperty.Value());

    const CDesCArray* value = propertyValue->Value();

    // In ORG field, the Organizational name is the first item and the second

    // item is extended department name

    if (field == EPIMContactOrg)

    {

        TInt valueCount = value->Count();

        if (valueCount >= 1)

        {

            HBufC* orgValue = value->MdcaPoint(0).AllocLC();

            aItem.AddStringL(field, KPIMAttrNone, orgValue);

            CleanupStack::Pop(orgValue);

            // Get department from the array

            if (valueCount > 1)

            {

                HBufC* department = value->MdcaPoint(1).AllocLC();

                aItem.AddStringL(EPIMContactExtDepartment, KPIMAttrNone,

                                 department);

                CleanupStack::Pop(department);

            }

        }

        return;

    }

    // Children is imported as a CDesCArray so we have to convert it here

    if (field == EPIMContactExtChildren && value->Count() >= 1)

    {

        // We are only interested about the first value

        HBufC* children = value->MdcaPoint(0).AllocLC();

        aItem.AddStringL(field, KPIMAttrNone, children);

        CleanupStack::Pop(children);

        return;

    }

    // Copy the array

    TInt elementCount = value->Count();

    CDesCArrayFlat* itemArray = new(ELeave) CDesCArrayFlat(elementCount);

    CleanupStack::PushL(itemArray);

    TInt i;

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

    {

        itemArray->AppendL((*value)[i]);

    }

    // If we need more elements, add nulls

    TInt itemElementCount = iContactValidator.NumElementsL(field);

    TPtrC nullArrayElement(KPIMNullArrayElement);

    for (; i < itemElementCount; i++)

    {

        itemArray->AppendL(nullArrayElement);

    }

    TPIMAttribute attributes = KPIMAttrNone;

    // Usually people only have one name. However, both PIM api and

    // vCards allow two names: Formatted name is not supported anymore since

    // converting it is not unambiguous and it must not be supported by the

    // PIM API internal specification version 4.3. IMC's vCard specification

    // states that Formatted name is an optional field for vCard parsers.

    if (field == EPIMContactName && aItem.CountValuesL(EPIMContactName) > 0)

    {

        // we already have a name, so we just change the current one

        // NOTE: There can be name reading fields before the name array

        // elements are added so we have take care of it

        const CDesCArray& nameArray = aItem.GetStringArrayL(EPIMContactName, 0);

        TPtrC name(nameArray.MdcaPoint(EPIMContactExtFamilyNameReading));

        if (name != KPIMNullArrayElement)

        {

            // Delete empty item and add existing item

            itemArray->Delete(EPIMContactExtFamilyNameReading);

            itemArray->InsertL(EPIMContactExtFamilyNameReading, name);

        }

        name.Set(nameArray.MdcaPoint(EPIMContactExtGivenNameReading));

        if (name != KPIMNullArrayElement)

        {

            // Delete empty item and add existing item

            itemArray->Delete(EPIMContactExtGivenNameReading);

            itemArray->InsertL(EPIMContactExtGivenNameReading, name);

        }

        aItem.SetStringArrayL(EPIMContactName, 0, attributes, itemArray);

        CleanupStack::Pop(); // itemArray now owned by aItem

        return;

    }

    else

    {

        // address can have attributes

        attributes = aProperty.MatchHomeAndWorkAttributes();

    }

    aItem.AddStringArrayL(field, attributes, itemArray);

    CleanupStack::Pop(); // itemArray now owned by aItem

}

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

// CPIMCardPropertyConverter::ConvertDateFieldL

// Converts a date field from a PIM Contact Item to a CParserVCard.

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

//

void CPIMCardPropertyConverter::ConvertDateFieldL(const CPIMItem& aItem, // item to convert from

        CParserVCard& aParser, // parser to insert the property to.

        TPIMContactField aField, // field to convert

        TInt aIndex) // index to the field

{

    JELOG2(EPim);

    TVersitDateTime* versitDateTime = NULL;

    CParserPropertyValue* propertyValue = NULL;