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

// COREPRSTATES.CPP

// Core PR States

// THIS API IS INTERNAL TO NETWORKING AND IS SUBJECT TO CHANGE AND NOT FOR EXTERNAL USE

// 

//

/**

 @file

 @internalComponent

*/

#include <comms-infras/ss_log.h>

#include <ss_glob.h>

#include <comms-infras/ss_tiermanager.h>

#include <comms-infras/ss_tiermanager_internal.h>

#include <comms-infras/ss_subconnprov.h>

#include <comms-infras/ss_connprov.h>

#include <comms-infras/ss_metaconnprov_internal.h>

#include <comms-infras/ss_nodeinterfaces.h>

#include "ss_coreprstates.h"

#include <comms-infras/ss_corepractivities.h>

#include "ss_apiext_messages.h"

#include <cs_subconparams.h>

#include <comms-infras/ss_protocolparameterset.h>

#include <elements/nm_messages_errorrecovery.h>

#include <elements/nm_messages_peer.h>

#include <elements/nm_messages_child.h>

#include "ss_flowrequest.h"

#include <comms-infras/ss_nodemessages_dataclient.h>

#include <comms-infras/ss_nodemessages_serviceprovider.h>

#include <comms-infras/ss_nodemessages_subconn.h>

#include <comms-infras/ss_nodemessages_rejoiningprovider.h>

#include <comms-infras/ss_nodemessages_internal_esock.h>

#include <comms-infras/ss_nodemessages_factory.h>

#include <comms-infras/ss_nodemessages_mcpr.h>

#include <comms-infras/ss_nodemessages_cpr.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_ESockCrStaCPRSC, "ESockCrStaCPRSC");

#endif

#if defined __CFLOG_ACTIVE || defined LOG || defined ESOCK_EXTLOG_ACTIVE

	#define KCoreProviderStatesTag KESockCoreProviderTag

	_LIT8(KCoreProviderStatesSubTag, "coreprovstate");

#endif

using namespace CoreStates;

using namespace CoreNetStates;

using namespace PRStates;

using namespace PRActivities;

using namespace CoreActivities;

using namespace NetStateMachine;

using namespace ESock;

using namespace CorePanics;

using namespace Elements;

using namespace Messages;

using namespace MeshMachine;

using namespace Factories;

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

//

// Panics

//

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

_LIT (KCorePrPanic,"CorePrPanic");

void CorePrPanic(TInt aCode)

	{

	User::Panic(KCorePrPanic, aCode);

	}

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

//

//Utility functions

//

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

//[RZ TODO] This method is a real pain. This method must go.

//This method method must be replaced with examining activity->Error()

//or similar.

TInt ExtractErrorCode(Messages::TSignatureBase& aMessage, MeshMachine::CNodeActivityBase* aActivity = NULL)

    {

    if (aActivity && aActivity->Error() != KErrNone)

        {

        TInt error = aActivity->Error();

        aActivity->SetError(KErrNone);

        return error;

        }

    TInt code = KErrCancel;

	if  ( (aMessage.IsMessage<TCFServiceProvider::TStopped>()) ||

		(aMessage.IsMessage<TCFServiceProvider::TStop>()) ||

		(aMessage.IsMessage<TCFDataClient::TStopped>()) ||

		(aMessage.IsMessage<TCFDataClient::TStop>()) )

		{

		code = static_cast<const Messages::TSigNumber&>(aMessage).iValue;

		}

	else if ( (aMessage.IsMessage<TCFControlClient::TGoneDown>()) ||

		(aMessage.IsMessage<TCFControlProvider::TDataClientGoneDown>()) )

		{

		code = static_cast<const Messages::TSigNumberNumber&>(aMessage).iValue1;

		}

	else if ( aMessage.IsMessage<TEErrorRecovery::TErrorRecoveryResponse>() )

		{

		//Action must be propagate or there is no error code (your activity flow is faulty)!

		const Messages::TSigErrResponse& sig = static_cast<const Messages::TSigErrResponse&>(aMessage);

		__ASSERT_DEBUG(sig.iErrResponse.iAction==Messages::TErrResponse::EPropagate, User::Panic(KSpecAssert_ESockCrStaCPRSC, 1));

   		code = sig.iErrResponse.iError;

		}

	return code;

    }

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

//

//Common States and Transitions

//

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

EXPORT_C TBool ASetErrorState::Accept(TNodeContextBase& aContext, TBool aSuperAccept)

	{

	TEBase::TError* msg = message_cast<TEBase::TError>(&aContext.iMessage);

	if (msg && aSuperAccept == EFalse && aContext.iNodeActivity != NULL)

    	{

		aContext.iNodeActivity->SetError(msg->iValue);

    	msg->ClearMessageId();

		return EFalse;

		}

	return aSuperAccept;

	}

