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

/**
 @file
 @internalTechnology
 @released
*/

#if !defined(__SS_FLOWREQUESTSTATES_H__)
#define __SS_FLOWREQUESTSTATES_H__

#include <comms-infras/ss_coreprstates.h>
#include <comms-infras/ss_corepractivities.h>
#include "ss_nodemessages_dataclient.h"

#include "ss_flowrequest.h"

#include <elements/nm_messages_child.h>


#ifdef _DEBUG
// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module
// (if it could happen through user error then you should give it an explicit, documented, category + code)
_LIT(KSpecAssert_ESocksflwrqststs, "ESocksflwrqststs");
#endif

namespace ESock
{
	class CFlowRequest;
}

namespace FlowRequestStates
{

typedef MeshMachine::TNodeContext<ESock::CFlowRequest, CoreStates::TContext> TContext;
typedef MeshMachine::TNodeContext<ESock::CImplicitFlowRequest, FlowRequestStates::TContext> TImplicitContext;


//
//Implicit and common

DECLARE_SMELEMENT_HEADER( TAwaitingImplicitFlowRequest, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )
	virtual TBool Accept();
DECLARE_SMELEMENT_FOOTER( TAwaitingImplicitFlowRequest )

DECLARE_SMELEMENT_HEADER( TAwaitingConnFlowRequest, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )
	virtual TBool Accept();
DECLARE_SMELEMENT_FOOTER( TAwaitingConnFlowRequest )

DECLARE_SMELEMENT_HEADER( TAwaitingSubConnFlowRequest, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )
	virtual TBool Accept();
DECLARE_SMELEMENT_FOOTER( TAwaitingSubConnFlowRequest )

DECLARE_SMELEMENT_HEADER( TRequestCSRCreation, MeshMachine::TStateTransition<TImplicitContext>, NetStateMachine::MStateTransition, TImplicitContext )
	virtual void DoL();
DECLARE_SMELEMENT_FOOTER( TRequestCSRCreation )

DECLARE_SMELEMENT_HEADER( TSelectMetaPlane, MeshMachine::TStateTransition<TImplicitContext>, NetStateMachine::MStateTransition, TImplicitContext )
	virtual void DoL();
DECLARE_SMELEMENT_FOOTER( TSelectMetaPlane )

DECLARE_SMELEMENT_HEADER( TJoinReceivedSCpr, MeshMachine::TStateTransition<TImplicitContext>, NetStateMachine::MStateTransition, TImplicitContext )
	virtual void DoL();
DECLARE_SMELEMENT_FOOTER( TJoinReceivedSCpr )

DECLARE_SMELEMENT_HEADER( TRequestCommsBinderFromSCpr, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )
	virtual void DoL();
DECLARE_SMELEMENT_FOOTER( TRequestCommsBinderFromSCpr )

DECLARE_SMELEMENT_HEADER( TRemoveRequestor, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )
	virtual void DoL();
DECLARE_SMELEMENT_FOOTER( TRemoveRequestor )

DECLARE_SMELEMENT_HEADER( TSendNoBearer, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )
	virtual void DoL();
DECLARE_SMELEMENT_FOOTER( TSendNoBearer )

DECLARE_SMELEMENT_HEADER( TJoinSubConnection, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )
	virtual void DoL();
DECLARE_SMELEMENT_FOOTER( TJoinSubConnection )

DECLARE_SMELEMENT_HEADER( TForwardBindToMsgToOriginator, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )
	virtual void DoL();
DECLARE_SMELEMENT_FOOTER( TForwardBindToMsgToOriginator )

DECLARE_SMELEMENT_HEADER( TLeaveSubConnection, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )
	virtual void DoL();
DECLARE_SMELEMENT_FOOTER( TLeaveSubConnection )

DECLARE_SMELEMENT_HEADER( TSendClientLeavingAndRemoveControlProvider, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )
	virtual void DoL();
DECLARE_SMELEMENT_FOOTER( TSendClientLeavingAndRemoveControlProvider )


//
//Cpr specific
DECLARE_SMELEMENT_HEADER( TJoinCpr, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )
	virtual void DoL();
DECLARE_SMELEMENT_FOOTER( TJoinCpr )

//
//SCpr specific
DECLARE_SMELEMENT_HEADER( TJoinSCpr, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )
	virtual void DoL();
DECLARE_SMELEMENT_FOOTER( TJoinSCpr )

} //namespace FlowRequestStates


