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

*/

#include "mm_activities.h"

#include <elements/mm_context.h>

#include <elements/mm_states.h>

#include <elements/nm_messages_base.h>

#include <elements/nm_messages_child.h>

#include <elements/nm_messages_errorrecovery.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_ElemMeshMachActC, "ElemMeshMachActC");

#endif

using namespace MeshMachine;

using namespace Messages;

using namespace Elements;

using namespace NetStateMachine;

//-=========================================================

//

//TNodeActivityIter

//

//-=========================================================

const TNodeActivity* TNodeActivityIter::FetchActivity()

	{

    const TNodeActivity* a = NULL;

    if (*iCurrentEntry)

    	{

    	a = &(*iCurrentEntry)();

    	++iCurrentEntry;

    	}

    else

    	{

    	if (NULL!=*(iCurrentEntry+1))

 		   	{

    		const TNodeActivityMap::TStaticNodeActivityMap& nextMapFn = (const TNodeActivityMap::TStaticNodeActivityMap&)*(iCurrentEntry+1);

    		iCurrentEntry = &nextMapFn().iFirstActivity;

    		a = FetchActivity();

    		}

    	}

    return a;

	}

//-=========================================================

//

//CNodeActivityBase

//

//-=========================================================

EXPORT_C CNodeActivityBase* CNodeActivityBase::NewL(const TNodeActivity& aActivitySig, AMMNodeBase& aNode)

    {

    return new(ELeave)CNodeActivityBase(aActivitySig, aNode);

    }

EXPORT_C CNodeActivityBase::CNodeActivityBase(const TNodeActivity& aActivitySig, AMMNodeBase& aNode)

:	iNode(aNode),

	iActivitySig(aActivitySig)

	{

	}

EXPORT_C CNodeActivityBase::~CNodeActivityBase()

	{

	if(iError != KErrNone)

		{

		PostToOriginators(TEBase::TError(KickOffMessageId(), iError).CRef());

		}

	//If an activity constructed custom originator's interfaces, now it needs to clean them up

	for (TInt i = iOriginators.Count() - 1; i >= 0; --i)

		{

		RemoveOriginator(i);

		}

	iOriginators.Close();

	}

EXPORT_C NetInterfaces::TInterfaceControl* CNodeActivityBase::DoFetchInterfaceControlL(TInt /*aInterfaceId*/)

/** Allows to fetch an arbitrary interface instance from the client

@internalTechnology

*/

	{

	return this; //as a base we assume are the control for any interface any derivative may implement

	}

//static

const TStateTriple* CNodeActivityBase::Accept(TNodeContextBase& aContext, const TNodeActivity& aActivitySig, TInt aTransitionTag)

    {

    const TStateTriple& first = aActivitySig.iFirstTriple;

    //in debug only(!) check if we are in the first triple as expected

    __ASSERT_DEBUG((&first-1)->iSCtor==NULL && (&first-1)->iTCtor==NULL, User::Panic(KSpecAssert_ElemMeshMachActC, 1));

    TBool accept = (aActivitySig.iKickOffMessageId == KNullMessageId

		|| (aActivitySig.iKickOffMessageId == aContext.iMessage.MessageId().MessageId() &&

			aActivitySig.iKickOffMessageRealm == aContext.iMessage.MessageId().Realm())

		)

    	&& NetStateMachine::ACore::Accept(first, &aContext, aTransitionTag);

    //if the activity accepted the message and the first triple has a transition, we execute it here

    //NOTE that the first transition is called BEFORE the originator (sender of the message)

    //is added to the activity list

    if (accept && first.iTCtor)

    	{

    	TBuf8<KMaxStateClassByteSize> mem;

   		ACore::Do(first,&aContext,mem);

   		MESH_LOG((KMeshMachineSubTag, _L8("CNodeActivityBase:\tAccept->first transition [ANode=0x%08x] [Activity=%s] [Triple=%s]"),

   				&aContext.NodeId().Node(), aActivitySig.iName ? aActivitySig.iName : _S8("Undefined"), first.iName? first.iName : _S8("Undefined")));

    	}

	if (accept && aContext.iReturn == KErrNone)

		{

		// MESH_LOG((KMeshMachineSubTag, _L8("CNodeActivityBase:\tAccept->accepted")));

		return &first;

		}

    return NULL;

    }

