/*
* Copyright (c) 2008 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 ChspsLiwDump.
*
*/


#include "hspsbytebuffer.h"
#include "hspsliwdump.h"
#include "hspslogbus.h"
#include <s32mem.h>
#include <liwcommon.h>

#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
// indentation delimiter
_LIT8 (KDelim8, "\t" );
_LIT( KDelim, "\t" );
_LIT( KCPlusPlusArrayStart, "const TUint8 liwDump[] = {" );
_LIT( KCPlusPlusArrayEnd, "};" );
const TInt KCPlusPlusArraySanityLimit = 16384;   // 16kb.
_LIT( KByteFormat, "0x%02x" );
_LIT( KLiwListBinaryDumpStartTag, "#LIW LIST BINARY DUMP START" );
_LIT( KLiwListBinaryDumpEndTag, "#LIW LIST BINARY DUMP END" );
_LIT( KLiwListTextDumpStartTag, "#LIW LIST TEXT DUMP START" );
_LIT( KLiwListTextDumpEndTag, "#LIW LIST TEXT DUMP END" );
#endif 

//------------------------------------------------------------------------------
// ChspsLiwDump::~ChspsLiwDump
//------------------------------------------------------------------------------
EXPORT_C ChspsLiwDump::~ChspsLiwDump()
    {
    }

