// Copyright (c) 2004-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          : CSIPContactHeader.cpp
// Part of       : SIP Codec
// Version       : SIP/4.0 
//




#include "sipcontactheader.h"
#include "sipaddress.h"
#include "sipuri.h"
#include "CSIPContactHeaderParams.h"
#include "CSIPTokenizer.h"
#include "sipcodecerr.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
#include "uricontainer.h"
#include "_sipcodecdefs.h"

_LIT8 (KStar, "*");

// ----------------------------------------------------------------------------
// CSIPContactHeader::DecodeL
// ----------------------------------------------------------------------------
//
EXPORT_C RPointerArray<CSIPContactHeader> 
CSIPContactHeader::DecodeL (const TDesC8& aValue)
	{
	RPointerArray<CSIPHeaderBase> baseheaders = BaseDecodeL(aValue);
	CSIPHeaderBase::PushLC(&baseheaders);
	RPointerArray<CSIPContactHeader> contactHeaders;
	CleanupClosePushL(contactHeaders);
	TInt count = baseheaders.Count();
	for (TInt i=0; i<count; i++)
		{
		CSIPContactHeader* contact = 
			static_cast<CSIPContactHeader*>(baseheaders[i]);
		User::LeaveIfError(contactHeaders.Append(contact));
		}
	CleanupStack::Pop(2); // contactHeaders, baseheaders
	baseheaders.Close();
	return contactHeaders;
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::NewL
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPContactHeader* CSIPContactHeader::NewL(CSIPAddress* aSIPAddress)
	{
	CSIPContactHeader* self = CSIPContactHeader::NewLC(aSIPAddress);
	CleanupStack::Pop(self);
	return self;
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::NewLC
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPContactHeader* CSIPContactHeader::NewLC(CSIPAddress* aSIPAddress)
	{
	CSIPContactHeader* self = new(ELeave)CSIPContactHeader;
	CleanupStack::PushL(self);
	self->ConstructL(aSIPAddress);
	return self;
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::CSIPContactHeader
// ----------------------------------------------------------------------------
//
CSIPContactHeader::CSIPContactHeader(TBool aIsStar)
 : CSIPParameterHeaderBase(';'),
   iIsStar (aIsStar)
	{
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPContactHeader::ConstructL ()
	{
	iParams = new(ELeave)CSIPContactHeaderParams;
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPContactHeader::ConstructL (CSIPAddress* aSIPAddress)
	{
	ConstructL ();
	SetSIPAddressL (aSIPAddress);
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPContactHeader::ConstructL (const CSIPContactHeader& aContactHeader)
	{
	if (aContactHeader.Star())
		{
		iIsStar = ETrue;
		ConstructL ();
		}
	else
		{
		iParams = CSIPContactHeaderParams::NewL (*(aContactHeader.iParams));
		iSIPAddress = CSIPAddress::NewL (*(aContactHeader.iSIPAddress));
		}	
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::~CSIPContactHeader
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPContactHeader::~CSIPContactHeader()
	{
	delete iParams;
	delete iSIPAddress;
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::CloneL
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPHeaderBase* CSIPContactHeader::CloneL () const
	{
	CSIPContactHeader* clone = new(ELeave)CSIPContactHeader;
	CleanupStack::PushL(clone);
	clone->ConstructL(*this);
	CleanupStack::Pop(clone);
	return clone;
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::operator==
// ----------------------------------------------------------------------------
//
EXPORT_C TBool 
CSIPContactHeader::operator==(const CSIPContactHeader& aSIPContactHeader) const
	{
	if (aSIPContactHeader.Star() != iIsStar) 
        {
        return EFalse;
        }
	if (iIsStar) 
        {
        return ETrue;
        }
	if (!(*iSIPAddress == *(aSIPContactHeader.SIPAddress())))
        {
        return EFalse;
        }
	return (*iParams == *(aSIPContactHeader.iParams));
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::ExpiresParameter
// ----------------------------------------------------------------------------
//
EXPORT_C TInt CSIPContactHeader::ExpiresParameter () const
	{
	if (iIsStar)
		{
		return 0;
		}
	RStringF expires = SIPStrings::StringF(SipStrConsts::EExpires);
	return iParams->IntParamValue(expires);
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::SetExpiresParameterL
// ----------------------------------------------------------------------------
//
EXPORT_C void CSIPContactHeader::SetExpiresParameterL (TInt aExpiresParam)
	{
	__ASSERT_ALWAYS (!iIsStar, User::Leave(KErrSipCodecContactSetToStar));					
	RStringF expires = SIPStrings::StringF(SipStrConsts::EExpires);
	iParams->SetParamL(expires,aExpiresParam);
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::QParameter
// ----------------------------------------------------------------------------
//
EXPORT_C TReal CSIPContactHeader::QParameter () const
	{
	if (iIsStar) 
		{
		return 0;
		}
	return iParams->RealParamValue(SIPStrings::StringF(SipStrConsts::EQ));
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::SetQParameterL
// ----------------------------------------------------------------------------
//
EXPORT_C void CSIPContactHeader::SetQParameterL (TReal aQValue)
	{
	__ASSERT_ALWAYS (!iIsStar, 
				User::Leave(KErrSipCodecContactSetToStar));
	iParams->SetParamL(SIPStrings::StringF(SipStrConsts::EQ),aQValue);
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::Star
// ----------------------------------------------------------------------------
//
EXPORT_C TBool CSIPContactHeader::Star () const
	{
	return iIsStar;
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::SIPAddress
// ----------------------------------------------------------------------------
//
EXPORT_C const CSIPAddress* CSIPContactHeader::SIPAddress() const
	{
	return iSIPAddress;
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::SIPAddress
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPAddress* CSIPContactHeader::SIPAddress()
	{
	return iSIPAddress;
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::SetSIPAddressL
// ----------------------------------------------------------------------------
//
EXPORT_C void CSIPContactHeader::SetSIPAddressL (CSIPAddress* aSIPAddress)
	{
	__ASSERT_ALWAYS (!iIsStar, 
				User::Leave(KErrSipCodecContactSetToStar));
	__ASSERT_ALWAYS (aSIPAddress != 0, 
				User::Leave(KErrSipCodecContactAddress));

	delete iSIPAddress;
	iSIPAddress = aSIPAddress;

    if(iSIPAddress->URI().IsSIPURI())
        {
    	CSIPURI& sipURI = *(iSIPAddress->URI().SIPURI());
    	sipURI.DeleteParam(SIPStrings::StringF(SipStrConsts::EMethod));
        }
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::MoreThanOneAllowed
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
TBool CSIPContactHeader::MoreThanOneAllowed () const
	{
	return ETrue;
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::Name
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
EXPORT_C RStringF CSIPContactHeader::Name() const
	{
	return SIPStrings::StringF(SipStrConsts::EContactHeader);
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::HasCompactName
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
TBool CSIPContactHeader::HasCompactName () const
	{
	return ETrue;
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::CompactName
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
RStringF CSIPContactHeader::CompactName () const
	{
	return SIPStrings::StringF(SipStrConsts::EContactHeaderCompact);
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::InternalizeValueL
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPHeaderBase* CSIPContactHeader::InternalizeValueL(
    RReadStream& aReadStream)
	{
	CSIPContactHeader* self = new(ELeave)CSIPContactHeader(EFalse);
	CleanupStack::PushL(self);
	self->DoInternalizeValueL(aReadStream);
	CleanupStack::Pop(self);
	return self;
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::ExternalizeValueL
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
void CSIPContactHeader::ExternalizeValueL (RWriteStream& aWriteStream) const
	{
	if (iIsStar)
		{
		aWriteStream.WriteUint8L(1);
		}
	else
		{
		aWriteStream.WriteUint8L(0);
		iSIPAddress->ExternalizeL(aWriteStream);
		iParams->ExternalizeL (aWriteStream);
		}
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::DoInternalizeValueL
// ----------------------------------------------------------------------------
//
void CSIPContactHeader::DoInternalizeValueL (RReadStream& aReadStream)
	{
	if (aReadStream.ReadUint8L() == 1) // is STAR
		{
		iIsStar = ETrue;
		iParams = new(ELeave)CSIPContactHeaderParams;
		}
	else
		{
		iIsStar = EFalse;
	    CSIPAddress* tmpAddr = CSIPAddress::InternalizeL (aReadStream);
	    CleanupStack::PushL(tmpAddr);
	    SetSIPAddressL(tmpAddr);
	    CleanupStack::Pop(tmpAddr);
		iParams = CSIPContactHeaderParams::InternalizeL (aReadStream);
		}
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::PreferredPlaceInMessage
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
CSIPHeaderBase::TPreferredPlace
CSIPContactHeader::PreferredPlaceInMessage () const
	{
	return CSIPHeaderBase::EMiddleTop;
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::BaseDecodeL
// ----------------------------------------------------------------------------
//
RPointerArray<CSIPHeaderBase> 
CSIPContactHeader::BaseDecodeL (const TDesC8& aValue)
	{
	__ASSERT_ALWAYS (aValue.Length() > 0,
		User::Leave(KErrSipCodecContactHeader));

	RPointerArray<CSIPHeaderBase> headers;
    CSIPHeaderBase::PushLC(&headers);
	CSIPTokenizer* tokenizer = CSIPTokenizer::NewLC(aValue, ',', ETrue);
	TBool star=EFalse;
	for (TInt i=0; i < tokenizer->Tokens().Count(); i++)
		{
		CSIPContactHeader* contactHeader = new(ELeave)CSIPContactHeader;
		CleanupStack::PushL(contactHeader);
		contactHeader->ConstructL();
		contactHeader->ParseL (tokenizer->Tokens()[i], ETrue, ETrue);
		if (!star) star = contactHeader->iIsStar;
		if (star && i > 0) 
			{
			User::Leave(KErrSipCodecContactSetToStar); 
			}
		headers.AppendL(contactHeader);
		CleanupStack::Pop(contactHeader);
		}
	CleanupStack::PopAndDestroy(tokenizer);
	CleanupStack::Pop(); // headers 
	return headers;
	}

// ----------------------------------------------------------------------------
// CSIPContactHeader::ParamInsertionAllowed
// From CSIPParameterHeaderBase:
// ----------------------------------------------------------------------------
//
TBool CSIPContactHeader::ParamInsertionAllowed () const
    {
    return !(iIsStar);
    }  

// ----------------------------------------------------------------------------
// CSIPContactHeader::ToTextMandatoryPartLC
// From CSIPParameterHeaderBase:
// ----------------------------------------------------------------------------
//
HBufC8* CSIPContactHeader::ToTextMandatoryPartLC () const
    {
	if (iIsStar)
        {
        return KStar().AllocLC();
        }
    return iSIPAddress->ToTextLC(ETrue);
    }

// ----------------------------------------------------------------------------
// CSIPContactHeader::ParseMandatoryPartL
// From CSIPParameterHeaderBase:
// ----------------------------------------------------------------------------
//
void CSIPContactHeader::ParseMandatoryPartL (const TDesC8& aMandatoryPart)
    {
	TLex8 lex(aMandatoryPart);
	lex.SkipSpace();
	if (lex.Peek() == '*')
		{
        lex.Inc();
        lex.SkipSpace();
        if (lex.Remainder().Length() > 0)
            {
            User::Leave(KErrSipCodecContactHeader);
            }
		iIsStar = ETrue;
		}
    else
        {
	    CSIPAddress* sipAddress = CSIPAddress::DecodeL(lex.Remainder());
	    CleanupStack::PushL(sipAddress);
	    SetSIPAddressL(sipAddress);
	    CleanupStack::Pop(sipAddress);
        }
    }
    
// ----------------------------------------------------------------------------
// CSIPContactHeader::Params
// From CSIPParameterHeaderBase:
// ----------------------------------------------------------------------------
//
const CSIPParamContainerBase& CSIPContactHeader::Params () const
    {
    return *iParams; 
    }

// ----------------------------------------------------------------------------
// CSIPContactHeader::Params
// From CSIPParameterHeaderBase:
// ----------------------------------------------------------------------------
//
CSIPParamContainerBase& CSIPContactHeader::Params ()
    {
    return *iParams; 
    }

// ----------------------------------------------------------------------------
// CSIPContactHeader::RemoveExpiresParam
// ----------------------------------------------------------------------------
//
EXPORT_C void CSIPContactHeader::RemoveExpiresParam()
	{
	RStringF expires = SIPStrings::StringF(SipStrConsts::EExpires);
	iParams->DeleteParam(expires);
	}