EXPORT_C TInt ACancelOrErrorOrTag::TransitionTag(TNodeContextBase& aContext, TInt aTag)

   	{

	if(aContext.iMessage.IsMessage<TEBase::TCancel>())

		{

		return MeshMachine::KCancelTag;

		}

	if(aContext.iMessage.IsMessage<TEBase::TError>())

		{

		return MeshMachine::KErrorTag;

		}

   	return aTag;

   	}

EXPORT_DEFINE_SMELEMENT(TForwardToControlProvider, NetStateMachine::MStateTransition, CoreStates::TContext)

EXPORT_C void TForwardToControlProvider::DoL()

	{

	iContext.Node().PostToClients<TDefaultClientMatchPolicy>(iContext.NodeId(),

		iContext.iMessage, TClientType(TCFClientType::ECtrlProvider));

	}

EXPORT_DEFINE_SMELEMENT(TForwardToControlClients, NetStateMachine::MStateTransition, PRStates::TContext)

void TForwardToControlClients::DoL()

	{

	iContext.Node().PostToClients<TDefaultClientMatchPolicy>(iContext.NodeId(), iContext.iMessage, TClientType(TCFClientType::ECtrl));

	}

EXPORT_DEFINE_SMELEMENT(TPanic, NetStateMachine::MStateTransition, CoreStates::TContext)

EXPORT_C void TPanic::DoL()

	{

	__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockCrStaCPRSC, 2));

	}

EXPORT_DEFINE_SMELEMENT(TPostToOriginators, NetStateMachine::MStateTransition, CoreStates::TContext)

EXPORT_C void TPostToOriginators::DoL()

	{

	iContext.iNodeActivity->PostToOriginators(iContext.iMessage);

	}

EXPORT_DEFINE_SMELEMENT(TAddAuxClient, NetStateMachine::MStateTransition, CoreNetStates::TContext)

EXPORT_C void TAddAuxClient::DoL()

	{

//TODO - what is this hack about? Please raise a defect.

	iContext.Node().AddClientL(TNodeId::NullId(), TClientType(TCFClientType::EAux));

	}

EXPORT_DEFINE_SMELEMENT(TRemoveAuxClient, NetStateMachine::MStateTransition, CoreNetStates::TContext)

EXPORT_C void TRemoveAuxClient::DoL()

	{

    TNodeSignal::TMessageId noPeerIds[] = {

        TNodeSignal::TMessageId()

        };

	TEChild::TLeft leaveMsg;

//DEF117712: Reentering mesh engine from TRemoveAuxClient::DoL has been raised on this.

//Must be removed or explained (as an exception - why safe here?), as re-entering the MM engine is forbidden.

	CoreNetStates::TContext ctx(iContext.Node(), leaveMsg, iContext.iSender, iContext.iRecipient);

	iContext.Node().Received(noPeerIds, ctx);

	}

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

//

//Control Client Join

//

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

EXPORT_DEFINE_SMELEMENT(TAddControlClientAndSendJoinCompleteIfRequest, NetStateMachine::MStateTransition, PRStates::TContext)

EXPORT_C void TAddControlClientAndSendJoinCompleteIfRequest::DoL()

	{

	//Make sure the client is in the client's table (add if not already there).

   	if (iContext.iMessage.IsMessage<TCFPeer::TJoinRequest>())

		{

		TCFPeer::TJoinRequest& msg = message_cast<TCFPeer::TJoinRequest>(iContext.iMessage);

        // Client type could be Messages::TClientType::EWorker (Selection Request)

        // or ESock::TCFClientType::ECtrl, possibly others but not ESock::TCFClientType::EData

        // which is handled by another activity

        __ASSERT_DEBUG(msg.iClientType.Type() != (TUint32)TCFClientType::EData, User::Panic(KSpecAssert_ESockCrStaCPRSC, 3));

//		iContext.Node().AddClientL(msg.iNodeId, TClientType(TCFClientType::ECtrl,msg.iValue));

		iContext.Node().AddClientL(msg.iNodeId, TClientType(TCFClientType::ECtrl));

		//Send confirmation

		RClientInterface::OpenPostMessageClose(iContext.NodeId(), iContext.iSender, TCFPeer::TJoinComplete().CRef());

		}

	else

		{

	    TCFFactory::TPeerFoundOrCreated& msg = message_cast<TCFFactory::TPeerFoundOrCreated>(iContext.iMessage);

		iContext.Node().AddClientL(address_cast<TNodeId>(iContext.iSender), TClientType(TCFClientType::ECtrl, msg.iValue));

		}

    //[399TODO] RZ: this call is safe as it checks for the existence of the ControlProvider

    //same as TSendDataClientIdle. Though it looks a bit not elegant, cos' either this has

    //to be a separate transition (why check ControlProvider then?) or it can always be

    //aggregated with join/leave - why separate export then?

   	TSendDataClientActive dcActive(iContext);

   	dcActive.DoL();

 	}

