// Copyright (c) 2008-2009 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:
//

//System Includes
#include <comms-infras/ss_log.h>
#include <comms-infras/ss_logext.h>

#include <http/thttptable.h>
#include <inetprottextutils.h>
#include <upnpdescriptionschema.h>
#include <rmemchunk.h>
#include <rmemcell.h>
//Local Includes
#include "upnpservicedeftscprstates.h"
#include "upnp_cf_msgs.h"
#include "upnpstatemachine.h"
#include "upnpserverconstants.h"
#include "upnplog.h"
using namespace UPnPServiceDefaultStates;
using namespace ESock;


//-=========================================================
//
//States
//
//-=========================================================

//-=========================================================
//
//Transitions
//
//-=========================================================
DEFINE_SMELEMENT ( TStoreUdpServer, NetStateMachine::MStateTransition, TContext )
void TStoreUdpServer::DoL ( )
	{
	TCFFactory::TPeerFoundOrCreated &msg = message_cast<TCFFactory::TPeerFoundOrCreated> ( iContext.iMessage );
	iContext.Node ( ).SetUdpServerFlow ( msg.iNodeId );
	}


DEFINE_SMELEMENT ( TStoreUdpClient, NetStateMachine::MStateTransition, TContext )
void TStoreUdpClient::DoL ( )
	{
	TCFFactory::TPeerFoundOrCreated &msg = message_cast<TCFFactory::TPeerFoundOrCreated> ( iContext.iMessage );
	iContext.Node ( ).SetUdpClientFlow ( msg.iNodeId );
	}

DEFINE_SMELEMENT ( TBuildPublishAndRootDeviceInfo, NetStateMachine::MStateTransition, TContext )
void TBuildPublishAndRootDeviceInfo::DoL ( )
	{
	if ( iContext.Node ( ).PublishInfo ( ) )
		{
		return;
		}
	
	TUpnpMessage::TRegisterRootDevice& msg = message_cast< TUpnpMessage::TRegisterRootDevice > ( iContext.iMessage );
	CUPnPDevice* device = static_cast <CUPnPDevice*> ( msg.iPtr );
	
	CStringPoolManager& stringPoolMgr = iContext.Node ().ConnectionProvider ().StringPoolManager ();
	RStringPool& sp = stringPoolMgr.StringPool ( );
	const TStringTable& upnpTable = stringPoolMgr.GetUPnPTable();
	CUPnPPublishInfoElement* publishInfo = CUPnPPublishInfoElement::NewL ( );
    CleanupStack::PushL ( publishInfo );
    
    publishInfo->SetKeyL( iContext.Node ().ConnectionProvider ().RootDeviceLocation () );
    publishInfo->SetSearchTargetL( KRootDevice ( ) ); //upnp:rootdevice
	publishInfo->SetCacheControlL( KCacheControl );
	
	const TDesC8& udnPtr = device->Property( sp.String ( UPNPDESCRIPTIONXMLTAGS::EUdn, upnpTable ) );
	const TDesC8& deviceTypePtr = device->Property( sp.String(UPNPDESCRIPTIONXMLTAGS::EDeviceType,upnpTable ) );
	
	publishInfo->SetUuidL ( udnPtr );
	
	// Set Usn to udn + devicetype
	TInt len = udnPtr.Length ( ) + KSeperator.iTypeLength + deviceTypePtr.Length ( );	
	RBuf8 tempBuf;
	tempBuf.CreateMaxL ( len );
	CleanupClosePushL ( tempBuf );
	
	tempBuf.Copy ( udnPtr );
	tempBuf.Append ( KSeperator ( ) );
	tempBuf.Append ( deviceTypePtr );
	publishInfo->SetUsnL( tempBuf );
		
	iContext.Node ( ).SetPublishInfoL ( publishInfo );
	// store deviceType in SCPr node for reference in M-Search Response Activity
	iContext.Node ( ).SetRootDeviceUrnL ( deviceTypePtr );
	
	CleanupStack::PopAndDestroy ( &tempBuf );
	CleanupStack::Pop ( publishInfo );	
	}