//------------------------------------------------------------------------------
// ChspsLiwDump::NewLC
//------------------------------------------------------------------------------
EXPORT_C ChspsLiwDump* ChspsLiwDump::NewLC( ChspsLogBus& aLogBus )
    {
    ChspsLiwDump* self = new (ELeave)ChspsLiwDump( aLogBus );
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

//------------------------------------------------------------------------------
// ChspsLiwDump::NewL
//------------------------------------------------------------------------------
EXPORT_C ChspsLiwDump* ChspsLiwDump::NewL( ChspsLogBus& aLogBus )
    {
    ChspsLiwDump* self = ChspsLiwDump::NewLC( aLogBus );
    CleanupStack::Pop( self ); // self;
    return self;
    }

//------------------------------------------------------------------------------
// ChspsLiwDump::LogLiwListAsText
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
EXPORT_C void ChspsLiwDump::LogLiwListAsText( CLiwGenericParamList& aLiwList )
    {
    TRAP_IGNORE( LogLiwListAsTextL( aLiwList ); );
    }
#else
EXPORT_C void ChspsLiwDump::LogLiwListAsText( CLiwGenericParamList& /*aLiwList*/ )
    {    
    }
#endif

#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
//------------------------------------------------------------------------------
// ChspsLiwDump::LogLiwListAsBinary
//------------------------------------------------------------------------------
EXPORT_C void ChspsLiwDump::LogLiwListAsBinary( CLiwGenericParamList& aLiwList )
    {
    TRAP_IGNORE( LogLiwListAsBinaryL( aLiwList ); );
    }
#else
EXPORT_C void ChspsLiwDump::LogLiwListAsBinary( CLiwGenericParamList& /*aLiwList*/ )
    {    
    }
#endif

//------------------------------------------------------------------------------
// ChspsLiwDump::ChspsLiwDump
//------------------------------------------------------------------------------
ChspsLiwDump::ChspsLiwDump( ChspsLogBus& aLogBus ) : iLogBus( aLogBus )
    {
    iDepth = 0;
    }

//------------------------------------------------------------------------------
// ChspsLiwDump::ConstructL
//------------------------------------------------------------------------------
void ChspsLiwDump::ConstructL()
    {
    }

//------------------------------------------------------------------------------
// ChspsLiwDump::LogLiwListAsTextL
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
void ChspsLiwDump::LogLiwListAsTextL( CLiwGenericParamList& aLiwList )
    {
    iLogBus.LogText( KLiwListTextDumpStartTag );
    
    // implementation for GetActiveAppConf and GetPluginConf that has map
    // as base root.      
    iDepth = 0;
    TInt count = aLiwList.Count();
    for( TInt i = 0; i < count; i++ )
        {
        //get Generic param and check for param id and name.
        TLiwGenericParam param = aLiwList[i];
        //Check for the param identifier:
        LIW::TGenericParamId identifier = param.SemanticId();
        //print semanticId:
        iLogBus.LogText( _L8(" SemanticId: %d"), identifier );
        if( identifier == LIW::EGenericParamError )
            {
            iLogBus.LogText( _L8(" ERROR: EGenericParamError") );
            }
        //get generic param name.
        //print name.
        iLogBus.LogText( param.Name() );
        //get Variant
        TLiwVariant value = param.Value();
        //get variant type.
        PrintVariantL( value );
        }
    
    iLogBus.LogText( KLiwListTextDumpEndTag );
    }
#else
void ChspsLiwDump::LogLiwListAsTextL( CLiwGenericParamList& /*aLiwList*/ )
    {    
    }
#endif

#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
//------------------------------------------------------------------------------
// ChspsLiwDump::LogLiwListAsBinaryL
//------------------------------------------------------------------------------
void ChspsLiwDump::LogLiwListAsBinaryL( CLiwGenericParamList& aLiwList )
    {    
    iLogBus.LogText( KLiwListBinaryDumpStartTag );
    
    const TInt byteSize = aLiwList.Size();
    if( byteSize <= 0 )
        {
        User::Leave( KErrArgument );
        }

    // Create memory buffer.
    ChspsByteBuffer* buffer = ChspsByteBuffer::NewL( byteSize );
    CleanupStack::PushL( buffer );    

    // Wrap buffer using memory stream.
    RMemWriteStream stream;    
    stream.Open( buffer->Buffer(), byteSize );
    stream.PushL();
    
    // Use stream that wraps buffer to enable direct-to-RAM
    // streaming from CLiwGenericParamList.
    aLiwList.ExternalizeL( stream );
    stream.CommitL();
    
    // Clean stream wrapper.
    stream.Release();
    stream.Close();
    stream.Pop();
    
    // Create C++ array and print it.
    HBufC* cplusplusDump = CreateCPlusPlusDumpL( *buffer );
    iLogBus.LogText( *cplusplusDump );
    delete cplusplusDump;
    cplusplusDump = NULL;
    
    // Clean memory buffer
    CleanupStack::PopAndDestroy( buffer );        
    
    iLogBus.LogText( KLiwListBinaryDumpEndTag );
    }
#else
void ChspsLiwDump::LogLiwListAsBinaryL( CLiwGenericParamList& /*aLiwList*/ )
    {    
    }
#endif

//------------------------------------------------------------------------------
// ChspsLiwDump::PrintVariantL
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
void ChspsLiwDump::PrintVariantL( TLiwVariant value )
    {
    LIW::TVariantTypeId variantId = value.TypeId();
    if( variantId == LIW::EVariantTypeDesC8 )
        {
        PrintString8L( value );
        }
    else if( variantId == LIW::EVariantTypeDesC )
        {
        PrintStringL( value );
        }
    else if ( variantId == LIW::EVariantTypeMap )
        {
        HBufC* text = GetFixedTextLC( _L("<Map>"), iDepth, KDelim );
        iLogBus.LogText( *text );
        CleanupStack::PopAndDestroy( text );
        PrintMapL( value );
        }
    else if ( variantId == LIW::EVariantTypeList )
        {
        HBufC* text = GetFixedTextLC( _L("<List>"), iDepth, KDelim );
        iLogBus.LogText( *text );
        CleanupStack::PopAndDestroy( text );
        PrintListL( value );
        }
    else 
        {
        iLogBus.LogText( _L8("--- TODO: Unknown --- "));
        }
    }
#else
void ChspsLiwDump::PrintVariantL( TLiwVariant /*value*/ )
    {    
    }
#endif

//------------------------------------------------------------------------------
// ChspsLiwDump::PrintMapL
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
void ChspsLiwDump::PrintMapL( TLiwVariant value )
    {
    //get map from the variant.
    //get map values.
    const CLiwMap* map = value.AsMap();
    TInt count = map->Count();
    for( TInt i = 0; i < count; i++ )
        {
        HBufC* index = GetFixedTextLC( _L("---"), iDepth, KDelim );
        iLogBus.LogText( *index );
        CleanupStack::PopAndDestroy( index );
        TBuf8<100> buf;
        map->AtL( i, buf);
        HBufC8* text = GetFixedText8LC( buf, iDepth, KDelim8 );
        iLogBus.LogText( *text );
        CleanupStack::PopAndDestroy( text );
        TLiwVariant value;
        map->FindL( buf, value );
        PrintVariantL( value );
        value.Reset();
        }
    }
#else
void ChspsLiwDump::PrintMapL( TLiwVariant /*value*/ )
    {
    }
#endif

//------------------------------------------------------------------------------
// ChspsLiwDump::PrintStringL
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
void ChspsLiwDump::PrintStringL( TLiwVariant value )
    {
    TPtrC textValue = value.AsDes();
    HBufC* text = GetFixedTextLC( textValue, iDepth, KDelim );
    iLogBus.LogText( *text );
    CleanupStack::PopAndDestroy( text );
    }
#else
void ChspsLiwDump::PrintStringL( TLiwVariant /*value*/ )
    {    
    }
#endif

//------------------------------------------------------------------------------
// ChspsLiwDump::PrintString8L
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
void ChspsLiwDump::PrintString8L( TLiwVariant value )
    {
    TPtrC8 textValue = value.AsData();
    HBufC8* text = GetFixedText8LC( textValue, iDepth, KDelim8 );
    iLogBus.LogText( *text );
    CleanupStack::PopAndDestroy( text );
    }
#else
void ChspsLiwDump::PrintString8L( TLiwVariant /*value*/ )
    {    
    }
#endif

//------------------------------------------------------------------------------
// ChspsLiwDump::PrintListL
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
void ChspsLiwDump::PrintListL( TLiwVariant value )
    {
    iDepth++;
    const CLiwList* list = value.AsList();
    TInt count = list->Count();
    for( TInt i = 0; i < count; i++ )
        {
        HBufC* index = GetFixedTextLC( _L("---"), iDepth, KDelim );
        iLogBus.LogText( *index );
        CleanupStack::PopAndDestroy( index );
        TLiwVariant value;
        list->AtL( i, value );
        PrintVariantL( value );
        value.Reset();
        }
    iDepth--;
    }
#else
void ChspsLiwDump::PrintListL( TLiwVariant /*value*/ )
    {    
    }
#endif

//------------------------------------------------------------------------------
// ChspsLiwDump::GetFixedText8LC
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
HBufC8* ChspsLiwDump::GetFixedText8LC( const TDesC8& aText, 
                                       const TInt aDepth, 
                                       const TDesC8& aDelim )
    {
    HBufC8 *buf = HBufC8::NewLC( aDepth * aDelim.Length() + aText.Length() + 1 );   
    TInt i = 0;
    for( ; i < aDepth; i++ )
        {
        buf->Des().Append( aDelim );
        }
    buf->Des().Append( aText );
    return buf;
    }
#else
HBufC8* ChspsLiwDump::GetFixedText8LC( const TDesC8& /*aText*/, 
                                       const TInt /*aDepth*/, 
                                       const TDesC8& /*aDelim*/ )
    {
    return NULL;
    }
#endif

//------------------------------------------------------------------------------
// ChspsLiwDump::GetFixedTextLC
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
HBufC* ChspsLiwDump::GetFixedTextLC( const TDesC& aText, 
                                     const TInt aDepth, 
                                     const TDesC& aDelim )
    {
    HBufC *buf = HBufC::NewLC( aDepth * aDelim.Length() + aText.Length() + 1 ); 
    TInt i = 0;
    for( ; i < aDepth; i++ )
        {
        buf->Des().Append( aDelim );
        }
    buf->Des().Append( aText );
    return buf;
    }
#else
HBufC* ChspsLiwDump::GetFixedTextLC( const TDesC& /*aText*/, 
                                     const TInt /*aDepth*/, 
                                     const TDesC& /*aDelim*/ )
    {
    return NULL;
    }
#endif

//------------------------------------------------------------------------------
// ChspsLiwDump::CreateCPlusPlusDumpL
//------------------------------------------------------------------------------
#ifdef HSPS_BUILD_LOG_IMPLEMENTATION
HBufC* ChspsLiwDump::CreateCPlusPlusDumpL( ChspsByteBuffer& aBuffer ) const
    {
    if( aBuffer.Size() <= 0 )
        {
        User::Leave( KErrArgument );
        }

    if( aBuffer.Size() > KCPlusPlusArraySanityLimit )
        {
        User::Leave( KErrArgument );
        }
    
    // Calcute required space.
    const TInt KOneByteFootprint = 5; // hex is like 0x00 = 4 bytes, then trailing ',' for each one.   
    const TInt KRequiredSpace = KCPlusPlusArrayStart().Length() +                                
                                ( aBuffer.Size() * KOneByteFootprint ) +
                                KCPlusPlusArrayEnd().Length();                                       
    
    // Create descriptor.
    HBufC* descriptor = HBufC::NewLC( KRequiredSpace );
    TPtr16 pointer = descriptor->Des();
    pointer.Append( KCPlusPlusArrayStart );
    for( TInt i = 0; i < aBuffer.Size(); i++ )
        {
        TUint byte = ( TUint ) ( ( aBuffer.Buffer() )[i] );
        pointer.AppendFormat( KByteFormat, byte );
        
        // Add ',' for all but the last element.
        if( i != ( aBuffer.Size() - 1 ) )
            {
            pointer.Append( TChar( ',' ) );
            }
        }
    pointer.Append( KCPlusPlusArrayEnd );
    
    CleanupStack::Pop( descriptor );
    return descriptor;
    }
#else
HBufC* ChspsLiwDump::CreateCPlusPlusDumpL( ChspsByteBuffer& /*aBuffer*/ ) const
    {
    return NULL;
    }
#endif