// Copyright (c) 2005-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:
// Name          : RouteSet.cpp
// Part of       : TransactionUser
// Version       : SIP/4.0 
//



#include "uricontainer.h"
#include "sipuri.h"
#include "sipaddress.h"
#include "siprouteheader.h"
#include "siprequest.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
#include "MSipRegistrations.h"

#include "RouteSet.h"

#ifdef CPPUNIT_TEST
#include "TestCleanupStack.h"
#endif


// -----------------------------------------------------------------------------
// CRouteSet::NewL
// -----------------------------------------------------------------------------
//
CRouteSet* CRouteSet::NewL(CSIPRequest& aReq,
						   MSipRegistrations& aRegistrations,
						   TRegistrationId aRegisterId)
	{
	CRouteSet* self = new (ELeave) CRouteSet();
	CleanupStack::PushL(self);
	self->ConstructL(aReq, aRegistrations, aRegisterId);
	CleanupStack::Pop(self);
	return self;
	}

// -----------------------------------------------------------------------------
// CRouteSet::NewL
// -----------------------------------------------------------------------------
//
CRouteSet* CRouteSet::NewL(const CRouteSet& aRouteSet)
	{
	CRouteSet* self = new (ELeave) CRouteSet();
	CleanupStack::PushL(self);	
	self->ConstructL(aRouteSet);
	CleanupStack::Pop(self);
	return self;
	}

// -----------------------------------------------------------------------------
// CRouteSet::CRouteSet
// -----------------------------------------------------------------------------
//
CRouteSet::CRouteSet()
#ifdef CPPUNIT_TEST
    : iRoutes(1)
#endif
	{
	}

// -----------------------------------------------------------------------------
// CRouteSet::ConstructL
// If aReq contains Route-headers (=case of a pre-existing route set filled by
// upper subsystem), they are copied to route set. Otherwise the outbound
// proxy (if it exists) is put to the route set.
// -----------------------------------------------------------------------------
//
void CRouteSet::ConstructL(CSIPRequest& aReq,
						   MSipRegistrations& aRegistrations,
						   TRegistrationId aRegisterId)
	{
	iPreconfigRouteExists =
		aReq.HasHeader(SIPStrings::StringF(SipStrConsts::ERouteHeader));
	if (iPreconfigRouteExists)
		{
		TSglQueIter<CSIPHeaderBase> iter =
			aReq.Headers(SIPStrings::StringF(SipStrConsts::ERouteHeader));

	    for (CSIPHeaderBase* header = iter++; header; header = iter++)
			{
			AddRouteL(*header);
			}
		}
	else
		{
		const CSIPRouteHeader* proxy = 
		    aRegistrations.OutboundProxy(aRegisterId);
		if (proxy)
			{
			AddRouteL(*proxy);			
			}
		}
	}

// -----------------------------------------------------------------------------
// CRouteSet::ConstructL
// -----------------------------------------------------------------------------
//
void CRouteSet::ConstructL(const CRouteSet& aRouteSet)
	{
	iPreconfigRouteExists = aRouteSet.iPreconfigRouteExists;

	for (TInt i = 0; i < aRouteSet.iRoutes.Count(); ++i)
		{
		AddRouteL(*aRouteSet.iRoutes[i]);
		}
	}

// -----------------------------------------------------------------------------
// CRouteSet::~CRouteSet
// -----------------------------------------------------------------------------
//
CRouteSet::~CRouteSet()
	{
	iRoutes.ResetAndDestroy();
	}

// -----------------------------------------------------------------------------
// CRouteSet::AddRouteL
// -----------------------------------------------------------------------------
//
void CRouteSet::AddRouteL(const CSIPHeaderBase& aRouteHeader)
	{
    CSIPRouteHeader* route =
		static_cast<CSIPRouteHeader*>(aRouteHeader.CloneL());
	CleanupStack::PushL(route);
	iRoutes.AppendL(route);
	CleanupStack::Pop(route);
	}

// -----------------------------------------------------------------------------
// CRouteSet::CopyToRequestL
// -----------------------------------------------------------------------------
//
void CRouteSet::CopyToRequestL(CSIPRequest& aReq, TUint aIndex) const
	{
	for (TInt i = aIndex; i < iRoutes.Count(); ++i)
		{		
		aReq.AddHeaderL(*iRoutes[i]);
		}
	}

// -----------------------------------------------------------------------------
// CRouteSet::IsLrParamInTopRoute
// -----------------------------------------------------------------------------
//
TBool CRouteSet::IsLrParamInTopRoute() const
	{
	if (IsEmpty())
		{
		return EFalse;
		}
	
	CURIContainer& uri = iRoutes[0]->SIPAddress().URI();
	
    return (uri.IsSIPURI() &&
    		uri.SIPURI()->HasParam(SIPStrings::StringF(SipStrConsts::ELr)));
	}

// -----------------------------------------------------------------------------
// CRouteSet::IsEmpty
// -----------------------------------------------------------------------------
//
TBool CRouteSet::IsEmpty() const
	{
	return iRoutes.Count() == 0;
	}

// -----------------------------------------------------------------------------
// CRouteSet::PreconfigRouteExists
// -----------------------------------------------------------------------------
//
TBool CRouteSet::PreconfigRouteExists() const
	{
	return iPreconfigRouteExists;
	}
	
// -----------------------------------------------------------------------------
// CRouteSet::NextHop
// -----------------------------------------------------------------------------
//
CURIContainer& CRouteSet::NextHop(CURIContainer& aRemoteTarget) const
    {
    if (IsEmpty())
    	{
    	return aRemoteTarget;
    	}

    return iRoutes[0]->SIPAddress().URI();
    }

// -----------------------------------------------------------------------------
// CRouteSet::TopRoute
// -----------------------------------------------------------------------------
//
const CURIContainer* CRouteSet::TopUri() const
	{
	if (IsEmpty())
		{
		return NULL;
		}

    return &iRoutes[0]->SIPAddress().URI();
	}

// -----------------------------------------------------------------------------
// CRouteSet::AddToBeginningL
// -----------------------------------------------------------------------------
//
void CRouteSet::AddToBeginningL(const CSIPRouteHeader& aRoute,
								TBool aOverwrite)
	{
	CSIPRouteHeader* route = static_cast<CSIPRouteHeader*>(aRoute.CloneL());
	CleanupStack::PushL(route);

	if (aOverwrite && !IsEmpty())
		{
		CSIPRouteHeader* old = iRoutes[0];
		iRoutes.Remove(0);
		delete old;
		}

	iRoutes.InsertL(route, 0);
	CleanupStack::Pop(route);
	}

// -----------------------------------------------------------------------------
// CRouteSet::IsInSet
// -----------------------------------------------------------------------------
//
TBool CRouteSet::IsInSet(const CURIContainer& aUri) const
	{
	for (TInt i = 0; i < iRoutes.Count(); ++i)
		{
		if (aUri == iRoutes[0]->SIPAddress().URI())
			{
			return ETrue;
			}
		}

	return EFalse;
	}