DEFINE_SMELEMENT ( TSendPublishRequest, NetStateMachine::MStateTransition, TContext )
void TSendPublishRequest::DoL ( )
	{
	CUPnPPublishInfoElement* publishInfo = iContext.Node ( ).PublishInfo ( );
	
	// Publish once for upnp:rootdevice::uuid:device-UUID
	DoPublishL ( publishInfo->SearchTarget ( ), iContext.Node ( ).RootDeviceUsn ( ), publishInfo->CacheControl ( ) );
		
	// Publish once for uuid:device-UUID
	DoPublishL ( publishInfo->Uuid ( ), publishInfo->Uuid ( ), publishInfo->CacheControl ( ) );
		
	// Publish once for uuid:device-UUID::urn:domain-name-device:deviceType:v	
	DoPublishL ( iContext.Node ( ).RootDeviceUrn ( ), publishInfo->Usn ( ), publishInfo->CacheControl ( ) );
		
	iContext.Node ( ).SetRootDevicePublished ( ETrue );
	}
	
void TSendPublishRequest::DoPublishL ( const TDesC8& aSearchTarget, const TDesC8& aUsn, TInt aMaxAge )
	{
	RMemoryAllocator allocator = iContext.Node ( ).ConnectionProvider().MemoryAllocator();
	
	RMemChunk locationBuf;
	locationBuf.CreateL ( iContext.Node ().ConnectionProvider ().RootDeviceLocation (), allocator );
	
	RMemChunk stBuf;
	stBuf.CreateL ( aSearchTarget, allocator );	
	TCleanupItem item ( &UPnPStateMachine::CUPnPUtils::CleanupMBufChain, &stBuf );
	CleanupStack::PushL ( item );
	
	RMemChunk usnBuf;
	usnBuf.CreateL ( aUsn, allocator );
	
	TSsdpInfo ssdpInfo ( aMaxAge, locationBuf, usnBuf, stBuf );
	
	TUpnpMessage::TUPnPPublishAliveRequest publishMsg ( ssdpInfo );			
	RClientInterface::OpenPostMessageClose ( iContext.NodeId (), iContext.Node ().UdpClientFlow (), publishMsg );
	
	CleanupStack::Pop ( ); // item
	}


DEFINE_SMELEMENT ( TRegisterRootDeviceWithMuServer, NetStateMachine::MStateTransition, TContext )
void TRegisterRootDeviceWithMuServer::DoL ( )
	{
	CUPnPPublishInfoElement* publishInfo = iContext.Node ( ).PublishInfo ( );
	
	// Register once for upnp:rootdevice
	RegisterForMSearchL ( publishInfo->SearchTarget ( ) );
	
	// Register once for uuid:device-UUID
	RegisterForMSearchL ( publishInfo->Uuid ( ) );
	
	// Register once for uuid:device-UUID::urn:domain-name-device:deviceType:v
	RegisterForMSearchL ( iContext.Node ( ).RootDeviceUrn ( ) );
	}
	
void TRegisterRootDeviceWithMuServer::RegisterForMSearchL ( const TDesC8& aSearchTarget )
	{
	RMemoryAllocator allocator(iContext.Node ( ).ConnectionProvider().MemoryManager());
	RMemChunk stBuf;
	stBuf.CreateL ( aSearchTarget, allocator );
	
	TSsdpInfo ssdpInfo ( stBuf );
	
	TUpnpMessage::TUPnPPublishRegistration msg ( ssdpInfo );
	RClientInterface::OpenPostMessageClose ( TNodeCtxId ( MeshMachine::KActivityNull, iContext.NodeId () ), iContext.Node ().UdpServerFlow (), msg );
	}
	

DEFINE_SMELEMENT ( TStartMuClient, NetStateMachine::MStateTransition, TContext )
void TStartMuClient::DoL ( )
	{
	iContext.iNodeActivity->PostRequestTo ( iContext.Node ().UdpClientFlow (), TCFDataClient::TStart ().CRef () );
	}

DEFINE_SMELEMENT ( TStartMuServer, NetStateMachine::MStateTransition, TContext )
void TStartMuServer::DoL ( )
	{	
	iContext.iNodeActivity->PostRequestTo ( iContext.Node ().UdpServerFlow (), TCFDataClient::TStart ().CRef () );
	}
	
