/*
* 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: Class used for encoding xml landmark content.
*
*
*/


#include    <lbsposition.h>
#include    <EPos_LandmarksErrors.h>
#include    "EPos_CPosLmXmlEncoder.h"
#include    "EPos_CPosLmFileOutput.h"
#include    "EPos_CPosLmBufferOutput.h"
#include    "EPos_CPosLmXmlEncoderOperation.h"
#include    "EPos_PosLmConverterUtils.h"

const TInt KPosBufferExpandSize = 600;

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

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmXmlEncoder::CPosLmXmlEncoder()
    {
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmXmlEncoder::~CPosLmXmlEncoder()
    {
    delete iOutput;
    delete iCollectionDataName;
    delete iCollectionDataDescription;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CBufBase* CPosLmXmlEncoder::SetUseOutputBufferL()
    {
    ResetEncoderL();

    CBufBase* buffer = CreateOutPutBufferLC();

    InitializeEncodingL();

    CleanupStack::Pop(buffer);
    return buffer;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmXmlEncoder::SetOutputFileL(
    const TDesC& aOutputFile)
    {
    ResetEncoderL();

    CreateOutputFileL(aOutputFile);

    InitializeEncodingL();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmXmlEncoder::AddCollectionDataL(
    TPosLmCollectionDataId aDataId,
    const TDesC& aCollectionData)
    {
    __ASSERT_ALWAYS((iEncoderStatus != EPosUninitialized) &&
        (iEncoderStatus != EPosLmInfoAdded),
        Panic(KPosLandmarksClientPanic, EPosLmProtocolBreak));

    __ASSERT_ALWAYS(aDataId != EPosLmCollDataNone,
        Panic(KPosLandmarksClientPanic, EPosLmInvalidArgument));

    if (aDataId == EPosLmCollDataCollectionName)
        {
        if (iCollectionDataName)
            {
            User::Leave(KErrAlreadyExists);
            }
        iCollectionDataName = aCollectionData.AllocL();
        }
    else if (aDataId == EPosLmCollDataCollectionDescription)
        {
        if (iCollectionDataDescription)
            {
            User::Leave(KErrAlreadyExists);
            }
        iCollectionDataDescription = aCollectionData.AllocL();
        }
    else
        {
        // Silently ignore unknown collection data.
        return;
        }

    iEncoderStatus = EPosCollectionInfoAdded;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmXmlEncoder::AddLandmarkL( const CPosLandmark& aLandmark )
    {
    __ASSERT_ALWAYS(
        iEncoderStatus != EPosUninitialized,
        Panic( KPosLandmarksClientPanic, EPosLmProtocolBreak ) );
    
    if ( iEncoderStatus == EPosCollectionInfoAdded )
        {
        WriteCollectionDataL( iCollectionDataName, iCollectionDataDescription );
        }

    WriteLastLandmarkL();
    
    iLastLandmark = CPosLandmark::NewL( aLandmark );
    iEncoderStatus = EPosLmInfoAdded;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmXmlEncoder::AddCategoryForLatestLandmarkL( const CPosLandmarkCategory& aCategory )
    {
    __ASSERT_ALWAYS(
        iEncoderStatus == EPosLmInfoAdded,
        Panic(KPosLandmarksClientPanic, EPosLmProtocolBreak));

    iCategories.Append( CPosLandmarkCategory::NewL( aCategory ) );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmXmlEncoder::InitializeEncodingL()
    {
    WritePrologL();
    WriteStartTagsL();
    iEncoderStatus = EPosInitialized;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmOperation* CPosLmXmlEncoder::FinalizeEncodingL()
    {
    __ASSERT_ALWAYS(
        iEncoderStatus == EPosLmInfoAdded,
        Panic(KPosLandmarksClientPanic, EPosLmProtocolBreak));

    WriteLastLandmarkL();
    WriteFinalTagsL();
    
    CPosLmXmlEncoderOperation* op = CPosLmXmlEncoderOperation::NewL( iOutput );
    // Ownership of iOutput has been transferred to op.
    iOutput = NULL;
    iEncoderStatus = EPosUninitialized;
    return op;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CBufBase* CPosLmXmlEncoder::CreateOutPutBufferLC()
    {
    CPosLmBufferOutput* output = CPosLmBufferOutput::NewL(KPosBufferExpandSize);
    iOutput = output;
    return output->BufferLC();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmXmlEncoder::CreateOutputFileL( const TDesC& aOutputFile )
    {
    iOutput = CPosLmFileOutput::NewL(aOutputFile);
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmXmlEncoder::ResetEncoderL()
    {
    delete iOutput;
    iOutput = NULL;

    delete iCollectionDataName;
    iCollectionDataName = NULL;
    delete iCollectionDataDescription;
    iCollectionDataDescription = NULL;
    
    delete iLastLandmark;
    iLastLandmark = NULL;
    iCategories.ResetAndDestroy();

    ResetIndentation();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmXmlEncoder::WritePrologL()
    {
    iOutput->WriteAndDeleteL( PrologStringLC() );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmXmlEncoder::WriteSTagL( TPosXmlTagType aTagType, const TDesC& aAttributes )
    {
    iOutput->WriteAndDeleteL( STagStringLC( aTagType, aAttributes ) );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmXmlEncoder::WriteETagL( TPosXmlTagType aTagType )
    {
    iOutput->WriteAndDeleteL( ETagStringLC( aTagType ) );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmXmlEncoder::WriteStringWithTagsL( const TDesC16& aDes, TPosXmlTagType aTagType )
    {
    WriteSTagL( aTagType, KNullDesC );
    WriteEscapedStringL( aDes );
    WriteETagL( aTagType );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmXmlEncoder::WriteTRealWithTagsL( TReal aValue, TPosXmlTagType aTagType )
    {
    WriteSTagL( aTagType, KNullDesC );
    iOutput->WriteTRealL( aValue );
    WriteETagL( aTagType );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmXmlEncoder::WriteEscapedStringL( const TDesC& aDes )
    {
    HBufC* des = PosLmConverterUtils::EscapeStringToXmlLC(aDes);
    iOutput->WriteL(*des);
    CleanupStack::PopAndDestroy(des);
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
HBufC16* CPosLmXmlEncoder::PrologStringLC()
    {
    HBufC16* string = HBufC16::NewLC( KPosLongStringLength );

    string->Des().Append(KPosXmlDeclStart);
    string->Des().Append(KPosXmlSpace);

    string->Des().Append(KPosXmlVersion);
    string->Des().Append(KPosXmlEq);
    string->Des().Append(KPosXmlQuotationMark);
    string->Des().Append(KPosXmlVersionNum10);
    string->Des().Append(KPosXmlQuotationMark);

    string->Des().Append(KPosXmlSpace);

    string->Des().Append(KPosXmlEncoding);
    string->Des().Append(KPosXmlEq);
    string->Des().Append(KPosXmlQuotationMark);
    string->Des().Append(KPosXmlEncNameUTF8);
    string->Des().Append(KPosXmlQuotationMark);

    string->Des().Append(KPosXmlDeclEnd);
    string->Des().Append(KPosXmlNewLine);

    return string;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmXmlEncoder::WriteLastLandmarkL()
    {
    if ( iLastLandmark )
        {
        WriteLandmarkL( *iLastLandmark, iCategories );
        
        delete iLastLandmark;
        iLastLandmark = NULL;
        iCategories.ResetAndDestroy();
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
HBufC16* CPosLmXmlEncoder::STagStringLC( TPosXmlTagType aTagType, const TDesC& aAttributes )
    {
    TPtrC tag = TagNameL( aTagType );

    HBufC16* indent = IndentationLC();     
    HBufC16* string = HBufC16::NewLC( KPosStringLength + indent->Length() + aAttributes.Length() );

    string->Des().Append( *indent );
    string->Des().Append( KPosXmlSTagStart );
    string->Des().Append( KPosXmlNameSpacePrefix );
    string->Des().Append( tag );
    
    if ( aAttributes.Length() )
        {
        string->Des().Append( KPosXmlSpace );
        string->Des().Append( aAttributes );
        }
    
    string->Des().Append( KPosXmlTagEnd );

    if ( !IsTagLeaf( aTagType ) )
        {
        string->Des().Append( KPosXmlNewLine );
        iIndentationDepth++;
        }

    CleanupStack::Pop( string );
    CleanupStack::PopAndDestroy( indent );
    CleanupStack::PushL( string );
    return string;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
HBufC16* CPosLmXmlEncoder::ETagStringLC( TPosXmlTagType aTagType ) 
    {
    TPtrC tag = TagNameL( aTagType );

    if ( !IsTagLeaf( aTagType ) )
        {
        iIndentationDepth = Max( iIndentationDepth - 1, 0 );
        }

    HBufC16* indent = IndentationLC();     
    HBufC16* string = HBufC16::NewLC( KPosStringLength + indent->Length() );

    if ( !IsTagLeaf( aTagType ) )
        {
        string->Des().Append( *indent );
        }
    string->Des().Append( KPosXmlETagStart );
    string->Des().Append( KPosXmlNameSpacePrefix );
    string->Des().Append( tag );
    string->Des().Append( KPosXmlTagEnd );
    string->Des().Append( KPosXmlNewLine );

    CleanupStack::Pop( string );
    CleanupStack::PopAndDestroy( indent );
    CleanupStack::PushL( string );
    return string;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmXmlEncoder::ResetIndentation()
    {
    iIndentationDepth = 0;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
HBufC16* CPosLmXmlEncoder::IndentationLC()
    {
    ASSERT( iIndentationDepth >= 0 );
    TInt indentLength = iIndentationDepth * KPosXmlTab().Length();
    HBufC16* indent = HBufC16::NewLC( indentLength );
    for ( TInt i=0; i < iIndentationDepth; i++ )
        {
        indent->Des().Append( KPosXmlTab );
        }
    return indent;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TBool CPosLmXmlEncoder::IsTagLeaf( TPosXmlTagType aXmlTagType )
    {
    return ( aXmlTagType < EPosXmlLmLastTree );
    }