EXPORT_DEFINE_SMELEMENT(TAwaitingApplyResponse, NetStateMachine::MState, CoreStates::TContext)

EXPORT_C TBool TAwaitingApplyResponse::Accept()

	{

	return (iContext.iMessage.IsMessage<TCFScpr::TApplyResponse>());

	}

EXPORT_DEFINE_SMELEMENT(TSendApplyRequest, NetStateMachine::MStateTransition, CoreStates::TContext)

EXPORT_C void TSendApplyRequest::DoL()

	{

   	__ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KSpecAssert_ESockCrStaCPRSC, 4));

	if (iContext.Node().ServiceProvider() == NULL)

    	{

    	User::Leave(KErrNotReady);

    	}

    iContext.iNodeActivity->PostRequestTo(*iContext.Node().ServiceProvider(),

    	TCFScpr::TApplyRequest().CRef());

	}

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

//

//Data Client Join

//

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

EXPORT_DEFINE_SMELEMENT(TAddDataClient, NetStateMachine::MStateTransition, PRStates::TContext)

EXPORT_C void TAddDataClient::DoL()

	{

	Messages::TNodeId* client = NULL;

	TCFClientType::TFlags clientFlags = (TCFClientType::TFlags)0;

	TCFFactory::TPeerFoundOrCreated* dataClientJoinedMsg = message_cast<TCFFactory::TPeerFoundOrCreated>(&iContext.iMessage);

	if ( dataClientJoinedMsg )

		{

		// Message "TJoined" => data client already joined (normally when "freshly" created)

		client = &dataClientJoinedMsg->iNodeId;

		clientFlags = (TCFClientType::TFlags)(dataClientJoinedMsg->iValue);

		}

	else

		{

		// Message "TJoinRequest" => data client requesting to join (when moved from one owner to another).

		TCFPeer::TJoinRequest& dataClientJoinReqMsg =

			message_cast<TCFPeer::TJoinRequest>(iContext.iMessage);

		client = &dataClientJoinReqMsg.iNodeId;

		clientFlags = static_cast<TCFClientType::TFlags>(dataClientJoinReqMsg.iClientType.Flags());

		//[EC120TODO]: RZ When ib earth does the sender of TJoinRequest specifies a different type than

		//             EData. API classification will clear this up though scrapping explicit Contrl/Data join msgs.

		//             So each join message will indeed carry a type.

		__ASSERT_DEBUG(dataClientJoinReqMsg.iClientType.Type() == TCFClientType::EData, User::Panic(KSpecAssert_ESockCrStaCPRSC, 5));

		}

	__ASSERT_DEBUG(client, User::Panic(KSpecAssert_ESockCrStaCPRSC, 6));

	__ASSERT_DEBUG(!client->IsNull(), User::Panic(KSpecAssert_ESockCrStaCPRSC, 7)); //Don't run this transition when you have received no data client from the factory!

	iContext.iPeer = iContext.Node().AddClientL(*client, TClientType(TCFClientType::EData, clientFlags));

	}

EXPORT_C void TAddDataClient::Error(TInt aError)

    {

	TCFFactory::TPeerFoundOrCreated* joinMsg = message_cast<TCFFactory::TPeerFoundOrCreated>(&iContext.iMessage);

    if (joinMsg)

        {

        RClientInterface::OpenPostMessageClose(iContext.NodeId(), joinMsg->iNodeId,

        	TEChild::TDestroy().CRef());

        if (iContext.iPeer)

            {

            iContext.Node().RemoveClient(iContext.iPeer->RecipientId());

            }

        }

    TStateTransition<TContext>::Error(aError);

    }

EXPORT_DEFINE_SMELEMENT(TAwaitingDataClientJoinRequest, NetStateMachine::MState, CoreNetStates::TContext)

EXPORT_C TBool CoreNetStates::TAwaitingDataClientJoinRequest::Accept()

	{

	TCFPeer::TJoinRequest* msg = message_cast<TCFPeer::TJoinRequest>(&iContext.iMessage);

	if (msg != NULL)

		{

		if (msg->iClientType.Type() & TCFClientType::EData)

			return ETrue;

		}

	return EFalse;

	}

