/*
* Copyright (c) 2006 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:   CNcdConfigurationParser implementation
*
*/


#include "ncdprotocolutils.h"
#include "ncdconfigurationparser.h"
#include "ncdparserobserver.h"
#include "catalogsdebug.h"
#include "ncdprotocolutils.h"

_LIT8( KXmlType, "text/xml" );



// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CNcdConfigurationParser* CNcdConfigurationParser::NewL( 
        MNcdConfigurationParserObserver& aObserver )
    {
    CNcdConfigurationParser* self = CNcdConfigurationParser::NewLC( 
        aObserver );
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CNcdConfigurationParser* CNcdConfigurationParser::NewLC( 
        MNcdConfigurationParserObserver& aObserver )
    {
    CNcdConfigurationParser* self = new(ELeave) CNcdConfigurationParser(
        aObserver );
    CleanupStack::PushL( self );
    return self;
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CNcdConfigurationParser::CNcdConfigurationParser( 
    MNcdConfigurationParserObserver& aObserver )
    : iObserver( aObserver )  
    {
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CNcdConfigurationParser::~CNcdConfigurationParser()
    {
    delete iXmlParser;
    iXmlParser = NULL;
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdConfigurationParser::ParseL( const TDesC16& aData )
    {
    DLTRACEIN(("16-bit parse, length=%d",aData.Length()));
    HBufC8* utf8 = NcdProtocolUtils::ConvertUnicodeToUtf8L( aData );
    CleanupStack::PushL( utf8 );
    ParseL( *utf8 );
    CleanupStack::PopAndDestroy( utf8 );
    
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdConfigurationParser::ParseL( const TDesC8& aData )
    {
    DLTRACEIN((""));
    iXmlParser = Xml::CParser::NewL( KXmlType, *this );
    iXmlParser->ParseBeginL();

    iXmlParser->ParseL( aData );
    iXmlParser->ParseEndL(); 
    
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdConfigurationParser::OnStartDocumentL(
    const Xml::RDocumentParameters& /*aDocParam*/, TInt aErrorCode) 
    {
    DLTRACE(("error=%d",aErrorCode));
    (void) aErrorCode; // suppresses compiler warning
//     iDocParam.Open( aDocParam.CharacterSetName() );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdConfigurationParser::OnEndDocumentL(TInt /*aErrorCode*/)
    {
//    DLTRACE(("tag=%S error=%d",iTag,aErrorCode));
//     iDocParam.Close();
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdConfigurationParser::OnStartElementL( 
    const Xml::RTagInfo& aElement, 
    const Xml::RAttributeArray& aAttributes, 
    TInt aErrorCode )
    {
    DLTRACE(("Start tag: %S, error=%d", 
        &aElement.LocalName().DesC(), aErrorCode ));
    (void) aErrorCode; // suppresses compiler warning
    
    iObserver.ConfigurationElementStartL( aElement.LocalName().DesC() );
    
    DLTRACE(("Handling %d attributes", aAttributes.Count() ));
    for ( TInt i = 0; i < aAttributes.Count(); ++i ) 
        {
        iObserver.ConfigurationAttributeL( aElement.LocalName().DesC(),
            aAttributes[i].Attribute().LocalName().DesC(),
            aAttributes[i].Value().DesC() );
        }
    
    delete iBuffer;
    iBuffer = NULL;
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdConfigurationParser::OnEndElementL(
    const Xml::RTagInfo& aElement,
    TInt /* aErrorCode */ )
    {
    DLTRACEIN((""));
    if ( iBuffer ) 
        {
        DLTRACE(("Handling element data"));
        iObserver.ConfigurationElementEndL( aElement.LocalName().DesC(),
            *iBuffer );
        delete iBuffer;
        iBuffer = NULL;
        }    
    else
        {
        DLTRACE(("Handling empty element data"));
        iObserver.ConfigurationElementEndL( aElement.LocalName().DesC(),
            KNullDesC8 );

        }
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdConfigurationParser::OnContentL( 
    const TDesC8& aBytes, 
    TInt /*aErrorCode*/ )
    { 
    DLTRACEIN(( "content size=%d",aBytes.Length() ));
//     if( aBytes.Length() < 1000 )
//         {
//         DLINFODUMP(aBytes.Ptr(),aBytes.Length(),1024) ;
//         DLINFO(("data=%S",&aBytes));
//         }
    if ( iBuffer ) 
        {
        TInt oldLength = iBuffer->Length();
        iBuffer = iBuffer->ReAllocL( oldLength + aBytes.Length() );
        }
    else 
        {
        iBuffer = HBufC8::NewL( aBytes.Length() );
        }
        
    iBuffer->Des().Append( aBytes );
    DLTRACEOUT(( "buffer=%X size=%d", this, iBuffer->Length() ));
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdConfigurationParser::OnStartPrefixMappingL( 
    const RString& /*aPrefix*/, const RString& /*aUri*/, 
    TInt aErrorCode ) 
    {
    DLTRACE(("error=%d",aErrorCode));
    (void) aErrorCode; // suppresses compiler warning
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdConfigurationParser::OnEndPrefixMappingL(
    const RString& /*aPrefix*/, TInt aErrorCode ) 
    {
    DLTRACE(("error=%d",aErrorCode));
    (void) aErrorCode; // suppresses compiler warning
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdConfigurationParser::OnIgnorableWhiteSpaceL(
    const TDesC8& /*aBytes*/, TInt aErrorCode ) 
    {
    DLTRACE(("error=%d",aErrorCode));
    (void) aErrorCode; // suppresses compiler warning
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdConfigurationParser::OnSkippedEntityL( 
    const RString& /*aName*/, TInt aErrorCode )
    {
    DLTRACE(("error=%d",aErrorCode));
    (void) aErrorCode; // suppresses compiler warning
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdConfigurationParser::OnProcessingInstructionL(
    const TDesC8& /*aTarget*/, const TDesC8& /*aData*/, TInt aErrorCode ) 
    {
    DLTRACE(("error=%d",aErrorCode));
    (void) aErrorCode; // suppresses compiler warning
    }


// When the CParser gives OnError(), it will not continue even if further
// data is fed to it.
void CNcdConfigurationParser::OnError(TInt aErrorCode)
    {
    DLTRACE(("error=%d",aErrorCode));
    iObserver.ConfigurationError( aErrorCode );
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TAny* CNcdConfigurationParser::GetExtendedInterface(const TInt32 /*aUid*/) 
    {
    DLTRACE((""));
    return 0;
    }