EXPORT_C void CNodeActivityBase::StartL(TNodeContextBase& aContext, const XNodePeerId& aOriginator, const TStateTriple& aFirst)

	{

	__ASSERT_DEBUG(FindOriginator(aOriginator) == KErrNotFound, User::Panic(KSpecAssert_ElemMeshMachActC, 2));

  	iOriginators.AppendL(aOriginator);

	MESH_LOG_ACTIVITY_EXT(KMeshMachineSubTag, this, &aContext, (_L8("CNodeActivityBase %08x:\tStartL->starting activity"), this));

	if (IsIdle())

		{

		NetStateMachine::ACore::Start(&aContext, aFirst);

		MESH_LOG_ACTIVITY_EXT(KMeshMachineSubTag, this, &aContext, (_L8("CNodeActivityBase %08x:\tStartL->activity started"), this));

		}

	}

EXPORT_C TBool CNodeActivityBase::MatchSender(const TNodeContextBase& aContext) const

    {

    //The role of this method is to filter out all messages that 'this' should

    //not be bothered with. 'this' should be interested in messages coming from

    //what's set as iPostedToId or from one of the orginators. 

    //if the message's recipient specifies the activity id, then that

    //activity must much that of 'this'.

    TBool sender = PostedToNodeId().IsNull() || 

    			   aContext.iSender == PostedToNodeId() || 

    			   FindOriginator(aContext.iSender) != KErrNotFound;

    const TNodeCtxId* recipient = address_cast<const TNodeCtxId>(&aContext.iRecipient);

    TBool activity = (recipient == NULL || ActivityId() == recipient->NodeCtx());

#ifdef SYMBIAN_TRACE_ENABLE

	//If didn't match, trace why.

	if (!(sender && activity))

		{

		NM_LOG_START_BLOCK(KMeshMachineSubTag, _L8("CNodeActivityBase::MatchSender"));

		if(!sender)

			{

			MESH_LOG((KMeshMachineSubTag(), _L8("CNodeActivityBase %08x:\tiPostedToId mismatch:"), this));

			NM_LOG_ADDRESS(KMeshMachineSubTag(), PostedToNodeId());

			NM_LOG_ADDRESS(KMeshMachineSubTag(), aContext.iSender);

			MESH_LOG((KMeshMachineSubTag(), _L8("CNodeActivityBase %08x:\toriginators' mismatch:"), this));

			for (TInt i = iOriginators.Count() - 1; i>=0; i--)

		        {

		        NM_LOG_ADDRESS(KMeshMachineSubTag(), iOriginators[i].RecipientId());

		        }

			}

		if(!activity)

			{

			MESH_LOG((KMeshMachineSubTag(), _L8("CNodeActivityBase %08x:\tactivity mismatch [ours 0x%x, recipient 0x%x]"), this, ActivityId(), recipient->NodeCtx()));

			}

		NM_LOG_END_BLOCK(KMeshMachineSubTag(), KNullDesC8());

		}

#endif

    return sender && activity;

    }

//static

EXPORT_C TAny* CNodeActivityBase::BorrowPreallocatedSpace(AMMNodeBase& aNode, TUint aSize)

	{

	return aNode.BorrowPreallocatedSpace(aSize);

	}

EXPORT_C void CNodeActivityBase::ReturnPreallocatedSpace(TAny* aSpace)

	{

	return iNode.ReturnPreallocatedSpace(aSpace);

	}

EXPORT_C void CNodeActivityBase::AppendActivityL()

	{

	//Based on the fact that there can ever be only one preallocated activity active at a time

	//it is sufficient to always maintain one reserved space in the activity array.

	//NOTE: ReserveL() will not cause table expansion when the already allocated space is

	//big enough to hold the new count = the array will not grow indefinietly.

	iNode.iActivities.ReserveL(iNode.iActivities.Count() + iNode.MaxPreallocatedActivityCount() + 1); //Reserve for additional + potential preallocated)

	//Can not fail now

	__ASSERT_ALWAYS(iNode.iActivities.Append(this) == KErrNone, User::Panic(KMMActivityPanic, EPanicNoPreallocatedSpace));

	}