EXPORT_DEFINE_SMELEMENT(TAddDataClientAndRespond, NetStateMachine::MStateTransition, PRStates::TContext)

EXPORT_C void TAddDataClientAndRespond::DoL()

	{

    TAddDataClient::DoL();

    RClientInterface::OpenPostMessageClose(iContext.NodeId(), iContext.iSender,

    	TCFPeer::TJoinComplete().CRef());

	}

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

//

//Data Client Rejoin

//

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

EXPORT_DEFINE_SMELEMENT(TAwaitingDataClientRejoin, NetStateMachine::MState, PRStates::TContext)

EXPORT_C TBool TAwaitingDataClientRejoin::Accept()

	{

	return iContext.iMessage.IsMessage<TCFRejoiningProvider::TRejoinDataClientRequest>();

	}

EXPORT_DEFINE_SMELEMENT(TAwaitingDataClientRejoinOrApplyOrCancel, NetStateMachine::MState, PRStates::TContext)

EXPORT_C TBool TAwaitingDataClientRejoinOrApplyOrCancel::Accept()

	{

	if (iContext.iMessage.IsMessage<TCFRejoiningProvider::TRejoinDataClientRequest>() ||

	    iContext.iMessage.IsMessage<TCFScpr::TApplyRequest>())

    	{

    	return ETrue;

    	}

	else if (iContext.iMessage.IsMessage<TEBase::TCancel>())

    	{

    	__ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KSpecAssert_ESockCrStaCPRSC, 8));

        iContext.iNodeActivity->SetIdle();

    	}

    return EFalse;

	}

EXPORT_DEFINE_SMELEMENT(TAwaitingRejoinDataClientComplete, NetStateMachine::MState, PRStates::TContext)

EXPORT_C TBool TAwaitingRejoinDataClientComplete::Accept()

	{

	return iContext.iMessage.IsMessage<TCFRejoiningProvider::TRejoinComplete>();

	}

EXPORT_DEFINE_SMELEMENT(TSendRejoinComplete, NetStateMachine::MStateTransition, PRStates::TContext)

EXPORT_C void TSendRejoinComplete::DoL()

    {

	__ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KSpecAssert_ESockCrStaCPRSC, 9));

    iContext.iNodeActivity->PostToOriginators(TCFRejoiningProvider::TRejoinComplete().CRef());

    }

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

//

//Client Leave && Client Leave Request

//

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

EXPORT_DEFINE_SMELEMENT(TAwaitingClientLeave, NetStateMachine::MState, CoreStates::TContext)

EXPORT_C TBool TAwaitingClientLeave::Accept()

	{

	}

EXPORT_DEFINE_SMELEMENT(TDestroyOrphanedDataClients, NetStateMachine::MStateTransition, PRStates::TContext)

EXPORT_C void TDestroyOrphanedDataClients::DoL()

	{

	iContext.Node().DestroyOrphanedDataClients();

	}

EXPORT_DEFINE_SMELEMENT(TSendDataClientIdle, NetStateMachine::MStateTransition, PRStates::TContext)

EXPORT_C void TSendDataClientIdle::DoL()

	{

    RNodeInterface* cp = iContext.Node().ControlProvider();

	if (cp)

		{ //If there is no Control Provider we probably are an MCPR/Tier Manager/etc

    	cp->PostMessage(iContext.NodeId(), TCFControlProvider::TIdle().CRef());

    	}

	}

EXPORT_DEFINE_SMELEMENT(TSendDataClientActive, NetStateMachine::MStateTransition, PRStates::TContext)

EXPORT_C void TSendDataClientActive::DoL()

	{

    RNodeInterface* cp = iContext.Node().ControlProvider();

	if (cp)

		{ //If there is no Control Provider we probably are an MCPR/Tier Manager/etc

    	cp->PostMessage(iContext.NodeId(), TCFControlProvider::TActive().CRef());

    	}

	}

EXPORT_DEFINE_SMELEMENT(TSendDataClientIdleIfNoClients, NetStateMachine::MStateTransition, PRStates::TContext)

