/*

* Copyright (c) 2002 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:  ?Description

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include "TestHspApi.h"

#include <hswidgetpublisher.h>

#include <hswidget.h>

#include <hsdataobserver.h>

#include <liwservicehandler.h>

#include <liwvariant.h>

#include <liwgenericparam.h>

#include <liwcommon.h>

#include "waitactive.h"

#include <hsexception.h>

_LIT8( KResults, "results" );

_LIT8( KType, "type" );

_LIT( KCpData, "cp_data" );

_LIT8( KContentIdFormat, "%s:%s");

_LIT8( KPublisherId, "publisher" );

_LIT8( KContentType, "content_type" );

_LIT8( KContentId, "content_id" );

_LIT( KHsPublisher, "ai3templatedwidget" );

_LIT( KHsWidgetPublisher, "hswidgetpublisher");

_LIT( KAll, "all" );

_LIT8( KFilter, "filter" );

_LIT( KContentAndPublisher_Registry, "cp_data:publisher");

_LIT8( KRequestNotification, "RequestNotification" );

_LIT( KPublisher, "publisher" );

_LIT8( KActionTrigger, "action_trigger" );

_LIT8( KCPService, "Service.ContentPublishing" );

_LIT8( KActive, "active");

_LIT8( KSelected, "selected");

_LIT( KFakeContentId, "616" );

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

// 

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

//

LOCAL_C HBufC* StdStringTo16bitDescLC( const std::string& aSrcString )

    {

    TPtrC8 srcDescriptor = (TUint8*) aSrcString.c_str();

    HBufC* dstDescriptor = HBufC::NewLC( srcDescriptor.Length() );

    dstDescriptor->Des().Copy( srcDescriptor );

    return dstDescriptor;

    }

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

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

// CTestHspApi::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

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

//

void CTestHspApi::Delete() 

    {

    mServiceInterface->Close();

    delete mServiceHandler;    

    }

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

// CTestHspApi::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt CTestHspApi::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function. 

        ENTRY( "TestHspApiConstrL", CTestHspApi::TestHspApiConstrL ),

        ENTRY( "TestHspWidgetAddWidgetItem1L", CTestHspApi::TestHspWidgetAddWidgetItem1L ),

        ENTRY( "TestHspWidgetAddWidgetItem2L", CTestHspApi::TestHspWidgetAddWidgetItem2L ),

        ENTRY( "TestHspWidgetAddWidgetItem3L", CTestHspApi::TestHspWidgetAddWidgetItem3L ),

        ENTRY( "TestHspApiDeleteWidgetL", CTestHspApi::TestHspApiDeleteWidgetL ), 

        ENTRY( "TestHspApiSetDataObserver1L", CTestHspApi::TestHspApiSetDataObserver1L ),

		ENTRY( "TestHspApiSetDataObserver2L", CTestHspApi::TestHspApiSetDataObserver2L ),

        ENTRY( "TestHspApiGetWidgetL", CTestHspApi::TestHspApiGetWidgetL ),

        ENTRY( "TestHspApiWidgetRemoveItem1L", CTestHspApi::TestHspApiWidgetRemoveItem1L ),

		ENTRY( "TestHspApiWidgetRemoveItem2L", CTestHspApi::TestHspApiWidgetRemoveItem2L ),

        ENTRY( "TestHspApiExceptionL", CTestHspApi::TestHspApiExceptionL ),

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// 

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

//

TInt CTestHspApi::ExtractItemCountL(

      const CLiwGenericParamList& aInParamList )

    {

    TInt result( KErrNotFound );

    TInt count (0);

    TInt pos( 0 );

    aInParamList.FindFirst( pos, KResults );

    if( pos != KErrNotFound )

      // results present - extract and return text

         {

         TLiwVariant variant = aInParamList[pos].Value();

         CLiwIterable* iterable = variant.AsIterable();

         iterable->Reset();

         while(iterable->NextL( variant ))

            {

            count++;

            }

         iterable->Reset();

         variant.Reset();

         result = count;

         }

    return result;

    }

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

// 

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

//

TInt CTestHspApi::ExtractItemL( const CLiwGenericParamList& aInParamList,

		const TDesC8& aItemName, RBuf& aItemValue )

	{

    TInt result( KErrNotFound );

    TInt count (0);

    TInt pos( 0 );

    aInParamList.FindFirst( pos, KResults );

    if( pos != KErrNotFound )

      // results present - extract and return text

         {

         TLiwVariant variant = aInParamList[pos].Value();

         CLiwIterable* iterable = variant.AsIterable();

         TLiwVariant item;

         while ( iterable->NextL( item ) )

        	 {

        	 CLiwDefaultMap *map = CLiwDefaultMap::NewLC();

        	 item.Get( *map );

             TLiwVariant dataMapVariant;

             TBool found = map->FindL( _L8("data_map"), dataMapVariant );

             if ( found )

            	 {

				 CLiwDefaultMap *dataMap = CLiwDefaultMap::NewLC();

				 dataMapVariant.Get( *dataMap );

				 TLiwVariant item1;

				 found = dataMap->FindL( aItemName, item1 );

				 if ( found )

					 {

					 TPtrC ptr;

					 item1.Get( ptr );

					 aItemValue.Create( ptr );

					 result = KErrNone;

					 }

				 item1.Reset();

				 dataMapVariant.Reset();

				 CleanupStack::PopAndDestroy( dataMap );

            	 }

        	 CleanupStack::PopAndDestroy( map );

        	 }         

         iterable->Reset();

         variant.Reset();

         }

    return result;

    }

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

// 

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

//

CLiwGenericParamList* CTestHspApi::GetListL( std::string& aContentType, 

		std::string& aIdentifier, std::string& aWidgetName )

	{

	TBool res( EFalse );

	CLiwGenericParamList* inParam = &(mServiceHandler->InParamListL());

	CLiwGenericParamList* outParam = &(mServiceHandler->OutParamListL());

	TLiwGenericParam type(KType, TLiwVariant(KCpData));

	inParam->AppendL(type);

	CLiwDefaultMap* cpdatamap = CLiwDefaultMap::NewLC();

	TPtrC8 contentType = ((TUint8*)aContentType.c_str());

	const TInt KSAPIContentNameMaxLength = 255;

	TBuf8<KSAPIContentNameMaxLength> contentId;

	contentId = (TUint8*)aIdentifier.c_str();

	HBufC* publisherName = StdStringTo16bitDescLC( aIdentifier + ":hswidgetpublisher" );

	cpdatamap->InsertL( KPublisherId, TLiwVariant( *publisherName ));

	cpdatamap->InsertL( KContentType, TLiwVariant( KAll ));

	cpdatamap->InsertL( KContentId, TLiwVariant( KFakeContentId ));

	TLiwGenericParam filter( KFilter, TLiwVariant( cpdatamap ));

	inParam->AppendL( filter );

	mServiceInterface->ExecuteCmdL( _L8("GetList"),

		*inParam, *outParam);

	CleanupStack::PopAndDestroy( publisherName );

	CleanupStack::PopAndDestroy( cpdatamap );

	filter.Reset();

	type.Reset();	

	inParam->Reset();

	return outParam;

	}

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

// 

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

//

TInt CTestHspApi::HandleNotifyL(

    TInt /*aCmdId*/,

    TInt /*aEventId*/,

    CLiwGenericParamList& aEventParamList,

    const CLiwGenericParamList& /*aInParamList*/)

	{

	iActionStatus = KErrNone;

	}

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

