/*

* 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: Parser implementation for GPX format.

*

*

*/

#include <utf.h>

#include <xml/xmlparsererrors.h>

#include <lbs.h>

#include <EPos_PosLmImplExtension.h>

#include <EPos_LandmarksErrors.h>

#include "EPos_CPosLmXmlParser.h"

#include "EPos_CPosLmXmlParserOperation.h"

#include "EPos_CPosLmCollectionData.h"

#include "EPos_CPosLmParsedLmBuffer.h"

#include "EPos_PosLmConverterUtils.h"

#include "EPos_LmConverter.h"

#include "EPos_CPosLmGpxParser.h"

const TReal KPosLmParserMinLatitude = -90.0;

const TReal KPosLmParserMaxLatitude = 90.0;

const TReal KPosLmParserMinLongitude = -180.0;

const TReal KPosLmParserMaxLongitude = 180.0;

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

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

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

//

CPosLmGpxParser::CPosLmGpxParser()

    {

    }

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

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

//

CPosLmGpxParser* CPosLmGpxParser::NewL()

    {

    CPosLmGpxParser* self = new (ELeave) CPosLmGpxParser;

    return self;

    }

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

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

//

CPosLmGpxParser::~CPosLmGpxParser()

    {

    }

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

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

//

void CPosLmGpxParser::OnStartDocumentL(

    const Xml::RDocumentParameters& aDocParam, 

    TInt aErrorCode)

    {

    CPosLmXmlParser::OnStartDocumentL( aDocParam, aErrorCode );

    iGpxVersion = EGpxVersionUnknown;

    }

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

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

//

void CPosLmGpxParser::GetNextAllowedTagsL( RArray<TPosXmlTagType>& aChildTags )

    {

    switch ( CurrentTree() )

        {

        case EPosXmlNothing:

            {

            aChildTags.AppendL( EPosXmlRoot );

            break;

            }

        case EPosXmlRoot:

            {

            // v1.0

            const TPosXmlTagType rootChildren10[] = { 

                EPosXmlLmCollName, EPosXmlLmCollDescription, 

                EPosXmlLandmark, EPosXmlLandmark // landmark can be repeated

                };

            const TInt rootChildren10Size = sizeof( rootChildren10 ) / sizeof( TPosXmlTagType );

            // v1.1

            const TPosXmlTagType rootChildren11[] = { 

                EPosXmlMetadata,

                EPosXmlLandmark, EPosXmlLandmark // landmark can be repeated

                };

            const TInt rootChildren11Size = sizeof( rootChildren11 ) / sizeof( TPosXmlTagType );

            if ( iGpxVersion < EGpxVersion11 )

                {

                GenValidSequenceL( rootChildren10, rootChildren10Size, aChildTags );

                }

            else

                {

                GenValidSequenceL( rootChildren11, rootChildren11Size, aChildTags );

                }

            break;

            }

        case EPosXmlLandmark:

            {

            // v1.0

            const TPosXmlTagType landmarkChildren10[] = { 

                EPosXmlCoordAltitude, 

                EPosXmlLmName, EPosXmlLmDescription2, EPosXmlLmDescription,

                EPosXmlMediaLinkUrl, EPosXmlMediaLinkName, EPosXmlCategoryName, 

                EPosXmlCoordHorizontalAcc, EPosXmlCoordVerticalAcc 

                };

            const TInt landmarkChildren10Size = sizeof( landmarkChildren10 ) / sizeof( TPosXmlTagType );

            // v1.1

            const TPosXmlTagType landmarkChildren11[] = { 

                EPosXmlCoordAltitude, 

                EPosXmlLmName, EPosXmlLmDescription2, EPosXmlLmDescription,

                EPosXmlLmMediaLink, EPosXmlLmMediaLink, // link can repeat

                EPosXmlCategoryName, EPosXmlCoordHorizontalAcc, EPosXmlCoordVerticalAcc 

                };

            const TInt landmarkChildren11Size = sizeof( landmarkChildren11 ) / sizeof( TPosXmlTagType );

            if ( iGpxVersion < EGpxVersion11 )

                {

                GenValidSequenceL( landmarkChildren10, landmarkChildren10Size, aChildTags );

                }

            else

                {

                GenValidSequenceL( landmarkChildren11, landmarkChildren11Size, aChildTags );

                }

            break;

            }

        case EPosXmlMetadata: // v1.1

            {

            const TPosXmlTagType metaChildren[] = { 

                EPosXmlLmCollName, EPosXmlLmCollDescription

                };

            const TInt metaChildrenSize = sizeof( metaChildren ) / sizeof( TPosXmlTagType );

            GenValidSequenceL( metaChildren, metaChildrenSize, aChildTags );

            break;

            }

        case EPosXmlLmMediaLink: // v1.1

            {

            const TPosXmlTagType linkChildren[] = { 

                EPosXmlMediaLinkName, EPosXmlMediaLinkMime

                };

            const TInt linkChildrenSize = sizeof( linkChildren ) / sizeof( TPosXmlTagType );

            GenValidSequenceL( linkChildren, linkChildrenSize, aChildTags );

            break;

            }

        default:

            break;

        }

    }

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

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

