/*

* 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:  Build liw list from a DomDocument.

*

*/

#include <s32mem.h>

#include <hspsdomdepthiterator.h>

#include <hspsdomnode.h>

#include <hspsdomattribute.h>

#include "hspsliwutilities.h"

#include "hspsxmlelements.h"

#include "hspsliwvocabulary.hrh"

const TInt KMaxTextLength = 16 * 1024; // 16KB.

_LIT8( KMaxChildDefault, "6" );

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

// Constructor

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

CHspsLiwUtilities::CHspsLiwUtilities()

	{

	}

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

// Destructor

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

CHspsLiwUtilities::~CHspsLiwUtilities()

	{

	}

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

//

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

CHspsLiwUtilities* CHspsLiwUtilities::CHspsLiwUtilities::NewL()

	{

	CHspsLiwUtilities* self = CHspsLiwUtilities::NewLC();

	CleanupStack::Pop( self ); //self

	return self;

	}

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

// 

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

CHspsLiwUtilities* CHspsLiwUtilities::CHspsLiwUtilities::NewLC()

	{

	CHspsLiwUtilities* self = new ( ELeave ) CHspsLiwUtilities();

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;	

	}

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

// 2nd stage constructor

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

void CHspsLiwUtilities::ConstructL()

	{	

	}

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

// Adds common status element to the output parameter list

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

void CHspsLiwUtilities::AppendStatusL( 

    TInt32 aStatus,

    CLiwGenericParamList& aOutParamList )

    {    

    TLiwGenericParam param;

    param.SetNameAndValueL( KHspsLiwStatus, TLiwVariant( aStatus ) );

    aOutParamList.AppendL( param );

    param.Reset();

    }

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

// Builds liw list from a dom document.

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

void CHspsLiwUtilities::GetConfigurationL( 

	const TDesC8& aReturnName,

    const TDesC8& aPluginId,

    ChspsDomDocument& aDomDocument,

    CLiwGenericParamList& aOutParamList )

	{

	ChspsDomNode* node( NULL );

    TInt err = KErrNotFound;

	//figure out what part of the dom is wanted.

	//we have configuration id.

	if( aPluginId.Length() > 0 )

		{

		//we have plugin id.

		//get view/widget configuration.

		//finds configuration node with plugin id.

		node = &( FindRootNodeByIdentifierL( KPluginElement, aPluginId, *aDomDocument.RootNode() ));

		if ( node )

		    {

    		node = &( FindRootNodeByTagL( KConfigurationElement, 

                    *node ));

		    }

		}

	else

		{

		//get application configuration

		//finds first configuration node.

		node = &( FindRootNodeByTagL( KConfigurationElement, 

								  *aDomDocument.RootNode() ));

		}

	if( node )

		{

	    CLiwDefaultMap* rootMap = CLiwDefaultMap::NewL();

	    CleanupStack::PushL( rootMap ); 

    	err = BuildConfigurationMapL( *node, *rootMap );

    	//put map into the iterable.

    	TLiwVariant rootMapVariant;

    	rootMapVariant.Set( rootMap );

    	//Put iterable into outParamList

    	TLiwGenericParam rootMapParam;

    	rootMapParam.SetNameAndValueL( aReturnName, rootMapVariant );

    	aOutParamList.AppendL( rootMapParam );

    	//Cleanup.

    	CleanupStack::Pop( rootMap );

    	rootMap->DecRef();

    	rootMapParam.Reset();

	    }

	User::LeaveIfError( err );

	}

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

// Builds plugins list from plugin header list

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

void CHspsLiwUtilities::GetPluginsOutputL( 

    CArrayPtrFlat<ChspsODT>& aList,

    CLiwGenericParamList& aOutParamList )

    {

    CLiwDefaultList* pluginList = CLiwDefaultList::NewL();

    CleanupStack::PushL( pluginList );

    BuildPluginInfoListL( aList, *pluginList );

    TLiwVariant listVariant;

    listVariant.Set( pluginList );

    TLiwGenericParam param;

    param.SetNameAndValueL( KHspsLiwPlugins, listVariant );

    aOutParamList.AppendL( param );

    CleanupStack::Pop( pluginList );

    pluginList->DecRef();

    param.Reset();

    }

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

// Builds plugins list from plugin node list

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

