/*

* 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: Parser that uses Symbian XML Framework to parse XML files with

*  Landmark Content 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"

const TInt KPosLmParserBytesAtATime = 100;

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

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

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

//

CPosLmXmlParser::CPosLmXmlParser()

    {

    }

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

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

//

CPosLmXmlParser::~CPosLmXmlParser()

    {

    // Notify operation that parser is deleted

    DisconnectOperation();

    ResetParser();

    iCollectionData.Close();

    iCategories.Close();

    iParsedLmBuffer.Close();

    }

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

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

//

TInt CPosLmXmlParser::ParseNextPartL( TReal32& aProgress )

    {

    __ASSERT_ALWAYS(( iParserStatus & EStateInitialized ) &&( iParserStatus & EStateOperationConstructed ), Panic(

            KPosLandmarksClientPanic, EPosLmProtocolBreak ) );

    TInt status = KPosLmOperationNotComplete;

    // Check if there are a parsed landmark before in lm parsed buffer

    TBool lmBeforeParsing = EFalse;

    if ( iParsedLmBuffer.Count()> 0 )

        {

        lmBeforeParsing = ETrue;

        }

    // We need to parse file/buffer since we don't have any landmark

    // in parsed buffer and

    // also to check that there are some more landmarks coming

    if ( iParsedLmBuffer.Count()<= 1 )

        {

        TInt nrOfLmBeforeParsing = iParsedLmBuffer.Count();

        TInt bytesBeforeParsing = iNumberOfBytesRead;

        iParserStatus |= EStateParsingStarted;

        iParserStatus &= ~EStateParsedLandmark;

        iParserStatus &= ~EStateParsingForNextLm;

        iParserStatus &= ~EStateParsingPartReady;

        iParserError = KErrNone;

        ReadNextPartL();

        iParserStatus |= EStateParsing;

        // Check if we have read a landmark

        while(!ParsedPart() && BufferLength()> 0 )

            {

            iXmlParser->ParseL(*iBuffer );

            User::LeaveIfError( iParserError );

            // Check if we are ready parsing

            /*if (( iParserStatus & EStateParsedLandmark ) &&( iParserStatus & EStateParsingForNextLm ) )

                {

                iParserStatus |= EStateParsingPartReady;

                }

            else

                if ( iParserStatus & EStateParsedLandmark )

                    {

                    iParserStatus |= EStateParsingForNextLm;

                    }*/

            if (!ParsedPart() )

                {

                ReadNextPartL();

                }

            }

        // Evaluate read bytes per read lm, used for progress

        if ( nrOfLmBeforeParsing < iParsedLmBuffer.Count() )

            {

            iIncrBytesPerLm = TReal32( iNumberOfBytesRead -TReal32( bytesBeforeParsing ) )/( iParsedLmBuffer.Count() - nrOfLmBeforeParsing );

            }

        // Finished parsing

        iParserStatus &= ~EStateParsing;

        }

    // Remove latest landmark if there where any parsed

    if ( lmBeforeParsing && iParserStatus)// & EStateParsedLandmark)

        {

        	delete iParsedLmBuffer[0];

        	iParsedLmBuffer.Remove( 0 );

        }

	if ( iParsedLmBuffer.Count()> 0 && iParsedLmBuffer[0]->Landmark())

        {

        	iNumOfParsedLandmarks++;

        }

    	else

        {

        	User::Leave( KErrPosLmUnknownFormat );

        }	

    // Set progress / Linear progress

    aProgress = TReal32( iNumberOfBytesRead -iIncrBytesPerLm *( iParsedLmBuffer.Count() - 1 ) )/TReal32( iContentSize );

    // Check status if parsing is completed

    if ( IsParsingComplete() )

        {

        User::LeaveIfError( CompleteParsing());

        status = KErrNone;

        }

    return status;

    }

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

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

//

void CPosLmXmlParser::ResetParserOnError()

    {

    CompleteParsing();

    iParserStatus &= ~EStateParsingStarted;

    iParserStatus &= ~EStateParsing;

    iParserStatus &= ~EStateParsingReady;

    iReadTags.Reset();

    iTrees.Reset();

    iLastElementState = EXmlParserOnEndElement;

    iNumberOfBytesRead = 0;

    iIncrBytesPerLm = 0;

    iParserError = KErrNone;

    ResetParserPartState();

    }

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

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

//

