// 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          : CSIPParamContainerBase.cpp
// Part of       : SIP Codec
// Version       : SIP/4.0 
//




#include "CSIPParamContainerBase.h"
#include "CSIPTokenizer.h"
#include "sipcodecerr.h"
#include "sipstrings.h"
#include "SIPSyntaxCheck.h"
#include "sipcodecutils.h"
#include "sipstrconsts.h"

const TInt KMaxNumericValueAsTextLength = 80;
_LIT8(KTIntFormat, "%d");

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::CSIPParamContainerBase
// -----------------------------------------------------------------------------
//
CSIPParamContainerBase::CSIPParamContainerBase(const TChar& aSeparator)
 : iParamSeparator (aSeparator)
	{
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::ConstructL
// -----------------------------------------------------------------------------
//
void 
CSIPParamContainerBase::ConstructL(const CSIPParamContainerBase& aContainer)
	{
	for (TInt i=0; i < aContainer.iParams.Count(); i++)
		{
		CSIPParam* param = CSIPParam::NewLC(*aContainer.iParams[i]);
		User::LeaveIfError(iParams.Append(param));
		CleanupStack::Pop(param);
		}
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::~CSIPParamContainerBase
// -----------------------------------------------------------------------------
//
CSIPParamContainerBase::~CSIPParamContainerBase()
	{
	iParams.ResetAndDestroy();
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::SetParamL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::SetParamL(RStringF aName)
	{
	CSIPParam* param = CSIPParam::NewLC(aName);
	SetParamL(param);
	CleanupStack::Pop(param);
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::SetParamL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::SetParamL(RStringF aName, RStringF aValue)
	{
	CSIPParam* param = CSIPParam::NewLC(aName,aValue);
	SetParamL(param);
	CleanupStack::Pop(param);
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::SetParamL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::SetParamL(RStringF aName, const TDesC8& aValue)
	{
	CSIPParam* param = CSIPParam::NewLC(aName,aValue);
	SetParamL(param);
	CleanupStack::Pop(param);
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::SetDesParamL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::SetDesParamL(RStringF aName, const TDesC8& aValue)
    {
    CSIPParam* param = CSIPParam::NewLC(aName,aValue);
    SetParamL(param);
    CleanupStack::Pop(param);
    param->SetValueL(aValue,ETrue);
    }

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::SetParamL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::SetParamL(RStringF aName, TInt aValue)
	{
	__ASSERT_ALWAYS(aValue >= 0, User::Leave(KErrSipCodecAnyParam));
	TBuf8<KMaxNumericValueAsTextLength> valueAsText;
	valueAsText.Format(KTIntFormat,aValue);
	SetParamL(aName,valueAsText);
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::SetParamL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::SetParamL(RStringF aName, TReal aValue)
	{
	TBuf8<KMaxNumericValueAsTextLength> valueAsText;
	TRealFormat format;
	const TChar KDotChr = '.';
	format.iPoint = KDotChr; // SIP uses always dot as a decimal point
	User::LeaveIfError(valueAsText.Num(aValue,format));
	SetParamL(aName, valueAsText);
	}	

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::SetParamL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::SetParamL (CSIPParam* aParam)
	{
	__ASSERT_ALWAYS (aParam != NULL, User::Leave(KErrSipCodecAnyParam));
	
	CheckParamL(*aParam);

	TInt index = FindParamIndex (aParam->Name());
	User::LeaveIfError (iParams.Append(aParam));
	if (index >= 0) // remove the old param
		{
		CSIPParam* oldParam = iParams[index];
		iParams.Remove(index);
		delete oldParam;
		}	
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::HasParam
// -----------------------------------------------------------------------------
//
TBool CSIPParamContainerBase::HasParam (RStringF aParamName) const
	{
	return (FindParamIndex(aParamName) >= 0);
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::ParamValue
// -----------------------------------------------------------------------------
//
RStringF CSIPParamContainerBase::ParamValue (RStringF aParamName) const
	{
	TInt index = FindParamIndex(aParamName);
	if (index >= 0 && iParams[index]->HasValue())
		{
		return iParams[index]->Value();
		}
	return SIPStrings::StringF(SipStrConsts::EEmpty);
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::DesParamValue
// -----------------------------------------------------------------------------
//	
const TDesC8& CSIPParamContainerBase::DesParamValue(RStringF aParamName) const
    {
	TInt index = FindParamIndex(aParamName);
	if (index >= 0)
		{
		return iParams[index]->DesValue();
		}
	return KNullDesC8;    
    }	

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::IntParamValue
// -----------------------------------------------------------------------------
//
TInt CSIPParamContainerBase::IntParamValue (RStringF aParamName) const
	{
	TPtrC8 des(ParamValue(aParamName).DesC());
	TInt value=KErrNotFound;
	if (des.Length() > 0)
		{
		TLex8 lex(des);
		TInt err = lex.Val(value);
		if (value < 0)
			{
			value = KErrSipCodecAnyParamValue;
			}	
		if (err != KErrNone)
			{
			value = err;
			}
		}
	return value;
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::RealParamValue
// -----------------------------------------------------------------------------
//
TReal CSIPParamContainerBase::RealParamValue (RStringF aParamName) const
	{
	TLex8 lex(ParamValue(aParamName).DesC());
	TReal value = 0;
	const TChar KDotChr = '.';
	lex.Val(value,KDotChr); // SIP uses always dot as a decimal point
	return value;
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::DeleteParam
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::DeleteParam (RStringF aParamName)
	{
	TInt index = FindParamIndex (aParamName);
	if (index >= 0) 
		{
		CSIPParam* param = iParams[index];
		iParams.Remove(index);
		delete param;
		}
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::ParamCount
// -----------------------------------------------------------------------------
//
TInt CSIPParamContainerBase::ParamCount() const
	{
	return iParams.Count();
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::ParamName
// -----------------------------------------------------------------------------
//	
TInt CSIPParamContainerBase::ParamName(TInt aIndex, RStringF& aParamName) const
    {
    TInt err = KErrNotFound;
    if (aIndex >= 0 && aIndex < iParams.Count())
        {
        aParamName = iParams[aIndex]->Name().Copy();
        err = KErrNone;
        }
    return err;
    }

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::ToTextLC
// -----------------------------------------------------------------------------
//
HBufC8* CSIPParamContainerBase::ToTextLC () const
	{
	TUint encodedLength = 0;

	RPointerArray<HBufC8> paramsAsText;
	CleanupStack::PushL (TCleanupItem(ResetAndDestroy,&paramsAsText));

	for (TInt i=0; i < iParams.Count(); i++)
		{
		HBufC8* paramAsText = iParams[i]->ToTextLC();
		encodedLength += paramAsText->Length();
		if (i < iParams.Count()-1) 
		    {
		    encodedLength += 1; // param separator
		    }
		paramsAsText.AppendL(paramAsText);
		CleanupStack::Pop(paramAsText);
		}
	
	HBufC8* encodedParams = HBufC8::NewL (encodedLength);
	TPtr8 encodedParamsPtr = encodedParams->Des();

	for (TInt j=0; j < paramsAsText.Count(); j++)
		{
		encodedParamsPtr.Append (*paramsAsText[j]);
		if (j < paramsAsText.Count()-1)
			{
			encodedParamsPtr.Append(iParamSeparator);
			}
		}

	CleanupStack::PopAndDestroy(1); // paramsAsText
	CleanupStack::PushL(encodedParams);
	return encodedParams;
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::ExternalizeL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::ExternalizeL (RWriteStream& aWriteStream)
	{
	aWriteStream.WriteUint32L (iParams.Count());
	for (TInt i=0; i < iParams.Count(); i++)
		{
		iParams[i]->ExternalizeL(aWriteStream);
		}
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::DoInternalizeL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::DoInternalizeL (RReadStream& aReadStream)
	{
	TUint32 parameterCount = aReadStream.ReadUint32L();
	for (TUint32 i=0; i < parameterCount; i++)
		{
		CSIPParam* param = CSIPParam::InternalizeL(aReadStream);
		CleanupStack::PushL (param);
		SetParamL(param);
		CleanupStack::Pop(param);
		}
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::ParseL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::ParseL (const TDesC8& aValue)
	{
	CSIPTokenizer* tokenizer = CSIPTokenizer::NewLC (aValue,iParamSeparator);
	for (TInt i=0; i < tokenizer->Tokens().Count(); i++)
		{
		TPtrC8 pname;
		TPtrC8 pvalue(KNullDesC8);
		TBool hasValue = CSIPParam::ParseL(tokenizer->Tokens()[i],pname,pvalue);
		CSIPParam* param = CSIPParam::NewLC(pname);
		RStringF pnameStr = param->Name();
		if (HasParam(pnameStr)) 
			{
			User::Leave(KErrSipCodecDuplicateParam);
			}
		CheckAndUpdateParamL(pnameStr,hasValue,pvalue);
		if (hasValue)
		    {
		    param->SetValueL(pvalue,AddQuotesWhenEncoding(pnameStr));
		    }
        User::LeaveIfError(iParams.Append(param));
		CleanupStack::Pop(param);
		}
	CleanupStack::PopAndDestroy(tokenizer);
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::FindParamIndex
// -----------------------------------------------------------------------------
//
TInt CSIPParamContainerBase::FindParamIndex (RStringF aParamName) const
	{
	for (TInt i=0; i < iParams.Count(); i++)
		{
		if (aParamName == iParams[i]->Name()) 
			{
			return i;
			}
		}
	return KErrNotFound;
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::ResetAndDestroy
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::ResetAndDestroy (TAny* anArray)
	{
	(reinterpret_cast<RPointerArray<HBufC8>*> (anArray))->ResetAndDestroy();
	}

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::CheckGenericParamL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::CheckGenericParamL(CSIPParam& aParam,
                                                TInt aLeaveCode) const
    {
    TPtrC8 value(aParam.Value().DesC());
    CheckGenericParamL(aParam.Name(),aParam.HasValue(),value,aLeaveCode);
    } 

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::CheckGenericParamL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::CheckGenericParamL(RStringF aName,
	                                            TBool aHasValue,
	                                            const TDesC8& aValue, 
                                                TInt aLeaveCode) const
    {
	if (!SIPSyntaxCheck::Token(aName.DesC()))
		{
		User::Leave(aLeaveCode);
		}
	if (!aHasValue) 
		{
		return;
		}
	if (!SIPSyntaxCheck::GenericParamValue(aValue))
		{
		User::Leave(aLeaveCode);
		}
    }

// -----------------------------------------------------------------------------
// CSIPParamContainerBase::RemoveQuotes
// -----------------------------------------------------------------------------
//  
void CSIPParamContainerBase::RemoveQuotes(TPtrC8& aParamValue) const
    {
    if (SIPSyntaxCheck::StartsAndEndsWithQuotes(aParamValue))
        {
		TPtrC8 valueWithoutQuotes;
        SIPCodecUtils::ValueWithoutQuotes(aParamValue, valueWithoutQuotes);
        aParamValue.Set(valueWithoutQuotes);
		}   
    }
    
// ----------------------------------------------------------------------------
// CSIPParamContainerBase::AddQuotesWhenEncoding
// ----------------------------------------------------------------------------
//    
TBool CSIPParamContainerBase::AddQuotesWhenEncoding(
    RStringF /*aParamName*/) const
    {
    return EFalse;
    }
    
// ----------------------------------------------------------------------------
// CSIPParamContainerBase::CheckParamL
// ----------------------------------------------------------------------------
//
void CSIPParamContainerBase::CheckParamL(CSIPParam& aParam) const
	{
	RStringF name = aParam.Name();
	TPtrC8 value = aParam.Value().DesC();
	if (aParam.DesValue().Length() > 0)
	    {
	    value.Set(aParam.DesValue());
	    }	
	CheckAndUpdateParamL(name,aParam.HasValue(),value);
	if (AddQuotesWhenEncoding(name))
	    {
	    // Quotes may have been removed. Set the updated value.
	    aParam.SetValueL(value,ETrue);     
	    }
	}    
    
// -----------------------------------------------------------------------------
// CSIPParamContainerBase::CheckAndUpdateParamL
// -----------------------------------------------------------------------------
//      
void CSIPParamContainerBase::CheckAndUpdateParamL(RStringF /*aName*/,
                                                  TBool /*aHasValue*/,
                                                  TPtrC8& /*aValue*/) const
    {
    // By default NOP.
    }