namespace FlowRequestActivities
{

class CFlowRequestActivity : public MeshMachine::CNodeActivityBase, public CoreActivities::ABindingActivity,
                             public ITFHIERARCHY_1(CFlowRequestActivity, CoreActivities::ABindingActivity)
	{
public:
	typedef ITFHIERARCHY_1(CFlowRequestActivity, CoreActivities::ABindingActivity) TIfStaticFetcherNearestInHierarchy;

public:
    static MeshMachine::CNodeActivityBase* NewL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode)
    	{
		return new (ELeave) CFlowRequestActivity(aActivitySig,aNode);
    	}

	void ReturnInterfacePtrL(CoreActivities::ABindingActivity*& aInterface)
		{
		aInterface = this;
		}

protected:
	CFlowRequestActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode)
	:MeshMachine::CNodeActivityBase(aActivitySig, aNode),
	 ABindingActivity(aNode.Id()),
	 TIfStaticFetcherNearestInHierarchy(this)
		{
		}

	virtual ~CFlowRequestActivity()
		{
		if( !iBindToSender.IsNull() )
		    {
		    TInt err = Error() ? Error() : KErrAbort;
		    Messages::RNodeInterface::OpenPostMessageClose(Messages::TNodeCtxId(ActivityId(), iNode.Id()),
		            iBindToSender, Messages::TEBase::TError(ESock::TCFDataClient::TBindToComplete::Id(), err).CRef());
		    }
		
		static_cast<ESock::CFlowRequest&>(iNode).iFlowParameters.Close();
		__ASSERT_DEBUG(iNode.CountAllActivities()==0, User::Panic(KSpecAssert_ESocksflwrqststs, 1));
#ifndef __GCCXML__
		Messages::RNodeInterface::OpenPostMessageClose(Messages::TNodeCtxId(ActivityId(), iNode.Id()),
			iNode.Id(), Messages::TEChild::TDestroy().CRef());
#endif
		}
	
public:
    /* A node that has sent TCFDataClient::TBindTo. The response TCFDataClient::TBindToComplete
     * must be sent to this node. 
     */ 
    Messages::TNodeCtxId iBindToSender;

public:
	typedef MeshMachine::TNodeContext<ESock::CFlowRequest, CoreStates::TContext> TContext;
	
DECLARE_SMELEMENT_HEADER( TAwaitingBindTo, MeshMachine::TState<TContext>, NetStateMachine::MState, TContext )
    virtual TBool Accept();
DECLARE_SMELEMENT_FOOTER( TAwaitingBindTo )
	
DECLARE_SMELEMENT_HEADER( TStoreFlowParams, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )
	virtual void DoL();
DECLARE_SMELEMENT_FOOTER( TStoreFlowParams )

DECLARE_SMELEMENT_HEADER( TSendBindToComplete, MeshMachine::TStateTransition<TContext>, NetStateMachine::MStateTransition, TContext )
    virtual void DoL();
DECLARE_SMELEMENT_FOOTER( TSendBindToComplete )
	};

class CFlowRequestDestroyActivity : public MeshMachine::CNodeActivityBase, protected MeshMachine::APreallocatedOriginators<1>
	{
public:
    static MeshMachine::CNodeActivityBase* New(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode)
    	{
		TAny* space = BorrowPreallocatedSpace(aNode, sizeof(CFlowRequestDestroyActivity));
		CFlowRequestDestroyActivity* self = new (space) CFlowRequestDestroyActivity(aActivitySig, aNode);
		self->InsertPreallocatedDestroyActivity(); //Destructing preallocated activity
		return self;
	   	}

protected:
	CFlowRequestDestroyActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode)
	:MeshMachine::CNodeActivityBase(aActivitySig, aNode),
	MeshMachine::APreallocatedOriginators<1>(iOriginators)
		{
		}

	void Destroy()
		{
		ReturnPreallocatedSpace(this);
		this->~CFlowRequestDestroyActivity(); //Run the destructor

		delete &static_cast<ESock::CFlowRequest&>(iNode);
		}

private:
	/*
	Private NewL with no implementation to hide the CNodeActivityBase::NewL
	Creation of preallocated activities doesn't fail and hence a non-leaving ::New should be used instead*/
    static MeshMachine::CNodeActivityBase* NewL(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode);
	};


} //namespace FlowRequestActivities


#endif
// __SS_FLOWREQUESTSTATES_H__