//

void CPosLmGpxParser::CheckMandatoryTagsL( TPosXmlTagType /*aTreeType */ )

    {

    // GPX has only mandatory attributes, which is checked in OnAttributesL

    }

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

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

//

void CPosLmGpxParser::SetContentL( TPosXmlTagType aTag, const TDesC& aContent )

    {

    switch (aTag)

        {

        // landmarkCollection Tags

        case EPosXmlLmCollName:

            AddCollectionDataL( EPosLmCollDataCollectionName, aContent );

            break;

        case EPosXmlLmCollDescription:

            AddCollectionDataL( EPosLmCollDataCollectionDescription, aContent );

            break;

        // landmark Tags

        case EPosXmlLandmark:

            {

            if ( !Math::IsNaN( iParsedLatitude ) && !Math::IsNaN( iParsedLongitude ) )

                {

                TLocality loc(

                    TCoordinate(

                        iParsedLatitude, 

                        iParsedLongitude,

                        iParsedAltitude), 

                    iParsedHorAcc, 

                    iParsedVertAcc);

                iWorkingLandmark->SetPositionL(loc);

                }

            TBuf<5> num;

            num.Num(iNoOfMediaLinks);

            iWorkingLandmark->SetPositionFieldL(EPositionFieldMediaLinks, num);

            // v1.0 media links

            if ( iReadUrl && iGpxVersion == EGpxVersion10 )

                {

                SetContentL( EPosXmlLmMediaLink, KNullDesC );

                }

            HandleLandmarkParsedL();

            break;

            }

        case EPosXmlLmName:

            iWorkingLandmark->SetLandmarkNameL( aContent.Left( KPosLmMaxTextFieldLength ) );

            break;

        case EPosXmlLmDescription:

            iWorkingLandmark->SetLandmarkDescriptionL( aContent.Left( KPosLmMaxDescriptionLength ) );

            break;

        case EPosXmlLmDescription2:

            iWorkingLandmark->SetPositionFieldL( EPositionFieldComment, aContent.Left( KPosLmMaxTextFieldLength ) );

            break;

        case EPosXmlCoordAltitude:

            PosLmConverterUtils::DesToRealL(aContent, iParsedAltitude);

            break;

        case EPosXmlCoordHorizontalAcc:

            PosLmConverterUtils::DesToRealL(aContent, iParsedHorAcc);

            // Ensure horizontal acc is >= 0

            PosLmConverterUtils::AssertL(

                iParsedHorAcc >= 0 || Math::IsNaN( iParsedHorAcc ) );

            iParsedHorAcc *= KPosLmDopToAccuracyFactor;

            break;

        case EPosXmlCoordVerticalAcc:

            PosLmConverterUtils::DesToRealL( aContent, iParsedVertAcc );

            // Ensure vertical acc is >= 0

            PosLmConverterUtils::AssertL(

                iParsedVertAcc >= 0 || Math::IsNaN( iParsedVertAcc ) );

            iParsedVertAcc *= KPosLmDopToAccuracyFactor;

            break;

        // mediaLink Tag

        case EPosXmlMediaLinkUrl:

            PosLmConverterUtils::AssertL( PosLmConverterUtils::IsAnyUri( aContent ) );

            iReadUrl = aContent.AllocL();

            break;

        case EPosXmlMediaLinkMime:

            iReadMimeType = aContent.AllocL();

            break;

        case EPosXmlLmMediaLink:

            {

            HBufC* mediaLink = PosLmConverterUtils::ConcatenateMediaLinkLC(

                *iReadMimeType, *iReadUrl );

            iWorkingLandmark->SetPositionFieldL(static_cast<TPositionFieldId>

                (EPositionFieldMediaLinksStart + iNoOfMediaLinks),

                mediaLink->Left(KPosLmMaxTextFieldLength));

            iNoOfMediaLinks++;

            CleanupStack::PopAndDestroy(mediaLink);

            delete iReadMimeType;

            iReadMimeType = NULL;

            delete iReadUrl;

            iReadUrl = NULL;

            break;

            }

        // category Tags

        case EPosXmlCategoryName:

            PosLmImplExtension::SetCategoryIdL( *iWorkingCategory, iWorkingItemId );

            PosLmConverterUtils::AssertL( aContent.Length() > 0 );

            iWorkingCategory->SetCategoryNameL( aContent.Left( KPosLmMaxCategoryNameLength ) );

            iWorkingLandmark->AddCategoryL( iWorkingItemId++ );

            User::LeaveIfError( iCategories.Append( iWorkingCategory ) );

            iWorkingCategory = NULL;

            break;

        // Attributes    

        case EPosXmlCoordLatitude: // WayPoint attribute

            PosLmConverterUtils::DesToRealL(aContent, iParsedLatitude);

            // Ensure latitude is in valid range

            PosLmConverterUtils::AssertL(

                (iParsedLatitude <= KPosLmParserMaxLatitude &&

                iParsedLatitude >= KPosLmParserMinLatitude) ||

                Math::IsNaN(iParsedLatitude));

            break;

        case EPosXmlCoordLongitude: // WayPoint attribute

            PosLmConverterUtils::DesToRealL(aContent, iParsedLongitude);

            // Ensure latitude is in valid range

            PosLmConverterUtils::AssertL(

                (iParsedLongitude <= KPosLmParserMaxLongitude &&

                iParsedLongitude >= KPosLmParserMinLongitude) ||

                Math::IsNaN(iParsedLongitude));

            break;

        case EPosXmlVersion: 

            if ( aContent.Compare( KPosXmlVersionNum10 ) == 0 )

                {

                iGpxVersion = EGpxVersion10;

                }

            else // anything else is used as 1.1

                {

                iGpxVersion = EGpxVersion11;

                }

            break;

        default:

            break;

        }

    }

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

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

