/*
* Copyright (c) 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: Implementation of CPosLmXmlEncoder for LMX format.
*
*
*/


#include    <e32base.h>
#include    <e32math.h>
#include    <lbsposition.h>
#include    <EPos_LandmarksErrors.h>
#include    "EPos_CPosLmLmxEncoder.h"
#include    "EPos_PosLmConverterUtils.h"

const TInt KPosFieldsGranularity = 8;

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

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmLmxEncoder::CPosLmLmxEncoder()
    {
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmLmxEncoder* CPosLmLmxEncoder::NewL()
    {
    return new (ELeave) CPosLmLmxEncoder;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmLmxEncoder::~CPosLmLmxEncoder()
    {
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmLmxEncoder::WriteStartTagsL()
    {
    // Root
    HBufC* rootAttributes = HBufC::NewLC( KPosLongStringLength );
    rootAttributes->Des().Append( KPosXmlLmNSAttName );
    rootAttributes->Des().Append( KPosXmlEq );
    rootAttributes->Des().Append( KPosXmlQuotationMark );
    rootAttributes->Des().Append( KPosXmlSchemaLocationAttValue );
    rootAttributes->Des().Append( KPosXmlVersionAttValue );
    rootAttributes->Des().Append( KPosXmlQuotationMark );

    rootAttributes->Des().Append( KPosXmlSpace );
    rootAttributes->Des().Append( KPosXmlXsiNSAttName );
    rootAttributes->Des().Append( KPosXmlEq );
    rootAttributes->Des().Append( KPosXmlQuotationMark );
    rootAttributes->Des().Append( KPosXmlXsiNSAttValue );
    rootAttributes->Des().Append( KPosXmlQuotationMark );

    rootAttributes->Des().Append( KPosXmlSpace );
    rootAttributes->Des().Append( KPosXmlSchemaLocationAttName );
    rootAttributes->Des().Append( KPosXmlEq );
    rootAttributes->Des().Append( KPosXmlQuotationMark );
    rootAttributes->Des().Append( KPosXmlSchemaLocationAttValue );
    rootAttributes->Des().Append( KPosXmlVersionAttValue );
    rootAttributes->Des().Append( KPosXmlSlash );
    rootAttributes->Des().Append( KPosXmlSpace );
    rootAttributes->Des().Append( KPosXmlSchemaAttValue );
    rootAttributes->Des().Append( KPosXmlQuotationMark );

    WriteSTagL( EPosXmlRoot, *rootAttributes );
    CleanupStack::PopAndDestroy( rootAttributes );

    // Start with collection right away
    WriteSTagL( EPosXmlLmCollection, KNullDesC );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmLmxEncoder::WriteFinalTagsL()
    {
    WriteETagL( EPosXmlLmCollection );
    WriteETagL( EPosXmlRoot );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmLmxEncoder::WriteCollectionDataL( 
    const HBufC* aCollectionName,
    const HBufC* aCollectionDescription )
    {
    if ( aCollectionName )
        {
        WriteStringWithTagsL( *aCollectionName, EPosXmlLmCollName );
        }

    if ( aCollectionDescription )
        {
        WriteStringWithTagsL( *aCollectionDescription, EPosXmlLmCollDescription );
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmLmxEncoder::WriteLandmarkL( 
    const CPosLandmark& aLandmark,
    const RPointerArray<const CPosLandmarkCategory>& aCategories )
    {
    TPtrC textField;

    WriteSTagL( EPosXmlLandmark, KNullDesC );
 
    // Write lm name
    if (aLandmark.GetLandmarkName(textField) == KErrNone)
        {
        WriteStringWithTagsL(textField, EPosXmlLmName);
        }

    // Write lm description
    if (aLandmark.GetLandmarkDescription(textField) == KErrNone)
        {
        WriteStringWithTagsL(textField, EPosXmlLmDescription);
        }

    // Write lm coordinates
    TLocality position;
    TInt status = aLandmark.GetPosition(position);
    if (status == KErrNone)
        {
        WriteLmCoordinatesL(position);
        }

    // Write lm coverage radius
    TReal32 coverageRadius;
    if (aLandmark.GetCoverageRadius(coverageRadius) == KErrNone)
        {
        WriteTRealWithTagsL(coverageRadius, EPosXmlLmCoverageRadius);
        }

    // Write address info and media link
    WriteLmPositionFieldsL(aLandmark);

    for ( TInt i = 0; i < aCategories.Count(); ++i )
        {
        WriteCategoryL( *(aCategories[i]) );
        }
    
    WriteETagL( EPosXmlLandmark );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmLmxEncoder::WriteLmCoordinatesL( const TLocality& aLocality )
    {
    WriteSTagL( EPosXmlLmCoordinates, KNullDesC );

    // Write latitude, mandatory tag
    WriteTRealWithTagsL(aLocality.Latitude(), EPosXmlCoordLatitude);

    // Write longitude, mandatory tag
    WriteTRealWithTagsL(aLocality.Longitude(), EPosXmlCoordLongitude);

    // Write altitude
    if (!Math::IsNaN(aLocality.Altitude()))
        {
        WriteTRealWithTagsL(aLocality.Altitude(), EPosXmlCoordAltitude);
        }

    // Write horizontalAccuracy
    if (!Math::IsNaN(aLocality.HorizontalAccuracy()))
        {
        WriteTRealWithTagsL(aLocality.HorizontalAccuracy(),
                            EPosXmlCoordHorizontalAcc);
        }

    // Write verticalAccuracy
    if (!Math::IsNaN(aLocality.VerticalAccuracy()))
        {
        WriteTRealWithTagsL(aLocality.VerticalAccuracy(),
                            EPosXmlCoordVerticalAcc);
        }

    WriteETagL(EPosXmlLmCoordinates);
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmLmxEncoder::WriteLmPositionFieldsL( const CPosLandmark& aLandmark )
    {
    RArray<TPosXmlTagType> addressTags;
    CleanupClosePushL(addressTags);

    CDesCArray* addressStrings =
        new (ELeave) CDesCArrayFlat(KPosFieldsGranularity);
    CleanupStack::PushL(addressStrings);

    CDesCArray* mediaLinkStrings =
        new (ELeave) CDesCArrayFlat(KPosFieldsGranularity);
    CleanupStack::PushL(mediaLinkStrings);

    // Sort out address info and media link from position fields.
    TPositionFieldId id = aLandmark.FirstPositionFieldId();
    while (id != EPositionFieldNone)
        {
        TPtrC textField;
        if (aLandmark.GetPositionField(id, textField) == KErrNone)
            {
            if ((id > EPositionFieldAddressCapabilitiesBegin &&
                id < EPositionFieldNMEACapabilitiesBegin)|| id == EPositionFieldProprietaryFieldsBegin)
                {
                TPosXmlTagType tag = XmlTagForPositionField( id );
                TBool validToExport = (tag != EPosXmlNothing);

                if (id == EPositionFieldCountryCode)
                    {
                    // Check that this is a valid token
                    validToExport = PosLmConverterUtils::IsTokenL(
                        textField, KPosCountryCodeLength);
                    }

                if (validToExport)
                    {
                    User::LeaveIfError(addressTags.Append(tag));
                    addressStrings->AppendL(textField);
                    }
                }
            else if (id > EPositionFieldMediaLinks &&
                id < EPositionFieldProprietaryFieldsBegin)
                {
                mediaLinkStrings->AppendL(textField);
                }
            }

        id = aLandmark.NextPositionFieldId(id);
        }

    // Write lm address info
    if (addressTags.Count() != 0)
        {
        WriteSTagL( EPosXmlLmAddressInfo, KNullDesC );

        for (TInt i = 0; i < addressTags.Count(); i++)
            {
            WriteStringWithTagsL((*addressStrings)[i], addressTags[i]);
            }

        WriteETagL(EPosXmlLmAddressInfo);
        }

    // Write media links
    for (TInt i = 0; i < mediaLinkStrings->Count(); i++)
        {
        TInt maxLength = (*mediaLinkStrings)[i].Length();
        HBufC* mime = HBufC::NewLC(maxLength);
        HBufC* url = HBufC::NewLC(maxLength);

        TInt status = PosLmConverterUtils::SeparateMediaLink(
            (*mediaLinkStrings)[i], mime, url);

        if (status == KErrNone)
            {
            if (PosLmConverterUtils::IsAnyUri(*url))
                {
                WriteSTagL( EPosXmlLmMediaLink, KNullDesC );

                // Write mime
                if (mime->Length() != 0)
                    {
                    WriteStringWithTagsL(*mime, EPosXmlMediaLinkMime);
                    }

                // Write url, mandatory tag
                WriteStringWithTagsL(*url, EPosXmlMediaLinkUrl);

                WriteETagL(EPosXmlLmMediaLink);
                }
            }

        CleanupStack::PopAndDestroy(2, mime); // url
        }

    CleanupStack::PopAndDestroy(3, &addressTags); // addressStrings
                                                  // mediaLinkStrings
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmLmxEncoder::WriteCategoryL( const CPosLandmarkCategory& aCategory )
    {
    WriteSTagL( EPosXmlLmCategory, KNullDesC );

    // Write global id
    TPosLmGlobalCategory id = aCategory.GlobalCategory();
    if ( id != KPosLmNullGlobalCategory )
        {
        const TInt KMaxDecimalStringLen = 10;
        TBuf<KMaxDecimalStringLen> idStr;
        idStr.AppendNum( id );
        WriteStringWithTagsL( idStr, EPosXmlCategoryId );
        }

    // Write category name
    WriteSTagL( EPosXmlCategoryName, KNullDesC ); // mandatory tag
    TPtrC categoryName;
    if (aCategory.GetCategoryName(categoryName) == KErrNone)
        {
        WriteEscapedStringL(categoryName);
        }
    WriteETagL( EPosXmlCategoryName ); // mandatory tag

    WriteETagL( EPosXmlLmCategory );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TPosXmlTagType CPosLmLmxEncoder::XmlTagForPositionField( TPositionFieldId aPosFieldId )
    {
    TPosXmlTagType xmlType = EPosXmlNothing;

    switch (aPosFieldId)
        {
        case EPositionFieldBuildingFloor:
            xmlType = EPosXmlAddrBuildingFloor;
            break;
        case EPositionFieldBuildingName:
            xmlType = EPosXmlAddrBuildingName;
            break;
        case EPositionFieldBuildingRoom:
            xmlType = EPosXmlAddrBuildingRoom;
            break;
        case EPositionFieldBuildingZone:
            xmlType = EPosXmlAddrBuildingZone;
            break;
        case EPositionFieldCity:
            xmlType = EPosXmlAddrCity;
            break;
        case EPositionFieldCountry:
            xmlType = EPosXmlAddrCountry;
            break;
        case EPositionFieldCountryCode:
            xmlType = EPosXmlAddrCountryCode;
            break;
        case EPositionFieldCounty:
            xmlType = EPosXmlAddrCounty;
            break;
        case EPositionFieldCrossing1:
            xmlType = EPosXmlAddrCrossing1;
            break;
        case EPositionFieldCrossing2:
            xmlType = EPosXmlAddrCrossing2;
            break;
        case EPositionFieldDistrict:
            xmlType = EPosXmlAddrDistrict;
            break;
        case EPositionFieldStreetExtension:
            xmlType = EPosXmlAddrExtension;
            break;
        case EPositionFieldBuildingTelephone:
            xmlType = EPosXmlAddrPhoneNumber;
            break;
        case EPositionFieldPostalCode:
            xmlType = EPosXmlAddrPostalCode;
            break;
        case EPositionFieldState:
            xmlType = EPosXmlAddrState;
            break;
        case EPositionFieldStreet:
            xmlType = EPosXmlAddrStreet;
            break;
        case EPositionFieldProprietaryFieldsBegin:
            xmlType = EPosXmlAddrPlaceId;
            break;
        default:
            break;
        }

    return xmlType;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TPtrC CPosLmLmxEncoder::TagNameL( TPosXmlTagType aTagType )
    {
    switch (aTagType)
        {
        case EPosXmlRoot:
            return KPosXmlLmxRoot();
        case EPosXmlLmCollection:
            return KPosXmlLmCollection();
        case EPosXmlLandmark:
            return KPosXmlLm();
        case EPosXmlLmCoordinates:
            return KPosXmlLmCoordinates();
        case EPosXmlLmAddressInfo:
            return KPosXmlLmAddressInfo();
        case EPosXmlLmMediaLink:
            return KPosXmlLmMediaLink();
        case EPosXmlLmCategory:
            return KPosXmlLmCategory();
        case EPosXmlLmCollName:
            return KPosXmlLmCollName();
        case EPosXmlLmCollDescription:
            return KPosXmlLmCollDescription();
        case EPosXmlLmName:
            return KPosXmlLmName();
        case EPosXmlLmDescription:
            return KPosXmlLmDescription();
        case EPosXmlLmCoverageRadius:
            return KPosXmlLmCoverageRadius();
        case EPosXmlCoordLatitude:
            return KPosXmlCoordLatitude();
        case EPosXmlCoordLongitude:
            return KPosXmlCoordLongitude();
        case EPosXmlCoordAltitude:
            return KPosXmlCoordAltitude();
        case EPosXmlCoordHorizontalAcc:
            return KPosXmlCoordHorizontalAcc();
        case EPosXmlCoordVerticalAcc:
            return KPosXmlCoordVerticalAcc();
        case EPosXmlAddrCountry:
            return KPosXmlAddrCountry();
        case EPosXmlAddrCountryCode:
            return KPosXmlAddrCountryCode();
        case EPosXmlAddrState:
            return KPosXmlAddrState();
        case EPosXmlAddrCounty:
            return KPosXmlAddrCounty();
        case EPosXmlAddrCity:
            return KPosXmlAddrCity();
        case EPosXmlAddrDistrict:
            return KPosXmlAddrDistrict();
        case EPosXmlAddrPostalCode:
            return KPosXmlAddrPostalCode();
        case EPosXmlAddrCrossing1:
            return KPosXmlAddrCrossing1();
        case EPosXmlAddrCrossing2:
            return KPosXmlAddrCrossing2();
        case EPosXmlAddrStreet:
            return KPosXmlAddrStreet();
        case EPosXmlAddrBuildingName:
            return KPosXmlAddrBuildingName();
        case EPosXmlAddrBuildingZone:
            return KPosXmlAddrBuildingZone();
        case EPosXmlAddrBuildingFloor:
            return KPosXmlAddrBuildingFloor();
        case EPosXmlAddrBuildingRoom:
            return KPosXmlAddrBuildingRoom();
        case EPosXmlAddrExtension:
            return KPosXmlAddrExtension();
        case EPosXmlAddrPhoneNumber:
            return KPosXmlAddrPhoneNumber();
        case EPosXmlMediaLinkMime:
            return KPosXmlMediaLinkMime();
        case EPosXmlMediaLinkUrl:
            return KPosXmlMediaLinkUrl();
        case EPosXmlCategoryId:
            return KPosXmlCategoryId();
        case EPosXmlCategoryName:
            return KPosXmlCategoryName();
        case EPosXmlAddrPlaceId:
            return KPosXmlAddrPlaceID();
        default:
            User::Leave(KErrNotSupported);
            return KNullDesC();
        }
    }