// 

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

//

CLiwGenericParamList* CTestHspApi::ExecuteActionL( std::string& aContentType, 

		std::string& aIdentifier, std::string& aWidgetName )

	{

	TBool res( EFalse );

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

	// register for notification

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

	CLiwGenericParamList* inParam = &(mServiceHandler->InParamListL());

	CLiwGenericParamList* outParam = &(mServiceHandler->OutParamListL());

	CLiwDefaultMap* reqFilter = CLiwDefaultMap::NewLC();

	//reqFilter->InsertL( KPublisherId, TLiwVariant( KHSPPublisher ));

	reqFilter->InsertL( KPublisherId, TLiwVariant( KAll ));

	reqFilter->InsertL( KContentType, TLiwVariant( KAll ));

	reqFilter->InsertL( KContentId, TLiwVariant( KAll ));

	//reqFilter->InsertL( KOperation, TLiwVariant( KOperationExecute ));

	inParam->AppendL(TLiwGenericParam(KType, TLiwVariant(KContentAndPublisher_Registry)));

	inParam->AppendL(TLiwGenericParam(KFilter, TLiwVariant(reqFilter)));

	mServiceInterface->ExecuteCmdL( KRequestNotification,

		*inParam, *outParam, 0, this );

	outParam->Reset();

	inParam->Reset();

	CleanupStack::PopAndDestroy( reqFilter );

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

	// execute action

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

	TLiwGenericParam type(KType, TLiwVariant(KPublisher));

	inParam->AppendL(type);

	CLiwDefaultMap* cpdatamap = CLiwDefaultMap::NewLC();

	TPtrC8 contentType = ((TUint8*)aContentType.c_str());

	const TInt KSAPIContentNameMaxLength = 255;

	TBuf8<KSAPIContentNameMaxLength> contentId;

	contentId = (TUint8*)aIdentifier.c_str();

	cpdatamap->InsertL( KPublisherId, TLiwVariant( KHsWidgetPublisher ));

	cpdatamap->InsertL( KContentType, TLiwVariant( KHsPublisher ));

	cpdatamap->InsertL( KContentId, TLiwVariant( contentId ));		

	cpdatamap->InsertL( KActionTrigger, TLiwVariant( KActive ));

	TLiwGenericParam filter( KFilter, TLiwVariant( cpdatamap ));

	inParam->AppendL( filter );

	mServiceInterface->ExecuteCmdL( _L8("ExecuteAction"),

		*inParam, *outParam );

	CleanupStack::PopAndDestroy( cpdatamap );

	filter.Reset();

	type.Reset();	

	inParam->Reset();

	return outParam;

	}

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