void CHspsLiwUtilities::GetPluginListOutputL( 

    ChspsDomNode& aRootNode,

    TDesC8& aType,

    TDesC8& aPluginId,

    CLiwGenericParamList& aOutParamList )

    {    

    CLiwDefaultList* pluginList = CLiwDefaultList::NewL();

    CleanupStack::PushL( pluginList );

    BuildPluginListL(

        aRootNode,

        aType,

        aPluginId,

        *pluginList );

    TLiwVariant listVariant;

    listVariant.Set( pluginList );

    TLiwGenericParam param;

    param.SetNameAndValueL( KHspsLiwPlugins, listVariant );

    aOutParamList.AppendL( param );

    CleanupStack::Pop( pluginList );

    pluginList->DecRef();

    param.Reset();

    }

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

// Creates output parmater list for AddPlugin method

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

void CHspsLiwUtilities::AddPluginOutputL( 

    TInt aPluginId,

    CLiwGenericParamList& aOutParamList )

    {    

    TBuf8<10>id;

    _LIT8(KFormat8, "%d");

    id.AppendFormat( KFormat8, aPluginId );

    TLiwGenericParam param;

    param.SetNameAndValueL( KPluginId, TLiwVariant( id ) );

    aOutParamList.AppendL( param );

    param.Reset();

    }

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

// Creates output parmater list for RemovePlugin method

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

void CHspsLiwUtilities::RemovePluginOutputL( 

    CLiwGenericParamList& aOutParamList )

    {

    AppendStatusL( KErrNone, aOutParamList );

    }

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

// Creates output parmater list for ReplacePlugin method

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

void CHspsLiwUtilities::ReplacePluginOutputL( 

    CLiwGenericParamList& aOutParamList )

    {    

    AppendStatusL( KErrNone, aOutParamList );

    }

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

// Builds settings Dom document from liw list

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

TInt CHspsLiwUtilities::SetPluginSettingsNodeL( 

     const CLiwList& aItemList,

     TDesC8& aPluginId,

     ChspsDomDocument& aDomDocument,

     ChspsDomDocument& aSettingsDom )

    {

    TInt error(KErrNone);

    ChspsDomNode* node( NULL );

    ChspsDomNode* settingsNode( NULL );

    ChspsDomNode* itemNode( NULL );

    if( aPluginId.Length() > 0 )

        {

        // get plugin node

        node = &( FindRootNodeByIdentifierL( KPluginElement, aPluginId, *aDomDocument.RootNode() ));

        if ( node )

            {

            // get control node of the plugin

            node = &( FindRootNodeByTagL( KControlElement, 

                                        *node ));

            if( node )

                {

                TInt index = 0;

                // get settings node (child of control node)

                settingsNode = FindChildNodeByTagL(

                         KSettingsElement,

                         *node,

                         index );

                }

            }

        if ( node == NULL || settingsNode == NULL )

            {

            // pluginId Not Found

            error=KErrNotFound;

            } 

        TLiwVariant tempVariant;

        tempVariant.PushL();

        TInt itemsCount = aItemList.Count();

        if ( (KErrNone == error) &&

                     (itemsCount > 0) )

            {    

            // Find items for plugin settings

            for ( TInt i = 0; ( i < itemsCount && error == KErrNone ); i++ )

                {

                error = KErrNotFound;

                aItemList.AtL( i, tempVariant );

                const CLiwMap* item = tempVariant.AsMap();

                if ( (item != NULL) &&

                      item->FindL( KHspsLiwItemId, tempVariant ) )

                    {

                    TPtrC8 itemId;

                    itemId.Set( tempVariant.AsData() );

                    itemNode = &( FindRootNodeByIdentifierL( 

                            KItemElement, itemId, *settingsNode ));

                    if( itemNode )

                        {

                        item->FindL(KHspsLiwProperties, tempVariant );

                        const CLiwList* propertyList = tempVariant.AsList();

                        if(propertyList && propertyList->Count() > 0)

                            {

                            if ( SetPluginPropertyNodeL( *propertyList, *itemNode) == KErrNone )

                                {

                                error = KErrNone;                              

                                }

                            }

                        }

                    }               

                tempVariant.Reset();

                }

            }

        else

            {

            error = KErrNotFound;

            }

        CleanupStack::Pop(&tempVariant);

        tempVariant.Reset();

        if( error == KErrNone )

            {

            // Making Settings Dom

            ChspsDomNode* clone = settingsNode->CloneL( aSettingsDom.StringPool() );

            CleanupStack::PushL( clone );

            aSettingsDom.SetRootNode( clone );

            CleanupStack::Pop( clone );

            }

        }

    return error;

    }

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

// Parse Properties from liw list

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

