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

#include "TEquiv.h"
#include <uriutils.h>
#include <uriutilscommon.h>
#include "UriUtilsInternal.h"
#include <delimitedpathsegment8.h>
#include <delimitedquery8.h>
#include <escapeutils.h>

_LIT8(KParamUserFull,	";user=");
_LIT8(KParamTtlFull,	";ttl=");
_LIT8(KParamMethodFull,	";method=");
_LIT8(KParamMaddrFull,	";maddr=");
_LIT8(KParamMaddr,		"maddr");

_LIT8(KHeaderId, "call-id");
_LIT8(KHeaderIdAbbr, "i");
_LIT8(KHeaderContact, "contact");
_LIT8(KHeaderContactAbbr, "m");
_LIT8(KHeaderEncoding, "content-encoding");
_LIT8(KHeaderEncodingAbbr, "e");
_LIT8(KHeaderLength, "content-length");
_LIT8(KHeaderLengthAbbr, "l");
_LIT8(KHeaderType, "content-type");
_LIT8(KHeaderTypeAbbr, "c");
_LIT8(KHeaderFrom, "from");
_LIT8(KHeaderFromAbbr, "f");
_LIT8(KHeaderSubject, "subject");
_LIT8(KHeaderSubjectAbbr, "s");
_LIT8(KHeaderTo, "to");
_LIT8(KHeaderToAbbr, "t");

TEquiv::TEquiv(const TUriC8& aLhs, const TUriC8& aRhs)
: iLhs(aLhs), iRhs(aRhs)
	{
	}

TBool TEquiv::EquivalentL() const
	{
	if (!IsMatchSchemeL())
		return KUriUtilsErrDifferentScheme;
	
	if (!IsMatchUserInfoL())
		return KUriUtilsErrDifferentUserInfo;
	
	if (!IsMatchHostL())
		return KUriUtilsErrDifferentHost;
	
	if (!IsMatchPortL())
		return KUriUtilsErrDifferentPort;
	
	if (!IsMatchPathL())
		return KUriUtilsErrDifferentPath;
	
	if (!IsMatchQueryL())
		return KUriUtilsErrDifferentQuery;
	
	if (!IsMatchFragmentL())
		return KUriUtilsErrDifferentFragment;
	
	return KErrNone;
	}

TBool TEquiv::IsMatchSchemeL() const
	{
	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriScheme);
	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriScheme);
	TBool result = IsMatchCaseless(*lhsDes, *rhsDes);
	CleanupStack::PopAndDestroy(2);
	return result;
	}

TBool TEquiv::IsMatchUserInfoL() const
	{
	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriUserinfo);
	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriUserinfo);
	TBool result = IsMatchCaseSensitive(*lhsDes, *rhsDes);
	CleanupStack::PopAndDestroy(2);
	return result;
	}

TBool TEquiv::IsMatchHostL() const
	{
	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriHost);
	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriHost);
	TBool result = IsMatchCaseless(*lhsDes, *rhsDes);
	CleanupStack::PopAndDestroy(2);
	return result;
	}

TBool TEquiv::IsMatchPortL() const
	{
	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriPort);
	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriPort);
	TBool result = IsMatchCaseSensitive(*lhsDes, *rhsDes);
	CleanupStack::PopAndDestroy(2);
	return result;
	}

TBool TEquiv::IsMatchPathL() const
	{
	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriPath);
	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriPath);
	TBool result = IsMatchCaseSensitive(*lhsDes, *rhsDes);
	CleanupStack::PopAndDestroy(2);
	return result;
	}

TBool TEquiv::IsMatchQueryL() const
	{
	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriQuery);
	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriQuery);
	TBool result = IsMatchCaseSensitive(*lhsDes, *rhsDes);
	CleanupStack::PopAndDestroy(2);
	return result;
	}

TBool TEquiv::IsMatchFragmentL() const
	{
	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriFragment);
	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriFragment);
	TBool result = IsMatchCaseSensitive(*lhsDes, *rhsDes);
	CleanupStack::PopAndDestroy(2);
	return result;
	}

HBufC8* TEquiv::DecodedSegmentLC(const TUriC8& aUri, TUriComponent aSegmentType) const
	{
	HBufC8* decoded = EscapeUtils::EscapeDecodeL(aUri.Extract(aSegmentType));
	CleanupStack::PushL(decoded);
	return decoded;
	}

TEquivSip::TEquivSip(const TUriC8& aLhs, const TUriC8& aRhs)
: TEquiv(aLhs, aRhs)
	{
	}

void TEquivSip::RemoveLeadingZeros(TPtr8 aHost) const
	{
	for (TInt i=0; i < aHost.Length(); i++)
		{
		TBool startOfNumber = (i == 0 || aHost[i-1] < '0' || aHost[i-1] > '9');
		if (aHost[i] == '0' && startOfNumber)
			{
			// The character is a zero and is either at the start of the string
			// or the fist number in a sequence.
			aHost.Delete(i--,1);
			}
		}
	}