//

TBool CPosLmGpxParser::IsLandmarkStarted( TPosXmlTagType aTag )

    {

    return ( aTag == EPosXmlLandmark );

    }

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

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

//

TBool CPosLmGpxParser::IsCategoryStarted( TPosXmlTagType aTag )

    {

    return ( aTag == EPosXmlCategoryName );

    }

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

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

//

TBool CPosLmGpxParser::IsTreeTag( TPosXmlTagType aTag )

    {

    __ASSERT_DEBUG( aTag != EPosXmlNothing, Panic( KPosLmConverterPanic, KErrGeneral ) );

    __ASSERT_DEBUG( aTag != EPosXmlUnknown, Panic( KPosLmConverterPanic, KErrGeneral ) );

    return ( aTag >= EPosXmlLmLastTree ) ? ETrue : EFalse;

    }

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

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

//

TPosXmlTagType CPosLmGpxParser::AttributeTypeL( TPosXmlTagType aParent, const Xml::RTagInfo& aElement )

    {

    TPosXmlTagType tagType = EPosXmlUnknown;

    TPtrC8 tagName = aElement.LocalName().DesC();

    switch ( aParent )

        {

        case EPosXmlRoot:

            {

            if ( EqualsTagL( tagName, KPosXmlVersion ) )

                {

                tagType = EPosXmlVersion;

                }

            break;

            }

        case EPosXmlLandmark:

            {

            if ( EqualsTagL( tagName, KPosXmlGpxLmLatitude ) )

                {

                tagType = EPosXmlCoordLatitude;

                }

            else if ( EqualsTagL( tagName, KPosXmlGpxLmLongitude ) )

                {

                tagType = EPosXmlCoordLongitude;

                }

            break;

            }

        case EPosXmlLmMediaLink: // v1.1

            {

            if ( iGpxVersion >= EGpxVersion11 )

                {

                if ( EqualsTagL( tagName, KPosXmlGpxLinkHref ) )

                    {

                    tagType = EPosXmlMediaLinkUrl;

                    }

                }

            break;

            }

        default:

            break;

        }

    return tagType;

    }

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

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

