// 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:
//

#include <comms-infras/ss_log.h>
#include <comms-infras/ss_nodemessages.h>
#include "ss_std.h"
#include "ss_glob.h"
#include <comms-infras/ss_subconnflow.h>
#include <comms-infras/ss_roles.h>
#include <comms-infras/ss_tiermanagerutils.h>
#include "policyrequest.h"
#include <comms-infras/ss_esockstates.h>
#include "policyrequeststates.h"
#include <comms-infras/ss_tiermanager.h>
#include <comms-infras/ss_corepractivities.h>

#include <comms-infras/ss_nodemessages_serviceprovider.h>
#include <comms-infras/ss_nodemessages_subconn.h>

using namespace Messages;
using namespace MeshMachine;
using namespace ESock;
using namespace NetStateMachine;
using namespace PolicyRequestStates;


namespace PolicyRequestErrorActivity
{
DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityError, PolicyRequestError, TEBase::TError, PolicyRequestActivities::CPolicyRequestActivity::NewL)
	FIRST_NODEACTIVITY_ENTRY(PolicyRequestStates::TAwaitingError, MeshMachine::TNoTag)
	THROUGH_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TLeaveServiceProvidersOrSetIdle, MeshMachine::TNoTag)
	//TDestroyAwaitingLeaveCompleteLoop loops back to its own triple if more SPs
	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSetIdleIfNoServiceProviders, MeshMachine::TAwaitingLeaveComplete, CoreActivities::CDestroyActivity::TNoTagOrNoTagBackwards)
	LAST_NODEACTIVITY_ENTRY(KNoTag, CoreStates::TAbortAllActivities)
NODEACTIVITY_END()
}

namespace PolicyConnectionActivity
{
//TODO perhaps get this from a header file since its used in a number of places - see ss_subconn.cpp
typedef MeshMachine::TAcceptErrorState<CoreNetStates::TAwaitingApplyResponse> TAwaitingApplyResponseOrError;

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFPolicyConnectionActivity, PolicyConnection, TCFIPMessage::TPolicyRequest, PolicyRequestActivities::CPolicyRequestActivity::NewL)
	FIRST_NODEACTIVITY_ENTRY(PolicyRequestStates::TAwaitingConnPolicyRequest, MeshMachine::TNoTag)
	NODEACTIVITY_ENTRY(KNoTag, PolicyRequestStates::TJoinCpr, CoreStates::TAwaitingJoinComplete, MeshMachine::TNoTag)
	NODEACTIVITY_ENTRY(KNoTag, PolicyRequestStates::TRequestCommsBinderFromSCpr, PolicyRequestStates::TAwaitingBinderResponse, MeshMachine::TNoTag)
	NODEACTIVITY_ENTRY(KNoTag, PolicyRequestStates::TJoinReceivedSCpr, CoreStates::TAwaitingJoinComplete, MeshMachine::TNoTag)

	THROUGH_NODEACTIVITY_ENTRY(KNoTag, PolicyRequestStates::TSendBindToComplete, MeshMachine::TNoTag)
    NODEACTIVITY_ENTRY(KNoTag, PolicyRequestStates::TLeaveCpr, MeshMachine::TAwaitingLeaveComplete, MeshMachine::TNoTag)

	NODEACTIVITY_ENTRY(KNoTag, PolicyRequestStates::TJoinTheDeftSCPr, CoreStates::TAwaitingJoinComplete, MeshMachine::TNoTag)
	//NODEACTIVITY_ENTRY(KNoTag, PolicyRequestStates::TSendRejoinDataClientRequestToDeftSCPr, CoreNetStates::TAwaitingRejoinDataClientComplete, MeshMachine::TNoTag)
	NODEACTIVITY_ENTRY(KNoTag, PolicyRequestStates::TSendRejoinDataClientRequestToDeftSCPr, CoreNetStates::TAwaitingRejoinDataClientComplete, MeshMachine::TNoTagOrErrorTag)
	NODEACTIVITY_ENTRY(KErrorTag, PolicyRequestStates::TLeaveTheDeftSCPr, MeshMachine::TAwaitingLeaveComplete, MeshMachine::TTag<KErrorTag>)

	// send param bundle with qos params
	NODEACTIVITY_ENTRY(KNoTag, PolicyRequestStates::TSendQoSParamsToNewSCpr, CoreNetStates::TAwaitingParamResponse, MeshMachine::TNoTagOrErrorTag)

	//When adding socket, add first, remove later.
	NODEACTIVITY_ENTRY(KNoTag, PolicyRequestStates::TSendApplyToNewSCPr, TAwaitingApplyResponseOrError, MeshMachine::TNoTagOrErrorTag)
	NODEACTIVITY_ENTRY(KNoTag, PolicyRequestStates::TSendApplyToDeftSCPr, TAwaitingApplyResponseOrError, MeshMachine::TNoTagOrErrorTag)

    NODEACTIVITY_ENTRY(KErrorTag, PolicyRequestStates::TSendCancelToDeftSCPr, PolicyRequestStates::TAwaitingCancelError, MeshMachine::TNoTag)
	NODEACTIVITY_ENTRY(KNoTag,    PolicyRequestStates::TLeaveTheDeftSCPr, MeshMachine::TAwaitingLeaveComplete, MeshMachine::TNoTag)

	//Cleanup
	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TLeaveServiceProvidersOrSetIdle, MeshMachine::TAwaitingLeaveComplete, MeshMachine::TNoTag)
	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSetIdleIfNoServiceProviders, MeshMachine::TAwaitingLeaveComplete, CoreActivities::CDestroyActivity::TNoTagOrNoTagBackwards)
	LAST_NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TDoNothing)