TBool TEquivSip::IsMatchHostL(const TDesC8& aLhs, const TDesC8& aRhs) const
	{
	UriUtils::TUriHostType lhsType = UriUtils::HostType(aLhs);
	UriUtils::TUriHostType rhsType = UriUtils::HostType(aRhs);
	if (lhsType != rhsType)
		return EFalse;
	if (lhsType != UriUtils::ETextHost)
		{
		// Host is IPv4 or IPv6
		// Create a copy of the hosts and remove any leading '0's
		HBufC8* lhsCopy = aLhs.AllocLC();
		HBufC8* rhsCopy = aRhs.AllocLC();
		RemoveLeadingZeros(lhsCopy->Des());
		RemoveLeadingZeros(rhsCopy->Des());
		TBool result = IsMatchCaseSensitive(*lhsCopy, *rhsCopy);
		CleanupStack::PopAndDestroy(2);
		return result;
		}

	return IsMatchCaseless(aLhs, aRhs);
	}

TBool TEquivSip::IsMatchHostL() const
	{
	HBufC8* lhsDes = DecodedSegmentLC(iLhs, EUriHost);
	HBufC8* rhsDes = DecodedSegmentLC(iRhs, EUriHost);
	TBool result = IsMatchHostL(*lhsDes, *rhsDes);
	CleanupStack::PopAndDestroy(2);
	return result;
	}

TBool TEquivSip::IsParamCompatibleL(const TDesC8& aLhsName, const TDesC8& aLhsValue, const TDesC8& aRhsName, const TDesC8& aRhsValue) const
	{
	// Were're just checking that if the segments have the same name part
	// that their values are the same. This method only returns false if the lhs and rhs
	// have the same name but their values are different.
	if (!IsMatchCaseless(aLhsName, aRhsName))
		{
		// Names don't match so we're OK
		return ETrue;
		}

	// The maddr parameter needs to be handled differently from the others
	// The address is checked for equivalence not just a straight string compare.
	if (IsMatchCaseless(aLhsName, KParamMaddr))
		{
			return IsMatchHostL(aLhsValue, aRhsValue);
		}
	else
		{
		if (!IsMatchCaseless(aLhsValue, aRhsValue))
			{
			// Names are the same but the values are different
			// We have a incompatible parameter
			return EFalse;
			}
		}

	return ETrue;
	}

TBool TEquivSip::IsParamListCompatibleL(const TDelimitedParserBase8& aLhsParser, const TDelimitedParserBase8& aRhsParser) const

	{
	TPtrC8 lhsName;
	TPtrC8 lhsValue;
	TPtrC8 rhsName;
	TPtrC8 rhsValue;

	TPtrC8 lhsSegment;
	TPtrC8 rhsSegment;

	// roll back to the start of the lhs segment parser
	aLhsParser.Reset();
	
	while( aLhsParser.GetNext(lhsSegment) == KErrNone )
		{
		// roll back to the start of the rhs segment parser
		aRhsParser.Reset();

		GetNameValuePair(lhsSegment, lhsName, lhsValue);
		while( aRhsParser.GetNext(rhsSegment) == KErrNone )
			{
			GetNameValuePair(rhsSegment, rhsName, rhsValue);
			if (!IsParamCompatibleL(lhsName, lhsValue, rhsName, rhsValue))
				return EFalse;
			}
		}

	return ETrue;
	}

TInt TEquivSip::ListLength(const TDelimitedParserBase8& aParser) const
	{
	aParser.Reset();
	
	TInt result = 0;
	while (!aParser.Eos())
		{
		aParser.Inc();
		++result;
		}
		
	aParser.Reset();
	return result;
	}

TBool TEquivSip::IsMatchPathL() const
	{
	HBufC8* lhs = DecodedSegmentLC(iLhs, EUriPath);
	HBufC8* rhs = DecodedSegmentLC(iRhs, EUriPath);

	TDelimitedPathSegmentParser8 lhsParser;
	lhsParser.Parse(*lhs);
	TDelimitedPathSegmentParser8 rhsParser;
	rhsParser.Parse(*rhs);
	
	// Check each parameter in the lhs parameter list with those in
	// the rhs parameter list. If at any point a parameter is incompatible
	// we'll return false.
	TBool result = ETrue;
	
	// Alway check the parameter list with the most parameters against the other
	// so that we don't miss any
	TInt lhsLength = ListLength(lhsParser);
	TInt rhsLength = ListLength(rhsParser);
	
	if (lhsLength > rhsLength)
		{
		result = IsParamListCompatibleL(lhsParser, rhsParser);
		}
	else
		{
		result = IsParamListCompatibleL(rhsParser, lhsParser);
		}

	// check that the special parameters, if present, are present in both
	if (result)
		{
		if ((lhs->Find(KParamUserFull) == KErrNotFound) != (rhs->Find(KParamUserFull) == KErrNotFound) ||
		    (lhs->Find(KParamTtlFull) == KErrNotFound) != (rhs->Find(KParamTtlFull) == KErrNotFound) ||
		    (lhs->Find(KParamMethodFull) == KErrNotFound) != (rhs->Find(KParamMethodFull) == KErrNotFound) ||
		    (lhs->Find(KParamMaddrFull) == KErrNotFound) != (rhs->Find(KParamMaddrFull) == KErrNotFound) )
			{
			result = EFalse;
			}
		}
	
	CleanupStack::PopAndDestroy(2);
	return result;
	}