// 

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

//

CLiwGenericParamList* CTestHspApi::ExecuteActionSelectedL( std::string& aContentType, 

		std::string& aIdentifier, std::string& aWidgetName )

	{

	TBool res( EFalse );

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

	// register for notification

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

	CLiwGenericParamList* inParam = &(mServiceHandler->InParamListL());

	CLiwGenericParamList* outParam = &(mServiceHandler->OutParamListL());

	CLiwDefaultMap* reqFilter = CLiwDefaultMap::NewLC();

	//reqFilter->InsertL( KPublisherId, TLiwVariant( KHSPPublisher ));

	reqFilter->InsertL( KPublisherId, TLiwVariant( KAll ));

	reqFilter->InsertL( KContentType, TLiwVariant( KAll ));

	reqFilter->InsertL( KContentId, TLiwVariant( KAll ));

	//reqFilter->InsertL( KOperation, TLiwVariant( KOperationExecute ));

	inParam->AppendL(TLiwGenericParam(KType, TLiwVariant(KContentAndPublisher_Registry)));

	inParam->AppendL(TLiwGenericParam(KFilter, TLiwVariant(reqFilter)));

	mServiceInterface->ExecuteCmdL( KRequestNotification,

		*inParam, *outParam, 0, this );

	outParam->Reset();

	inParam->Reset();

	CleanupStack::PopAndDestroy( reqFilter );

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

	// execute action

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

	TLiwGenericParam type(KType, TLiwVariant(KPublisher));

	inParam->AppendL(type);

	CLiwDefaultMap* cpdatamap = CLiwDefaultMap::NewLC();

	TPtrC8 contentType = ((TUint8*)aContentType.c_str());

	const TInt KSAPIContentNameMaxLength = 255;

	TBuf8<KSAPIContentNameMaxLength> contentId;

	contentId.Format( KContentIdFormat,

		((TUint8*)aIdentifier.c_str()), 

		((TUint8*)aWidgetName.c_str()) );

	cpdatamap->InsertL( KPublisherId, TLiwVariant( KHsWidgetPublisher ));

	cpdatamap->InsertL( KContentType, TLiwVariant( KHsPublisher ));

	cpdatamap->InsertL( KContentId, TLiwVariant( contentId ));		

	cpdatamap->InsertL( KActionTrigger, TLiwVariant( KSelected ));

	TLiwGenericParam filter( KFilter, TLiwVariant( cpdatamap ));

	inParam->AppendL( filter );

	mServiceInterface->ExecuteCmdL( _L8("ExecuteAction"),

		*inParam, *outParam );

	CleanupStack::PopAndDestroy( cpdatamap );

	filter.Reset();

	type.Reset();	

	inParam->Reset();

	return outParam;

	}

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