//

TPosXmlTagType CPosLmGpxParser::TagTypeL( const Xml::RTagInfo& aElement )

    {

    TPosXmlTagType tagType = EPosXmlUnknown;

    TPosXmlTagType treeType = CurrentTree();

    TPtrC8 tagName = aElement.LocalName().DesC();

    if ( treeType == EPosXmlNothing )

        {

        if ( EqualsTagL( tagName, KPosXmlGpxRoot ) )

            {

            tagType = EPosXmlRoot;

            }

        }

    else if ( MatchesRootNamespace( aElement ) )

        {

        switch ( treeType )

            {

            case EPosXmlRoot:

                {

                if ( EqualsTagL( tagName, KPosXmlGpxMetadata ) )

                    {

                    tagType = EPosXmlMetadata;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxWaypoint ) )

                    {

                    tagType = EPosXmlLandmark;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxCollName ) && 

                          iGpxVersion == EGpxVersion10 ) // v1.0

                    {

                    tagType = EPosXmlLmCollName;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxCollDesc ) && 

                          iGpxVersion == EGpxVersion10 ) // v1.0

                    {

                    tagType = EPosXmlLmCollDescription;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxRoot ) )

                    {

                    User::Leave( EXmlRecursiveEntity );

                    }

                }

                break;

            case EPosXmlMetadata:

                {

                if ( EqualsTagL( tagName, KPosXmlGpxCollName ) && 

                     iGpxVersion >= EGpxVersion11 ) // v1.1

                    {

                    tagType = EPosXmlLmCollName;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxCollDesc ) && 

                          iGpxVersion == EGpxVersion11 ) // v1.1

                    {

                    tagType = EPosXmlLmCollDescription;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxMetadata ) )

                    {

                    User::Leave( EXmlRecursiveEntity );

                    }

                }

                break;

            case EPosXmlLandmark:

                {

                if ( EqualsTagL( tagName, KPosXmlGpxLmName ) ) 

                    {

                    tagType = EPosXmlLmName;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxLmDescription ) )

                    {

                    tagType = EPosXmlLmDescription;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxLmComment ) ) 

                    {

                    tagType = EPosXmlLmDescription2;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxLmAltitude ) ) 

                    {

                    tagType = EPosXmlCoordAltitude;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxHdop ) ) 

                    {

                    tagType = EPosXmlCoordHorizontalAcc;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxVdop ) ) 

                    {

                    tagType = EPosXmlCoordVerticalAcc;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxCategory ) ) 

                    {

                    tagType = EPosXmlCategoryName;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxLink ) ) 

                    {

                    tagType = EPosXmlLmMediaLink;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxUrl ) && 

                          iGpxVersion == EGpxVersion10 )  // v1.0

                    {

                    tagType = EPosXmlMediaLinkUrl;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxUrlName ) && 

                          iGpxVersion == EGpxVersion10 ) // v1.0

                    {

                    tagType = EPosXmlMediaLinkName;

                    }

                else if ( EqualsTagL( tagName, KPosXmlGpxWaypoint ) )

                    {

                    User::Leave( EXmlRecursiveEntity );

                    }

                }

                break;

            case EPosXmlLmMediaLink: // v1.1

                {

                if ( iGpxVersion >= EGpxVersion11 )

                    {

                    if ( EqualsTagL( tagName, KPosXmlGpxLinkType ) )

                        {

                        tagType = EPosXmlMediaLinkMime;

                        }

                    else if ( EqualsTagL( tagName, KPosXmlGpxLinkText ) )

                        {

                        tagType = EPosXmlMediaLinkName;