TEquivSip::THeaderType TEquivSip::HeaderType(const TDesC8& aHeaderName) const
	{
	if (IsMatchCaseless(aHeaderName, KHeaderId) || IsMatchCaseless(aHeaderName, KHeaderIdAbbr))
		return EHeaderId;
	if (IsMatchCaseless(aHeaderName, KHeaderContact) || IsMatchCaseless(aHeaderName, KHeaderContactAbbr))
		return EHeaderContact;
	if (IsMatchCaseless(aHeaderName, KHeaderEncoding) || IsMatchCaseless(aHeaderName, KHeaderEncodingAbbr))
		return EHeaderEncoding;
	if (IsMatchCaseless(aHeaderName, KHeaderLength) || IsMatchCaseless(aHeaderName, KHeaderLengthAbbr))
		return EHeaderLength;
	if (IsMatchCaseless(aHeaderName, KHeaderType) || IsMatchCaseless(aHeaderName, KHeaderTypeAbbr))
		return EHeaderType;
	if (IsMatchCaseless(aHeaderName, KHeaderFrom) || IsMatchCaseless(aHeaderName, KHeaderFromAbbr))
		return EHeaderFrom;
	if (IsMatchCaseless(aHeaderName, KHeaderSubject) || IsMatchCaseless(aHeaderName, KHeaderSubjectAbbr))
		return EHeaderSubject;
	if (IsMatchCaseless(aHeaderName, KHeaderTo) || IsMatchCaseless(aHeaderName, KHeaderToAbbr))
		return EHeaderTo;

	return EHeaderNormal;
	}

TBool TEquivSip::IsMatchHeader(const TDesC8& aLhs, const TDesC8& aRhs) const
	{
	if (IsMatchCaseless(aLhs, aRhs))
		{
		// identical headers are always OK
		return ETrue;
		}

	// We now need to check for abbreviated headers
	TPtrC8 lhsName;
	TPtrC8 lhsValue;
	TPtrC8 rhsName;
	TPtrC8 rhsValue;

	GetNameValuePair(aLhs, lhsName, lhsValue);
	GetNameValuePair(aRhs, rhsName, rhsValue);

	if (!IsMatchCaseless(lhsValue, rhsValue))
		{
		// headers with different values can never match
		return EFalse;
		}

	// We now have only those with different header names but with the same value
	// The last check is to see if the headers are in abbreviated forms
	THeaderType lhsType = HeaderType(lhsName);
	THeaderType rhsType = HeaderType(rhsName);
	if (lhsType != EHeaderNormal && (lhsType == rhsType))
		{
		// They are both special headers of the same type
		// Everything matches
		return ETrue;
		}

	return EFalse;
	}

TBool TEquivSip::IsQueryListCompatible(const TDelimitedParserBase8& aLhsParser, const TDelimitedParserBase8& aRhsParser) const

	{
	TPtrC8 lhsSegment;
	TPtrC8 rhsSegment;

	TBool found = EFalse;
	// roll back to the start of the lhs segment parser
	aLhsParser.Reset();

	while( aLhsParser.GetNext(lhsSegment) == KErrNone )
		{
		// roll back to the start of the rhs segment parser
		aRhsParser.Reset();
		
		found = EFalse;

		while( aRhsParser.GetNext(rhsSegment) == KErrNone )
			{
			if (IsMatchHeader(lhsSegment, rhsSegment))
				{
				// a match has been found for this header so move to the next
				// header in the lhs list
				found = ETrue;
				break;
				}
			}
		if (!found)
			{
			// no match has been found so the headers are not equvalent
			return EFalse;
			}
		}

	return ETrue;
	}

TBool TEquivSip::IsMatchQueryL() const
	{
	HBufC8* lhs = DecodedSegmentLC(iLhs, EUriQuery);
	HBufC8* rhs = DecodedSegmentLC(iRhs, EUriQuery);

	TDelimitedQueryParser8 lhsParser;
	lhsParser.Parse(*lhs);
	TDelimitedQueryParser8 rhsParser;
	rhsParser.Parse(*rhs);

	TBool result = EFalse;
	
	// first check that the number of headers are the same in both lists.
	TInt lhsLength = ListLength(lhsParser);
	TInt rhsLength = ListLength(rhsParser);
	if (lhsLength == rhsLength)
		{
		// Check each parameter in the lhs parameter list with those in
		// the rhs parameter list. If at any point a parameter is incompatible
		// we'll return false.
		result = IsQueryListCompatible(lhsParser, rhsParser);
		}
	
	CleanupStack::PopAndDestroy(2);
	return result;
	}

TBool TEquivSip::IsMatchFragmentL() const
	{
	// We don't care about the fragment for SIP URIs
	return ETrue;
	}