DEFINE_SMELEMENT ( TSendRootDeviceRegistered, NetStateMachine::MStateTransition, TContext )
void TSendRootDeviceRegistered::DoL ( )
	{
	TUpnpMessage::TRootDeviceRegistered msg ( iContext.iNodeActivity->Error( ) );
	RClientInterface::OpenPostMessageClose ( iContext.NodeId (), iContext.Node ().ControlProvider ()->RecipientId (), msg );
	}


DEFINE_SMELEMENT ( TSendSearchResponse, NetStateMachine::MStateTransition, TContext )
void TSendSearchResponse::DoL ( )
	{	
	if ( !iContext.Node ( ).RootDevicePublished ( ) )
		{
		return;		
		}
	
	TUpnpMessage::TUPnPSearchRequest& reqMsg = message_cast< TUpnpMessage::TUPnPSearchRequest > ( iContext.iMessage );
		
	RMemCell* mBuf = reqMsg.iSsdpInfo.iSearchTarget.First ( );
	TPtr8 stPtr ( mBuf->Ptr( ), mBuf->Length( ), mBuf->Length( ) );
		
	CUPnPPublishInfoElement* publishInfo = iContext.Node ( ).PublishInfo ( );
		
	if ( stPtr.CompareF ( publishInfo->SearchTarget ( ) ) == 0 )
		{
		// Search Response for upnp:rootdevice::uuid:device-UUID
		SendSearchResponseL ( publishInfo->SearchTarget ( ), iContext.Node ( ).RootDeviceUsn ( ), publishInfo->CacheControl ( ) );
		}
	else if ( stPtr.CompareF ( publishInfo->Uuid ( ) ) == 0 )
		{
		// Search Response for uuid:device-UUID
		SendSearchResponseL ( publishInfo->Uuid ( ), publishInfo->Uuid ( ), publishInfo->CacheControl ( ) );
		}
	else
		{
		// Search Response for uuid:device-UUID::urn:domain-name-device:deviceType:v		
		SendSearchResponseL ( stPtr, publishInfo->Usn ( ), publishInfo->CacheControl ( ) );
		}
	reqMsg.iSsdpInfo.iSearchTarget.Free ( );
	}

void TSendSearchResponse::SendSearchResponseL ( const TDesC8& aSearchTarget, const TDesC8& aUsn, TInt aMaxAge )
	{		
	TUpnpMessage::TUPnPSearchRequest& reqMsg = message_cast< TUpnpMessage::TUPnPSearchRequest > ( iContext.iMessage );	
	TAppProtAddr remoteUnicastAddr = reqMsg.iSsdpInfo.iAddr;
	RMemoryAllocator allocator = iContext.Node ( ).ConnectionProvider().MemoryAllocator();
	
	RMemChunk locationBuf;
	locationBuf.CreateL ( iContext.Node ().ConnectionProvider ().RootDeviceLocation (), allocator );
	TCleanupItem item ( &UPnPStateMachine::CUPnPUtils::CleanupMBufChain, &locationBuf );
	CleanupStack::PushL ( item );

	RMemChunk stBuf;
	stBuf.CreateL ( aSearchTarget, allocator );
	TCleanupItem item1 ( &UPnPStateMachine::CUPnPUtils::CleanupMBufChain, &stBuf );
	CleanupStack::PushL ( item1 );

	RMemChunk usnBuf;
	usnBuf.CreateL ( aUsn, allocator );
	
	TSsdpInfo ssdpInfo ( aMaxAge,
						locationBuf,
						usnBuf,
						stBuf,
						remoteUnicastAddr );
	
	TUpnpMessage::TUPnPSearchResponse msg ( ssdpInfo );
	RClientInterface::OpenPostMessageClose ( iContext.NodeId (), iContext.Node ().UdpClientFlow (), msg );
	
	CleanupStack::Pop ( ); // item
	CleanupStack::Pop ( ); // item1
	}