EXPORT_C void CNodeActivityBase::AppendPreallocatedActivity()

	{

	//Can not fail now

	__ASSERT_ALWAYS(iNode.iActivities.Append(this) == KErrNone, User::Panic(KMMActivityPanic, EPanicNoPreallocatedSpace));

	}

EXPORT_C void CNodeActivityBase::InsertPreallocatedDestroyActivity()

	{

	//Can not fail now

	__ASSERT_ALWAYS(iNode.iActivities.Insert(this, 0) == KErrNone, User::Panic(KMMActivityPanic, EPanicNoPreallocatedSpace));

	}

EXPORT_C TInt CNodeActivityBase::FindOriginator(const RNodeInterface& aPeerToFind) const

    {

	for (TInt i = iOriginators.Count() - 1; i>=0; i--)

        {

        //When you see a panic here this is probably because your originator

        //stopped being a peer and this node failed to remove it from the activity originator's list.

        if (iOriginators[i] == aPeerToFind.RecipientId())

            {

	        return i;

            }

        }

    return KErrNotFound;

    }

EXPORT_C TInt CNodeActivityBase::FindOriginator(const TRuntimeCtxId& aPeerToFind) const

    {

	for (TInt i = iOriginators.Count() - 1; i>=0; i--)

        {

        //When you see a panic here this is probably because your originator

        //stopped being a peer and this node failed to remove it from the activity originator's list.

        if (iOriginators[i] == aPeerToFind)

            {

	        return i;

            }

        }

    return KErrNotFound;

	}

EXPORT_C TInt CNodeActivityBase::FindOriginator(const TNodePeerId& aOriginator) const

	{

	for (TInt i = iOriginators.Count() - 1; i>=0; i--)

        {

        //When you see a panic here this is probably because your originator

        //stopped being a peer and this node failed to remove it from the activity originator's list.

        if (iOriginators[i] == aOriginator)

            {

	        return i;

            }

        }

    return KErrNotFound;

	}

EXPORT_C TUint16 CNodeActivityBase::ActivityId() const

	{

	return ActivitySigId();

	}

//You should use this function to remove originators to prevent memory leaking!

EXPORT_C void CNodeActivityBase::RemoveOriginator(TInt aIndex)

	{

	__ASSERT_DEBUG(aIndex>=0 && aIndex<iOriginators.Count(), User::Panic(KSpecAssert_ElemMeshMachActC, 3));

	iOriginators[aIndex].Destroy();

	iOriginators.Remove(aIndex);

	}

EXPORT_C void CNodeActivityBase::SetIdle()

	{

	MESH_LOG((KMeshMachineSubTag, _L8("CNodeActivityBase %08x:\tSetIdle"), this));

	NetStateMachine::ACore::SetIdle();

	}

EXPORT_C TBool CNodeActivityBase::Next(TNodeContextBase& aContext)

	{

	TBool nextRet = EFalse;

	//Check if this is the same id we have recently sent to

	TBool senderMatch = MatchSender(aContext);

	MESH_LOG_ACTIVITY_EXT(KMeshMachineSubTag, this, &aContext,

	    (senderMatch ? _L8("CNodeActivityBase %08x:\tNext->match") : _L8("CNodeActivityBase %08x:\tNext->NO match"), this));

	if (senderMatch)

		{

		nextRet = ACore::Next(&aContext);

	    if(nextRet)

			{

	    	MESH_LOG_ACTIVITY_EXT(KMeshMachineSubTag, this, &aContext, (_L8("CNodeActivityBase %08x:\tNext->transition"), this));

			}

		}

    return nextRet;

	}

EXPORT_C void CNodeActivityBase::Cancel(TNodeContextBase& aContext)

	{//we expect KErrCancel be set as a result of the state cancelation

    MESH_LOG((KMeshMachineSubTag, _L8("CNodeActivityBase %08x:\tCancel(), PostedToNodeId %08x"), this, PostedToNodeId().Ptr()));

	if ((PostedToPeer() && !(PostedToPeer()->Flags() & TClientType::ELeaving)) ||

	     PostedToNodeId() == aContext.Node().Id())

		{//only safe to forward TCancels to non-leavers or self. There is an underlying assumption that a node won't dissapear in presence of activities (see AMMNodeBase::~AMMNodeBase)

		RClientInterface::OpenPostMessageClose(TNodeCtxId(ActivityId(), iNode.Id()), PostedToNodeId(), TEBase::TCancel().CRef());

		}

    else

        {

    	NetStateMachine::ACore::Cancel(&aContext);

        }

	SetError(KErrCancel);

	}