void CPosLmXmlParser::SetInputBuffer( const TDesC8& aBuffer )

    {

    __ASSERT_ALWAYS(!( iParserStatus & EStateParsing ), Panic( KPosLandmarksClientPanic,

            EPosLmProtocolBreak ) );

    ResetParser();

    iInputBuffer.Set( aBuffer );

    // Set size

    iContentSize = iInputBuffer.Length();

    iParserStatus |= EStateInitialized;

    }

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

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

//

void CPosLmXmlParser::SetInputFileL( const TDesC& aFile )

{

	SetInputFileInternalL( NULL, aFile );

}

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

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

//

void CPosLmXmlParser::SetInputFileHandleL( RFile& aFileHandle )

{

	SetInputFileInternalL(&aFileHandle );

}

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

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

//

CPosLmOperation* CPosLmXmlParser::ParseContentL( TBool aBuildIndex )

    {

    __ASSERT_ALWAYS( iParserStatus & EStateInitialized, Panic(

            KPosLandmarksClientPanic, EPosLmProtocolBreak ) );

    // Check if we support buildindex

    if ( aBuildIndex )

        {

        User::Leave( KErrNotSupported );

        }

     // Reset parsers content

    ResetContentL();

    DisconnectOperation();

    iParserOp = CPosLmXmlParserOperation::NewL(*this );

    return iParserOp; // ownership is transferred to client

    }

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

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

//

TUint32 CPosLmXmlParser::NumOfParsedLandmarks() const

    {

    return iNumOfParsedLandmarks;

    }

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

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

//

TPosLmCollectionDataId CPosLmXmlParser::FirstCollectionDataId() const

    {

    if ( iCollectionData.Count()== 0 )

        {

        return EPosLmCollDataNone;

        }

    return iCollectionData[0]->CollectionDataId();

    }

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

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

//

TPosLmCollectionDataId CPosLmXmlParser::NextCollectionDataId(

        TPosLmCollectionDataId aCollectionDataId ) const

    {

    for( TInt i = 0; i < iCollectionData.Count(); i++ )

        {

        if ( iCollectionData[i]->CollectionDataId()== aCollectionDataId &&i+1 < iCollectionData.Count() )

            {

            return iCollectionData[i+1]->CollectionDataId();

            }

        }

    return EPosLmCollDataNone;

    }

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

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

//

TPtrC CPosLmXmlParser::CollectionData( TPosLmCollectionDataId aDataId ) const

    {

    TPtrC collectionData;

    TBool found = EFalse;

    for( TInt i = 0; !found && i < iCollectionData.Count(); i++ )

        {

        if ( iCollectionData[i]->CollectionDataId()== aDataId )

            {

            iCollectionData[i]->GetCollectionData( collectionData );

            found = ETrue;

            }

        }

    return collectionData;

    }

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

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

//

CPosLandmark* CPosLmXmlParser::LandmarkLC( TUint aLandmarkIndex ) const

    {

    __ASSERT_ALWAYS(

            aLandmarkIndex < iNumOfParsedLandmarks ||aLandmarkIndex == KPosLastParsedLandmark,

            Panic( KPosLandmarksClientPanic, EPosInvalidIndex ) );

    // Need to check things here

    if ( aLandmarkIndex != KPosLastParsedLandmark ||iParsedLmBuffer.Count()== 0 )

        {

        //User::Leave( KErrPosLmUnknownFormat);//KErrNotFound );

        User::Leave( KErrNotFound );

        }

	//if(!isAlreadyCreated)

    	return CPosLandmark::NewLC(*iParsedLmBuffer[0]->Landmark() );

    //else

    	//return NULL;		

    }

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

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

//

CPosLandmarkCategory* CPosLmXmlParser::LandmarkCategoryLC(

        TPosLmItemId aCategoryId ) const

    {

    TInt found = KErrNotFound;

    if ( iParsedLmBuffer.Count()== 0 )

        {

        User::Leave( found );

        }

    for( TInt i=0; found == KErrNotFound &&i<iParsedLmBuffer[0]->Categories().Count(); i++ )

        {

        TPosLmItemId itemid = iParsedLmBuffer[0]->Categories()[i]->CategoryId();

        if ( itemid != KPosLmNullItemId && itemid == aCategoryId )

            {

            found = i;

            }

        }

    User::LeaveIfError( found );

    return CPosLandmarkCategory::NewLC(*iParsedLmBuffer[0]->Categories()[found] );

    }

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

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

//

void CPosLmXmlParser::OnStartDocumentL(

        const Xml::RDocumentParameters& /*aDocParam*/, TInt /*aErrorCode*/)

    {

    }

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

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

//