NODEACTIVITY_END()
}

namespace PolicyRequestIgnoreSubConEvent
{
DECLARE_DEFINE_NODEACTIVITY(ECFActivityNotification, PolicyRequestSCprNotif, TCFSubConnControlClient::TSubConnNotification)
    NODEACTIVITY_ENTRY(KNoTag, PolicyRequestStates::TIgnoreAndCloseSubConEvent, CoreNetStates::TAwaitingSubConEvent, MeshMachine::TNoTag)
NODEACTIVITY_END()
}

namespace PolicyRequestActivities
{
DECLARE_DEFINE_ACTIVITY_MAP(policyRequestActivities)
	ACTIVITY_MAP_ENTRY(PolicyConnectionActivity, PolicyConnection)
	ACTIVITY_MAP_ENTRY(PolicyRequestErrorActivity, PolicyRequestError)
	ACTIVITY_MAP_ENTRY(PolicyRequestIgnoreSubConEvent, PolicyRequestSCprNotif)
ACTIVITY_MAP_END()
}

CPolicyRequest::CPolicyRequest(const TCFConnPolicyRequest& aMsg)
:   ACFMMNodeIdBase(PolicyRequestActivities::policyRequestActivities::Self())
	{
	iParamBundle.Open(aMsg.iParamBundle);
	iFlowNodeId = aMsg.iFlowNodeId;
	iSenderSCPrNodeId = aMsg.iSenderSCPrNodeId;
	iIPCPrNodeId = aMsg.iIPCPrNodeId;
	iNewSCprId.SetNull();

	//iMessage.Adopt(static_cast<RSafeMessage&>(const_cast<RMessage2&>(aMessage)));
	LOG_NODE_CREATE(KESockConnectionTag, CPolicyRequest);
	}

CPolicyRequest::~CPolicyRequest()
	{
	//ASSERT(!iMessage.IsNull());
	//iMessage.Complete(iError);
	iParamBundle.Close();
	LOG_NODE_DESTROY(KESockConnectionTag, CPolicyRequest);
	}

void CPolicyRequest::Received(TNodeContextBase& aContext)
    {
    Messages::TNodeSignal::TMessageId noPeerIds[] = {
    	TCFIPMessage::TPolicyRequest::Id(),
    	Messages::TNodeSignal::TMessageId()
    	};
    MeshMachine::AMMNodeBase::Received(noPeerIds, aContext);
	MeshMachine::AMMNodeBase::PostReceived(aContext);
	}

void CPolicyRequest::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage)
    {
    // TODO: TCFMessage::TConnectionGoingDown - If this message is received
    // a new request needs to be sent on behalf of the socket, and
    // this one needs to cleanup/destroy itself. This is for the race condition
    // where either the idle timer triggers and begin stopping the connection,
    // or the connection is lost (both resulting in TConnectionGoingDown) while
    // the request is in progress.
    if (aMessage.IsMessage<TCFMessage::TStateChange>() ||
        aMessage.IsMessage<TCFControlClient::TGoneDown>() )
        {
        // Note of caution: As a control client of providers the CPolicyRequest
        // could be bombarded with messages that we have no interest in.
        // TStateChange is one, but there could be others. Due to the nature
        // of the mesh machine if we don't handle them it will forward them
        // to the CSocket which only expects a limited set of messages from
        // the CPolicyRequest. The CSocket wont like the messages and its not
        // great for performance to forward them unnecessarily so try to kill
        // them off here.
        aMessage.ClearMessageId();
        return;
        }

	TNodeContext<CPolicyRequest> ctx(*this, aMessage, aSender, aRecipient);
    CPolicyRequest::Received(ctx);
    User::LeaveIfError(ctx.iReturn);
	}

//
//TCFConnPolicyRequest
void TCFConnPolicyRequest::StartL(const TRuntimeCtxId& aSender)
	{
	CPolicyRequest* req = new (ELeave) CPolicyRequest(*this);
	CleanupStack::PushL(req);

    TNodeId newServiceProvider = iIPCPrNodeId;
    // set service provider of the PolicyPequest node
	req->AddClientL(iIPCPrNodeId, TClientType(TCFClientType::EServProvider,TCFClientType::EActive));

	TCFIPMessage::TPolicyRequest msg(ESoCreateWithConnection); //Message to triger activity
	req->ReceivedL(aSender, TNodeCtxId(0, req->Id()), msg);
	CleanupStack::Pop(req);
	}

void TCFConnPolicyRequest::DispatchL(const TRuntimeCtxId& aSender, const TRuntimeCtxId& aRecipient)
	{
	const TNodeId& nodeId = address_cast<const TNodeId>(aRecipient);  //This message type operates on nodes
	ASSERT(nodeId==SockManGlobals::Get()->GetPlaneFC(TCFPlayerRole(TCFPlayerRole::ESubConnPlane))); //Should be dispatched on the Connection Plane container!
	
	CleanupClosePushL(iParamBundle);
	StartL(aSender);
	CleanupStack::PopAndDestroy(&iParamBundle);
	}