TInt CHspsLiwUtilities::SetPluginPropertyNodeL( const CLiwList& aPropertyList,

        ChspsDomNode& aNode  )

    {

    // Init used local variables.        

    TInt err = KErrNone;

    TLiwVariant mapVariant;

    mapVariant.PushL();

    TLiwVariant propertyNameVariant;

    propertyNameVariant.PushL();

    TLiwVariant propertyValueVariant;

    propertyValueVariant.PushL();            

    const TInt propertiesCount = aPropertyList.Count();

    // Loop all items in given list.

    for( TInt i = 0; ( i < propertiesCount && err == KErrNone ); i++ )

        {        

        // Extract map.

        aPropertyList.AtL( i, mapVariant );

        const CLiwMap* property = mapVariant.AsMap();

        if( property == NULL ) 

            {

            err = KErrCorrupt;

            }

        // Extract property name.

        if( !err )

            {

            if( !property->FindL( KHspsLiwPropertyName, propertyNameVariant ) )

                {

                err = KErrNotFound;

                }

            }

        TPtrC8 name;

        if( !err )

            {

            name.Set( propertyNameVariant.AsData() );

            if( name.Length() > KMaxTextLength )

                {

                err = KErrArgument;

                }

            }

        // Extract property value.

        if( !err )

            {

            if( !property->FindL( KHspsLiwPropertyValue, propertyValueVariant ) )

                {

                err = KErrNotFound;

                }

            }

        TPtrC8 value;

        if( !err )

            {        

            value.Set( propertyValueVariant.AsData() );

            if( value.Length() > KMaxTextLength )

                {

                err = KErrArgument;

                }

            }

        // Set attribute.

        if( !err )

            {

            err = SetPropertyAttributesL( name, value, aNode );

            }

        mapVariant.Reset();

        propertyNameVariant.Reset();

        propertyValueVariant.Reset();        

        }

    // Cleanup.    

    CleanupStack::Pop( &propertyValueVariant );

    CleanupStack::Pop( &propertyNameVariant );

    CleanupStack::Pop( &mapVariant );

    return err;   

    }

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

// SetpropertyAttributeL replaces value of property attribute given in parameter 

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

//

TInt CHspsLiwUtilities::SetPropertyAttributesL(

         TDesC8& aAttrName,

         TDesC8& aAttrValue,

        ChspsDomNode& aNode )

    {

    TInt error(KErrNotFound);

    ChspsDomDepthIterator* iter = ChspsDomDepthIterator::NewL( aNode );

    CleanupStack::PushL( iter );                                

    ChspsDomNode* node = iter->First();                              

    TBool replaced(EFalse);                     

    while( node && !replaced )

        {

        const TDesC8& nodeName = node->Name();

        if( nodeName == KPropertyElement )

            {

            ChspsDomList& attrList = node->AttributeList();

            ChspsDomAttribute* attr = static_cast<ChspsDomAttribute*>( attrList.FindByName(KPropertyAttrName) );     

            if ( attr )

                {

                const TDesC8& name = attr->Value(); 

                if (aAttrName.Compare( name )== 0 ) 

                    {

                    ChspsDomAttribute* attr2 = static_cast<ChspsDomAttribute*>( attrList.FindByName(KPropertyAttrValue) );

                    if( attr2 )

                        {

                        attr2->SetValueL( aAttrValue );

                        replaced=ETrue;

                        error = KErrNone;

                        }

                    }

                }

            }

        if( !replaced )

            {

            node = iter->NextL();

            }

        }

    CleanupStack::PopAndDestroy( iter );

    return error;

    }  

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

// Creates output parmater list for SetPluginSettings method

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

void CHspsLiwUtilities::SetPluginSettingsOutputL( 

    CLiwGenericParamList& aOutParamList )

    {

    AppendStatusL( KErrNone, aOutParamList );

    }

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

// Creates output parmater list for GetPluginSettings method

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

void CHspsLiwUtilities::GetPluginSettingsOutputL( 

		ChspsDomDocument& aDom, 

		CLiwGenericParamList& aOutParamList )

	{

	TInt pos = 0;

    CLiwDefaultList* list = CLiwDefaultList::NewL();

    CleanupStack::PushL( list );

	ChspsDomNode* node( NULL );

	node = aDom.RootNode();

    if( !node )

    	{

    	User::Leave( KErrNotFound );

    	}

    // get ctrl node (child of control node)

    node = FindChildNodeByTagL(

    	KControlElement,

        *node,

        pos );

    if( !node )

    	{

    	User::Leave( KErrNotFound );

    	}

    // get settings node (child of control node)

    node = FindChildNodeByTagL(

    	KSettingsElement,

        *node,

        pos );

    if ( node )

        {

        // append item maps to settings list

        AppendItemsL( *node, *list );

        }

    else

        {

        User::Leave( KErrNotFound );