EXPORT_C TBool CNodeActivityBase::PostToOriginator(const TNodePeerId& aOriginator, const TSignalBase& aMessage) const

	{

	if (!(aOriginator.Flags() & TClientType::ELeaving))

	    {

	    aOriginator.PostMessage(TNodeCtxId(ActivityId(), iNode.Id()), aMessage);

	    }

	else

		{

		MESH_LOG((KMeshMachineSubTag, _L8("CNodeActivityBase:\tPostToOriginator - IGNORING POST!")));

		return EFalse;

		}

	return ETrue;

	}

EXPORT_C TInt CNodeActivityBase::PostToOriginators(const TSignalBase& aMessage, TUint32 aFlagsToSet, TUint32 aFlagsToClear)

	{

	TInt msgSendCount=0;

	for (TInt n = iOriginators.Count() - 1;n>=0; n--)

		{

		if (PostToOriginator(iOriginators[n], aMessage))

			{

			++msgSendCount;

	    	iOriginators[n].SetFlags(aFlagsToSet);

	    	iOriginators[n].ClearFlags(aFlagsToClear);

			};

		}

	return msgSendCount;

	}

EXPORT_C void CNodeActivityBase::SetPostedTo(const TNodeId& aNodeId)

    {

    //You are being punished for storing a postedto TNodeId that you also know as your peer.

    //the Messages::RNodeInterface& overload of CNodeActivityBase::SetPostedTo

    //It is dangerous to use this overload for peers when the relation with these peers

    //is being terminated. the PostedTo facility is also used to forward TCancel in

    //the automatic calencallation handling. No message can be posted to a leaving peer

    //but only peers (Messages::RNodeInterfaces) can be recognised as leaving. 

    //

    //ASSERT temporarily commened out as it is a behavioural break. A Polonium BR

    //has been drafted and will be raised when the RNodeInterface overloads end up in the

    //codeline. http://polonium.ext.nokia.com/changerequests/cr/601/

    //__ASSERT_DEBUG(iNode.FindClient(aNodeId) == NULL, User::Panic(KSpecAssert_ElemMeshMachActC, 14));     

    if (aNodeId == Messages::TNodeId::NullId())

        {

        ClearPostedTo();

        return;

        }

    iPostedToId.Open(aNodeId);

    }

EXPORT_C void CNodeActivityBase::SetPostedTo(const Messages::RNodeInterface& aRecepient)

    {

    iPostedToId.Open(aRecepient);

    }

EXPORT_C void CNodeActivityBase::ClearPostedTo()

    {

    iPostedToId.Close();

    }

EXPORT_C const Messages::TNodeId& CNodeActivityBase::PostedToNodeId() const

    {

    return iPostedToId.NodeId();

    }

EXPORT_C const Messages::RNodeInterface* CNodeActivityBase::PostedToPeer() const

    {

    return iPostedToId.Peer();

    }

EXPORT_C void CNodeActivityBase::PostRequestTo(const RNodeInterface& aRecipient, const TSignalBase& aMessage, const TBool aRecipientIdCritical)

	{

	aRecipient.PostMessage(TNodeCtxId(ActivityId(), iNode.Id()), aMessage);

	// Provide the option for the identity of the receipient to be unimportant when the response arrives

	ClearPostedTo();

    if (aRecipientIdCritical)

        {

        SetPostedTo(aRecipient);

        }

	}

//Avoid using this function, always prefer PostRequestTo(const RNodeInterface& aRecipient, const TNodeSignal& aMessage)

EXPORT_C void CNodeActivityBase::PostRequestTo(const TNodeId& aRecipient, const TSignalBase& aMessage, const TBool aRecipientIdCritical)

	{

	RClientInterface::OpenPostMessageClose(TNodeCtxId(ActivityId(), iNode.Id()), aRecipient, aMessage);

	// Provide the option for the identity of the receipient to be unimportant when the response arrives

	ClearPostedTo();

	if (aRecipientIdCritical)

	    {

        SetPostedTo(aRecipient);

	    }

	}