//

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

//

void CTestHspApi::WaitL(TInt aMicroSec)

   {

   CWaitActive* wait = CWaitActive::NewL();

    wait->Wait(aMicroSec);

    delete wait;

   }

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

// 

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

//

MLiwInterface* CTestHspApi::GetServiceInterfaceL()

	{

	CLiwGenericParamList* inParam = CLiwGenericParamList::NewL();

	CleanupStack::PushL( inParam );

	CLiwGenericParamList* outParam = CLiwGenericParamList::NewL();

	CleanupStack::PushL( outParam );

//	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL( KLiwCmdAsStr, 

//		KCPInterface, KCPService );

	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL( KLiwCmdAsStr, 

			_L8("IContentPublishing"), KCPService );

	crit->SetServiceClass( TUid::Uid(KLiwClassBase) );

	RCriteriaArray a;

	a.AppendL(crit);    

	mServiceHandler->AttachL(a);

	mServiceHandler->ExecuteServiceCmdL( *crit, *inParam, *outParam ); 

	delete crit;

	a.Reset();

	// find service interface

	TInt pos = 0;

	MLiwInterface* msgInterface = NULL;

	//outParam->FindFirst( pos, KCPInterface );

	outParam->FindFirst( pos, _L8("IContentPublishing") );

	if ( pos != KErrNotFound ) 

	    {

	    msgInterface = (*outParam)[pos].Value().AsInterface(); 

	    }

	outParam->Reset();

	inParam->Reset();

	CleanupStack::PopAndDestroy( outParam );

	CleanupStack::PopAndDestroy( inParam );

	return msgInterface;

	}

// from Observer interface

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

// 

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

//

void CTestHspApi::handleItemEvent( std::string aWidgetName, std::string aTemplateItemName,

		IHsDataObserver::EItemEvent aAction )

	{

	TPtrC8 itemName = ((TUint8*)aTemplateItemName.c_str());

	iItemActionStatus = KErrNone;

	}

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

// 

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

//

void CTestHspApi::handleEvent( std::string aWidgetName,

		IHsDataObserver::EEvent aAction )

	{

	TPtrC8 widgetName = ((TUint8*)aWidgetName.c_str());

	iActionStatus = KErrNone;

	}

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

// 

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

//

TInt CTestHspApi::TestHspApiConstrL( CStifItemParser& aItem )

    {

    Hs::HsWidgetPublisher* mHSPApi = new Hs::HsWidgetPublisher(this);

    if ( mHSPApi )

    	{

    	delete mHSPApi;

    	return KErrNone;

    	}

    else

    	{

    	return KErrGeneral;

    	}

    }

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

// 

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

//

void CTestHspApi::AddTemplate( Hs::HsWidgetPublisher* aHspApi, std::string& aContentType, 

		std::string& aIdentifier, std::string& aWidgetName )

	{

	Hs::HsWidget& templ = aHspApi->createHsWidget( aContentType, aWidgetName, aIdentifier);

	std::string itemName1( "item_name_1" );

	std::string itemValue1( "myimage1_image" );

	templ.setItem( itemName1, itemValue1 );

	std::string itemName2( "item_name_2" );

	templ.setItem( itemName2, 1 );

	std::string itemName3( "item_name_3" );

	std::string itemValue3( "value_3" );

	templ.setItem( itemName3, itemValue3 );

	templ.setItem( itemName2, 1 );

	templ.setItem( itemName2, itemValue3 );

	SendFakeActivateEvent( aIdentifier );

	WaitL( 1000000 );

	aHspApi->publishHsWidget( templ );

	}

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

// 

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

//

void CTestHspApi::SendFakeActivateEvent( std::string& aIdentifier )

    {