EXPORT_C void TSendDataClientIdleIfNoClients::DoL()

	{

	//A node is idle if it has no EData, ECtrl nor EAux clients.

    //If a node is idle it should send TDataClientIdle to its Control Provider,

    //which (in a typical scenario) decides to send TDestroy as a response.

    //We should process TDestroy by sending TClientLeaving back and destroying self.

    //Should we be the last client of our Control Provider, the Control Provider

    //sends TDataClientIdle to its Control Provider triggering a similar cycle.

	if (iContext.Node().GetFirstClient<TDefaultClientMatchPolicy>(TClientType(TCFClientType::ECtrl|TCFClientType::EAux))==NULL

		&& iContext.Node().GetFirstClient<TDefaultClientMatchPolicy>(TClientType(TCFClientType::EData, TCFClientType::EActive)) == NULL)

		{

		TSendDataClientIdle::DoL();

		return;

        }

    //In the somewhat similar scenario, if the node loses its last control client

    //and discovers it still has dataclients that are not bound to and are not

    //started, it will assume the dataclients are idle (unbound and not started

    //dataclients will never admit to being idle themselves).

    RNodeInterface* cc = iContext.Node().GetFirstClient<TDefaultClientMatchPolicy>(TClientType(TCFClientType::ECtrl));

    if (cc==NULL)

        {

        TClientIter<TDefaultClientMatchPolicy> dciter = iContext.Node().GetClientIter<TDefaultClientMatchPolicy>(TClientType(TCFClientType::EData),

        	TClientType(0, TCFClientType::EActive|TCFClientType::EActivating|TCFClientType::EStarted|TCFClientType::EStarting|TCFClientType::ELeaving));

        TInt i = 0;

        RNodeInterface* dc;

        while ((dc = dciter[i++]) != NULL)

            {

			RClientInterface::OpenPostMessageClose(dc->RecipientId(), iContext.iNode.Id(),

				TCFControlProvider::TIdle().CRef());

            }

        }

	}

EXPORT_DEFINE_SMELEMENT(TSendLeaveCompleteIfRequest, NetStateMachine::MStateTransition, PRStates::TContext)

EXPORT_C void TSendLeaveCompleteIfRequest::DoL()

	{

	if (iContext.iMessage.IsMessage<TEPeer::TLeaveRequest>())

   		{

		iContext.PostToSender(TEPeer::TLeaveComplete().CRef());

		}

	}

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

//

//Data Client Idle

//

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

EXPORT_DEFINE_SMELEMENT(TAwaitingDataClientIdle, MState, PRStates::TContext)

EXPORT_C TBool TAwaitingDataClientIdle::Accept()

	{

	if (! iContext.iMessage.IsMessage<TCFControlProvider::TIdle>())

    	{

    	return EFalse;

    	}

    __ASSERT_DEBUG(iContext.iPeer, User::Panic(KSpecAssert_ESockCrStaCPRSC, 11)); //TDataClientIdle is a peer message

    iContext.iPeer->ClearFlags(TCFClientType::EActive);

    return ETrue;

	}

EXPORT_DEFINE_SMELEMENT(TAwaitingDataClientActive, MState, PRStates::TContext)

EXPORT_C TBool TAwaitingDataClientActive::Accept()

	{

	if (! iContext.iMessage.IsMessage<TCFControlProvider::TActive>())

    	{

    	return EFalse;

    	}

    __ASSERT_DEBUG(iContext.iPeer, User::Panic(KSpecAssert_ESockCrStaCPRSC, 12)); //TDataClientActive is a peer message

    iContext.iPeer->SetFlags(TCFClientType::EActive);

    return ETrue;

	}

EXPORT_DEFINE_SMELEMENT(THandleDataClientIdle, MStateTransition, PRStates::TContext)

EXPORT_C void THandleDataClientIdle::DoL()

	{

	// Send Destroy to the node which has sent data client idle, but only if the node

	// is not in use, i.e. not started/starting/activating and it has not already

	// been sent destroy.

	//This will result in a data client leaving which in turn will trigger sending

	//of TDataClientIdle to the Control Provider if there is no more clients joined to this node.

	//Activity id does not matter for TDestroy message since there is no response to it.

	//The only action that may result from sending destroy is reception of a "no peer"

	//data clent leaving message which is always going to be delivered to the client leaving

	//activity.

	//Please do not ASSERT(iContext.iNodeActivity) here!

	//This transition may only be triggered by a peer message from a data client

	__ASSERT_DEBUG(iContext.iPeer, User::Panic(KSpecAssert_ESockCrStaCPRSC, 13));

	__ASSERT_DEBUG(iContext.iPeer->Type()==TCFClientType::EData, User::Panic(KSpecAssert_ESockCrStaCPRSC, 14));

	if (!(iContext.iPeer->Flags() &

			(TCFClientType::EActivating|TCFClientType::EStarting|TCFClientType::ELeaving|TCFClientType::EStarted)))

    	{

		// if dataclient is default and there is a non default present, don't kill the default.

      	if (!( iContext.iPeer->Flags() & TCFClientType::EDefault &&