DEFINE_SMELEMENT ( TProcessDataClientStop, NetStateMachine::MStateTransition, TContext )
void TProcessDataClientStop::DoL ( )
	{
	CUPnPPublishInfoElement* publishInfo = iContext.Node ( ).PublishInfo ( );
	
	if ( publishInfo && iContext.Node ( ).RootDevicePublished ( ) )
		{
		// for upnp:rootdevice::uuid:device-UUID
		SendByeRequestL ( publishInfo->SearchTarget ( ), iContext.Node ( ).RootDeviceUsn ( ) );
			
		// for uuid:device-UUID
		SendByeRequestL ( publishInfo->Uuid ( ), publishInfo->Uuid ( ) );
		
		// for uuid:device-UUID::urn:domain-name-device:deviceType:v
		SendByeRequestL ( iContext.Node ( ).RootDeviceUrn ( ), publishInfo->Usn ( ) );
		
		iContext.Node ( ).SetRootDevicePublished ( EFalse );		
		}

	// StopDataClients
	iContext.Node().PostToClients<TDefaultClientMatchPolicy> ( TNodeCtxId ( iContext.ActivityId (), iContext.NodeId () ),
									TCFDataClient::TStop ( KErrNone ).CRef (), TClientType ( TCFClientType::EData, TCFClientType::EStarted ) );
	iContext.iNodeActivity->SetPostedTo( TNodeId::NullId ( ) );
	
	return;
	}

void TProcessDataClientStop::SendByeRequestL ( const TDesC8& aSearchTarget, const TDesC8& aUsn )
	{
	RMemoryAllocator allocator = iContext.Node ( ).ConnectionProvider().MemoryAllocator();
	
	RMemChunk stBuf;
	stBuf.CreateL ( aSearchTarget, allocator );
	TCleanupItem item ( &UPnPStateMachine::CUPnPUtils::CleanupMBufChain, &stBuf );
	CleanupStack::PushL ( item );

	RMemChunk usnBuf;
	usnBuf.CreateL ( aUsn, allocator );
	
	TSsdpInfo ssdpInfo ( usnBuf, stBuf );
	TUpnpMessage::TUPnPPublishByeRequest msg ( ssdpInfo );
	RClientInterface::OpenPostMessageClose ( iContext.NodeId (), iContext.Node ().UdpClientFlow (), msg );
	
	CleanupStack::Pop ( ); // item
	}
	
DEFINE_SMELEMENT ( TLeaveRequest, NetStateMachine::MStateTransition, TContext )
void TLeaveRequest::DoL ( )
	{
	TUint ccCount = iContext.Node ().CountClients<TDefaultClientMatchPolicy> ( TClientType ( TCFClientType::ECtrl ) );
		
	// -- If control client goes zero and the node is not having any pending activities
	// then process the data client stop,  
	// mark the default SCPR node for deletion and close it.
	if ( ccCount == 0 )
		{
		iContext.Node ( ).SetClosing ( );		
		}
	}
	
DEFINE_SMELEMENT ( TNoTagOrDataClientIdle, NetStateMachine::MStateFork, TContext )
TInt TNoTagOrDataClientIdle::TransitionTag ( )
	{
	return iContext.Node ( ).IsClosing ( ) ? CoreNetStates::KDataClientIdle : MeshMachine::KNoTag;
	}	


DEFINE_SMELEMENT ( TRequestOrIgnoreTag, NetStateMachine::MStateFork, TContext )
TInt TRequestOrIgnoreTag::TransitionTag ( )
	{
	if ( iContext.Node ( ).IsClosing ( ) )
		{
		return CoreStates::KIgnore;
		}
	
	TUpnpMessage::TUPnPRequestInfo& requestInfoMsg = message_cast<TUpnpMessage::TUPnPRequestInfo> ( iContext.iMessage );	
	CTransaction* transaction = static_cast<CTransaction*> ( requestInfoMsg.iPtr );	
	const RStringF& header =  transaction->Request( )->Handle( ).Method ( );

	__ASSERT_DEBUG ( header == transaction->Request( )->StringPool ( ).StringF ( HTTP::EGET, THTTPTable::Table() ), User::Invariant () );
	
	const TDesC8& uriPath =  transaction->Request()->URI()->Uri().Extract ( EUriPath);
	_LIT8 ( KRootPath, "/" );
	if ( uriPath.Compare ( KRootPath ) == 0 )
		{
		return UPnPStateMachine::KDescribeRequest;
		}
	else
		{
		return UPnPStateMachine::KIconRequest;
		}
	}


DEFINE_SMELEMENT ( TNoTagOrIgnoreTag, NetStateMachine::MStateFork, TContext )
TInt TNoTagOrIgnoreTag::TransitionTag ( )
	{
	return iContext.Node ( ).IsClosing ( ) ? CoreStates::KIgnore : MeshMachine::KNoTag;
	}