/*
* Copyright (c) 2002-2004 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: Utility methods for mrversit2.
*
*/


// Class include.
#include "emailtrace.h"
#include "esmricalutil.h"	// NESMRICalUtil

//debug

// User includes.
#include "esmricalerrors.h"			// Error codes
#include "esmricalkeywords.h"		// Literals
#include "cesmricalproperty.h"		// CESMRICalProperty
#include "cesmricalpropertyparam.h"	// CESMRICalPropertyParam

namespace NESMRICalUtil
	{
	/**
	Finds the first occurence of a character within a string which does not occur
	between a pair of double quotes.
	@param aString The string to search.
	@param aChar The character to search for.
	@return The position of the character within the string, or KErrNotFound.
	@internalTechnology
	*/
	TInt FindFirstUnquoted(const TDesC& aString, const TChar& aChar)
		{
		
		TBool quoted(EFalse);
		
		for (TInt pos = 0; pos < aString.Length(); ++pos)
			{
			TChar val(aString[pos]);
			
			if (val == KICalQuoteChar)
				{
				quoted = !quoted;
				}
			else if ((val == aChar) && (!quoted))
				{
				return pos;
				}
			}
			
		return KErrNotFound;
		}

	/**
	Finds the first occurence of a character within a string which is not escaped
	by a backslash character. Searching for a comma will find it in the following
	strings: "abc," and "abc\\," but will not find it in "abc\," and "abc\\\,".
	Note that backslash cannot exist unescaped, so cannot be searched for.
	@param aString The string to search.
	@param aChar The character to search for.
	@return The position of the character within the string, or KErrNotFound.
	@internalTechnology
	*/
	TInt FindFirstUnescaped(const TDesC& aString, const TChar& aChar)
		{
		
		TBool escaped(EFalse);
		
		for (TInt pos = 0; pos < aString.Length(); ++pos)
			{
			TChar val(aString[pos]);
			
			if (val == KICalBackslashChar)
				{
				escaped = !escaped;
				}
			else 
				{
				if ((val == aChar) && (!escaped))
					{
					return pos;
					}
					
				escaped = EFalse;
				}
			}
		
		return KErrNotFound;	
		}

	/**
	Finds the first occurence of a character within a string, whether or not it
	is escaped by a backslash character. If it was escaped, however, the
	aWasEscaped parameter will be set to true. Note that backslash cannot exist
	unescaped, so cannot be searched for.
	@param aString The string to search.
	@param aChar The character to search for.
	@param aWasEscaped True if the character was escaped, otherwise false.
	@return The position of the character within the string, or KErrNotFound.
	@internalTechnology
	*/
	TInt FindFirstAndUnescape(const TDesC& aString, const TChar& aChar, TBool& aWasEscaped)
		{
		
		aWasEscaped = EFalse;
		TBool escaped(EFalse);
		
		for (TInt pos = 0; pos < aString.Length(); ++pos)
			{
			TChar val(aString[pos]);
			
			if (val == KICalBackslashChar)
				{
				escaped = !escaped;
				}
			else 
				{
				if (val == aChar)
					{
					aWasEscaped = escaped;
					return pos;
					}
					
				escaped = EFalse;
				}
			}
		
		return KErrNotFound;	
		}

	/**
	Take a line and extract the name, parameter and value sections.
	@param aLine A line of text in which to find the data.
	@param aName A TPtrC referencing the section of aLine containing the name.
	@param aParameters A TPtrC referencing the section of aLine containing the
	parameters.
	@param aValues A TPtrC referencing the section of aLine containing the
	values.
	@return An error code: either KErrNone or KErrPropertyHasNoValue - avoid
	leaving so we can try and recover without the overhead of a trap.
	@internalTechnology
	*/
	TInt ExtractSectionsL(const TDesC& aLine, TPtrC& aName, TPtrC& aParameters, TPtrC& aValues)
		{
		
		// Find the value delimiter.
		const TInt colon = FindFirstUnquoted(aLine, KICalColonChar);

		// Vague check that the property has a value.
		if ((colon == KErrNotFound) || (colon == (aLine.Length() - 1)))
			{
			return KErrPropertyHasNoValue;	// No value given - the property is invalid.
			}

		// Find the first parameter delimiter.
		const TInt firstSemiColon = aLine.Locate(KICalSemiColonChar);
			
		// Find the characters dividing each section:
		TUint endOfName(colon);

		if ((firstSemiColon != KErrNotFound) && (firstSemiColon < colon))
			{
			endOfName = firstSemiColon;
			}
		
		// Set the name, parameters and values:
		aName.Set(aLine.Left(endOfName));
	
		if (endOfName < colon)
			{
			const TInt startOfParameters = endOfName + 1;
			aParameters.Set(aLine.Mid(startOfParameters, colon - startOfParameters));
			}
		else
			{
			aParameters.Set(aLine.Left(0));	// No parameters.
			}
		
		aValues.Set(aLine.Mid(colon + 1));
		
		return KErrNone;
		}

	/**
	Takes two strings, representing the parameters and values of a property, and
	the property itself, and populates the latter with the contents of the first
	two.
	@param aParameters A string of parameters.
	@param aValues A string of values.
	@param aProperty A property to add the parameters and values to.
	@internalTechnology
	*/
	void ExtractPropertyL(const TDesC& aParameters, const TDesC& aValues, CESMRICalProperty& aProperty)
		{
		
		ExtractParametersL(aParameters, aProperty);
		ExtractPropertyValuesL(aValues, aProperty);
		
		}

	/**
	Takes a string representing the parameters of a property, and the property
	itself, and populates the property with the contents of the string.
	@param aParameters A string of parameters.
	@param aProperty A property to add the parameters and values to.
	@internalTechnology
	*/
	void ExtractParametersL(const TDesC& aParameters, CESMRICalProperty& aProperty)
		{
		
		TPtrC remainder(aParameters);
		
		while (remainder.Length() > 0)
			{
			TInt endOfParameter(FindFirstUnquoted(remainder, KICalSemiColonChar));
			
			if (endOfParameter == KErrNotFound)
				{
				endOfParameter = remainder.Length();
				}
			
			CESMRICalPropertyParam& param = aProperty.AddPropertyParamL();
			ExtractParameterL(remainder.Left(endOfParameter), param);
			
			// Remove the parameter if it has no value.
			if (param.Values().Count() == 0)
				{
				aProperty.RemovePropertyParamL(param);
				}

			if (endOfParameter < remainder.Length())
				{
				remainder.Set(remainder.Mid(endOfParameter + 1));
				}
			else
				{
				break;
				}
			}
		}

	/**
	Takes a string representing a single parameter, and a class to store it in.
	@param aParameter A string of the form <parameter>[=<value>[,value]*].
	@param aPropertyParam A property parameter to store the data in.
	@internalTechnology
	*/
	void ExtractParameterL(const TDesC& aParameter, CESMRICalPropertyParam& aPropertyParam)
		{
		
		TInt firstEquals(aParameter.Locate(KICalEqualsChar));
		TInt endOfType(aParameter.Length());
		
		if (firstEquals != KErrNotFound)
			{
			endOfType = firstEquals;
			}
		
		aPropertyParam.SetTypeL(aParameter.Left(endOfType));
		
		if (endOfType < aParameter.Length())
			{
			ExtractParameterValuesL(aParameter.Mid(endOfType + 1), aPropertyParam);
			}
		}

	/**
	Takes a string of comma separated values and adds them to a parameter.
	@param aValues A string of the form <value>[,<value>]*.
	@param aPropertyParam A property parameter to store the values in.
	@internalTechnology
	*/
	void ExtractParameterValuesL(const TDesC& aValues, CESMRICalPropertyParam& aPropertyParam)
		{
		
		TPtrC remainder(aValues);
		
		while (remainder.Length() > 0)
			{
			TInt endOfValue(FindFirstUnquoted(remainder, KICalCommaChar));
			
			if (endOfValue == KErrNotFound)
				{
				endOfValue = remainder.Length();
				}
			
			// Add value.
			if (endOfValue > 0)
				{
				aPropertyParam.AddValueL(remainder.Left(endOfValue));
				}
			
			if (endOfValue < remainder.Length())
				{
				remainder.Set(remainder.Mid(endOfValue + 1));
				}
			else
				{
				break;
				}
			}
		}

	/**
	Takes a string of comma separated values and adds them to a property.
	@param aValues A string of the form <value>[,<value>]*.
	@param aProperty A property to store the values in.
	@param aEscaping Used for dealing with incorrect output from other applications.
	@leave Leaves with KErrUnknown if the value of aEscaping is not known.
	@internalTechnology
	*/
	void ExtractPropertyValuesL(const TDesC& aValues, CESMRICalProperty& aProperty, TEscaping aEscaping)
		{
		
		TPtrC remainder(aValues);
		TBool wasEscaped(EFalse);
		
		while (remainder.Length() > 0)
			{
			TInt endOfValue( KErrNotFound );
			
			switch (aEscaping)
				{
				case EEscapeNormal:
					endOfValue = FindFirstUnescaped(remainder, KICalCommaChar);
					break;
				case EEscapeValueSeparators:
					endOfValue = FindFirstAndUnescape(remainder, KICalCommaChar, wasEscaped);
					break;
				default:
					User::Leave(KErrUnknown);
					break;
				}
			
			if (endOfValue == KErrNotFound)
				{
				endOfValue = remainder.Length();
				}
			
			// Add value.
			if (endOfValue > 0)
				{
				aProperty.AddValueL(remainder.Left(endOfValue - (wasEscaped ? 1 : 0)));
				}
			
			if (endOfValue < remainder.Length())
				{
				remainder.Set(remainder.Mid(endOfValue + 1));
				}
			else
				{
				break;
				}
			}
		}
		
	/**
	Determines if the given property has a type which holds a text value.
	@param aProperty The property to test.
	@return ETrue if the property value is a "text" type.
	@internalTechnology
	*/
	TBool PropertyHasTextValueL(const CESMRICalProperty& aProperty)
		{
		
		const TDesC& type = aProperty.Type();
		
		// First check if it's an X-type.
		if ((type.Length() >= 2) && (type.Left(2).CompareF(KICalXProperty) == 0))
			{
			return ETrue;
			}

		// Else return ETrue if the property is PRODID, UID, CATEGORIES, COMMENT, CONTACT,
		// DESCRIPTION, LOCATION, RELATED-TO, RESOURCES, SUMMARY, TZID or TZNAME.
		return ((type.CompareF(KICalProdId) == 0) || (type.CompareF(KICalUid) == 0) ||
			(type.CompareF(KICalCategories) == 0) || (type.CompareF(KICalComment) == 0) ||
			(type.CompareF(KICalContact) == 0) || (type.CompareF(KICalDescription) == 0) || 
			(type.CompareF(KICalLocation) == 0) || (type.CompareF(KICalRelatedto) == 0) || 
			(type.CompareF(KICalResources) == 0) || (type.CompareF(KICalSummary) == 0) || 
			(type.CompareF(KICalTzid) == 0) || (type.CompareF(KICalTzname) == 0));
		}
	}

// End of File