void CPosLmXmlParser::OnEndDocumentL( TInt /*aErrorCode*/)

    {

    iParserStatus |= EStateParsingReady;

    }

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

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

//

void CPosLmXmlParser::OnStartElementL( 

    const Xml::RTagInfo& aElement,

    const Xml::RAttributeArray& aAttributes, 

    TInt /*aErrorCode*/)

    {

    delete iReadContent;

    iReadContent = NULL;

    if ( iLastElementState == EXmlParserOnStartElement )

        {

        // new element started, but last one has not been yet closed 

        // => last element is a tree tag

        StartNewTreeL();

        }

    else

        {

        iLastElementState = EXmlParserOnStartElement;

        }

    TPosXmlTagType startTag = TagTypeL( aElement );

    // Save namespace of root tag

    if ( startTag == EPosXmlRoot && !iRootNs )

    	{

    	iRootNs = aElement.Uri().DesC().AllocL();

    	}

    if ( startTag != EPosXmlUnknown )

        {

        CheckSequenceOrderL( startTag );

        OnAttributesL( startTag, aAttributes );

        }

    iReadTags.AppendL( startTag );

    SetParserStateL( startTag );

    }

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

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

//

void CPosLmXmlParser::CheckSequenceOrderL( TPosXmlTagType aTag )

    {

    RArray<TPosXmlTagType> allowedChildTags;

    CleanupClosePushL( allowedChildTags );

    GetNextAllowedTagsL( allowedChildTags );

    PosLmConverterUtils::AssertL( allowedChildTags.Find( aTag ) >= 0 );

    CleanupStack::PopAndDestroy( &allowedChildTags );

    }

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

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

//

void CPosLmXmlParser::OnEndElementL( const Xml::RTagInfo& aElement, TInt /*aErrorCode*/)

    {

    if ( iLastElementState == EXmlParserOnEndElement )

        {

        // some tree is closed

        CheckMandatoryTagsL( CurrentTree() );

        CloseCurrentTree();

        }

    else

        {

        // here checking is done for the case when

        // closing tag looks like a leaf,

        // but is expected to be a tree and is missing all child tags

        // cases like <latitide>/<longitude> fields not included in <landmark> in LMX

        CheckMandatoryTagsL( CurrentTag() );

        iLastElementState = EXmlParserOnEndElement;

        }

    TPosXmlTagType tagType = TagTypeL( aElement );

    SaveContentL( tagType );

    if ( tagType == EPosXmlRoot ) 

        {

        HandleRootTag();

        }

    }

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

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

//

void CPosLmXmlParser::SaveContentL( TPosXmlTagType aTag )

    {

    // Read property/content for end element

    if ( iReadContent )

        {

        // Convert property/content

        HBufC* content = PosLmConverterUtils::Utf8ToUnicodeLC( *iReadContent );

        // Set content on Landmark related objects and parser status

        SetContentL( aTag, *content );

        // Reset/delete read/converted content

        CleanupStack::PopAndDestroy( content );

        delete iReadContent;

        iReadContent = NULL;

        }

    else

        {

        SetContentL( aTag, KNullDesC );

        }

    }

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

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

//

void CPosLmXmlParser::OnContentL( const TDesC8& aBytes, TInt /*aErrorCode*/)

    {

    TPosXmlTagType currentTag = EPosXmlNothing;

    if ( iLastElementState == EXmlParserOnStartElement )

        {

        currentTag = CurrentTag();

        }

    else

        {

        currentTag = CurrentTree();

        }

    if ( currentTag != EPosXmlUnknown && 

         currentTag != EPosXmlNothing )

        {

        // Only leaf tags should contain data

        if ( !PosLmConverterUtils::OnlyWhiteSpaces( aBytes ) )

            {

            PosLmConverterUtils::AssertL( !IsTreeTag( currentTag ) );

            }

        // If there is a content from a previous parsing

        // then we need to concatenate data/strings.

        if ( iReadContent )

            {

            HBufC8* prevContent = iReadContent;

            CleanupStack::PushL( prevContent );

            iReadContent = NULL;

            iReadContent = HBufC8::NewL( prevContent->Length()+ aBytes.Length() );

            iReadContent->Des().Append( *prevContent );

            iReadContent->Des().Append( aBytes );

            CleanupStack::PopAndDestroy( prevContent );

            }

        else

            {

            iReadContent = aBytes.AllocL();

            }

        }

    }

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

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

//

void CPosLmXmlParser::OnStartPrefixMappingL( const RString& /*aPrefix*/,

        const RString& /*aUri*/, TInt /*aErrorCode*/)

    {

    }

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