EXPORT_C TBool CNodeActivityBase::IsIdle() const

	{

	return NetStateMachine::ACore::IsIdle();

	}

EXPORT_C void CNodeActivityBase::Abort(TNodeContextBase& aContext, TBool aIsNodeBeingDestroyed)

    {

    MESH_LOG((KMeshMachineSubTag, _L8("CNodeActivityBase %08x:\tAbort"), this));

	//the error message will be send by message post processing see AMMNodeBase::Received

   	aContext.iReturn = KErrAbort; //before so as the error could be overwritten

    NetStateMachine::ACore::Cancel(&aContext);

    if (aContext.iReturn != KErrNone)

        {

        TEBase::TError error(aContext.iMessage.MessageId(), aContext.iReturn);

       	for (TInt n = iOriginators.Count() - 1;n>=0; n--)

			{

			TNodePeerId& originator = iOriginators[n];

			//In the "quiet mode", when the hosting node is being destroyed, we can not afford sending

			//an error to the node as it would hit void.

   	        TBool canSend = !((aIsNodeBeingDestroyed && originator == aContext.NodeId())

   	        	|| aContext.iMessage.IsMessage<TEChild::TLeft>());

			if (canSend)

				{

				PostToOriginator(originator, error);

				}

			RemoveOriginator(n); //Do not allow ~CNodeActivityBase to post as client's might be already gone

			}

        }

    }

//-=========================================================

//

//CNodeActivityBase::RPostedToNodeOrPeer

//

//-=========================================================

CNodeActivityBase::RPostedToNodeOrPeer::RPostedToNodeOrPeer() 

    {

    Close();

    }

void CNodeActivityBase::RPostedToNodeOrPeer::Open(const Messages::RNodeInterface& aPeer)

    {

    Close();

    *_Peer() = const_cast<Messages::RNodeInterface*>(&aPeer);

    }

void CNodeActivityBase::RPostedToNodeOrPeer::Open(const Messages::TNodeId& aNode)

    {

    __ASSERT_DEBUG(aNode.Ptr(), User::Panic(KSpecAssert_ElemMeshMachActC, 15));    

    //see Messages::TNodeId::operator= (snapping size is essential in case aNode is more than just plain TNodeId).

    *_Node() = Messages::TNodeId(); 

    //normal assigment

    *_Node() = aNode;

    }

void CNodeActivityBase::RPostedToNodeOrPeer::Close()

    {

    Mem::FillZ(iBuf, sizeof(iBuf));

    }

const Messages::RNodeInterface* CNodeActivityBase::RPostedToNodeOrPeer::Peer() const

    {

    return _Node()->Ptr() ? NULL : *_Peer();

    }

const Messages::TNodeId& CNodeActivityBase::RPostedToNodeOrPeer::NodeId() const

    {

    return (_Node()->Ptr() ? *_Node() : (*_Peer() ? (*_Peer())->RecipientId() : Messages::TNodeId::NullId()));

    }

//-=========================================================

//

//CNodeRetryActivity

//

//-=========================================================

EXPORT_C CNodeRetryActivity::CNodeRetryActivity( const TNodeActivity& aActivitySig, AMMNodeBase& aNode )

:	CNodeActivityBase(aActivitySig, aNode),

	TIfStaticFetcherNearestInHierarchy(this)

	{

	}

EXPORT_C CNodeActivityBase* CNodeRetryActivity::NewL( const TNodeActivity& aActivitySig, AMMNodeBase& aNode )

    {

    return new(ELeave)CNodeRetryActivity(aActivitySig, aNode);

    }

EXPORT_C TBool CNodeRetryActivity::IsIdle() const

	{

	return !IsWaiting() && CNodeActivityBase::IsIdle();

	}

EXPORT_C void CNodeRetryActivity::SetIdle()

	{

	iContextDesc.Close();

	ClearIsWaiting();

	ClearWillWait(); //Set this too in case this fn was invoked from within the serialised state ot transition

	CNodeActivityBase::SetIdle();

	}