// Copyright (c) 1997-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 <vstaticutils.h>

// System includes

#include <f32file.h>

#include <charconv.h>

#include <utf.h>

#include <s32mem.h>

#include <concnf.h>

#include <confndr.h>

#include <conlist.h>

// User includes

#include <vutil.h>

#include <vuid.h>

#include "verror.h"

#include "VersitAdditionalStorage.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "versit_internal.h"

#include "versittlscontainer.h"

#endif

// Constants

_LIT(KVersitEscapeCharacter, "\\");

const TText KVersitSemiColon = ';';

EXPORT_C TBool VersitUtils::EightBitEncoding(Versit::TVersitCharSet aCharSet)

/** Tests whether the specified character set is encoded using 8 bits or not. 

For instance ASCII is 7-bit; ISO-8859-1 is 8-bit. 

@param aCharSet A character set.

@return ETrue if the character set uses 8 bits; EFalse if it uses 7 bits. */

	{

	switch(aCharSet)

		{

	case Versit::EUSAsciiCharSet:

	case Versit::EUTF7CharSet:

		return EFalse;

	//

	case Versit::EUTF8CharSet:

	case Versit::EISO88591CharSet:

	case Versit::EISO88592CharSet:

	case Versit::EISO88594CharSet:

	case Versit::EISO88595CharSet:

	case Versit::EISO88597CharSet:

	case Versit::EISO88599CharSet:

	case Versit::EISO88593CharSet:

	case Versit::EISO885910CharSet:

	case Versit::EGB231280CharSet:

	case Versit::EGBKCharSet:

	case Versit::EBIG5CharSet:

	case Versit::EISO2022JPCharSet:

	case Versit::EEUCJPCharSet:

	case Versit::EShiftJISCharSet:

	case Versit::EJISCharSet:

		return ETrue;

	default:

		break;

		}

	__ASSERT_DEBUG(EFalse, User::Invariant());

	return EFalse;

	}

EXPORT_C TBool VersitUtils::EightBitEncoding(TUint aCharSetId)

/** Tests whether the character set identified by the specified ID is encoded using 8 

bits or not. 

@param aCharSetId A character set ID.

@return ETrue if the character set uses 8 bits; EFalse if it uses 7 bits. */

	{

	return (aCharSetId!=KCharacterSetIdentifierUtf7 && aCharSetId!=KCharacterSetIdentifierAscii);

	}

EXPORT_C TUid VersitUtils::ConArcEncodingUid(Versit::TVersitEncoding aEncoding)

/** Returns the UID of a character set converter suitable for the specified encoding. 

@param aEncoding An encoding type.

@return The UID of a character set converter. 

@see CCnaConverterList::NewConverterL() */

	{

	switch(aEncoding)

		{

	case Versit::EQuotedPrintableEncoding:

		return TUid::Uid(KTextToQuotedPrintableConverter);

	case Versit::EBase64Encoding:

		return TUid::Uid(KTextToBase64Converter);

	default:

	case Versit::ENoEncoding:

	case Versit::EEightBitEncoding:

		__ASSERT_DEBUG(EFalse, User::Invariant());

		return KNullUid;

		}

	}

EXPORT_C const TDesC8& VersitUtils::IANACharacterSetName(Versit::TVersitCharSet aCharSet)

/** Returns the IANA character set name corresponding to the specified character set identifier.

@param aCharSet A character set.

@return An IANA character set name. */

	{

	switch(aCharSet)

		{

	case Versit::EUSAsciiCharSet:

		return KNullDesC8; // Should this do something else?

	//

	case Versit::EUTF7CharSet:

		return KVersitTokenUTF7;

	case Versit::EUTF8CharSet:

		return KVersitTokenUTF8;

	case Versit::EISO88591CharSet:

		return KVersitTokenISO1;

	case Versit::EISO88592CharSet:

		return KVersitTokenISO2;

	case Versit::EISO88594CharSet:

		return KVersitTokenISO4;

	case Versit::EISO88595CharSet:

		return KVersitTokenISO5;

	case Versit::EISO88597CharSet:

		return KVersitTokenISO7;

	case Versit::EISO88599CharSet:

		return KVersitTokenISO9;

	case Versit::EISO88593CharSet:

		return KVersitTokenISO3;

	case Versit::EISO885910CharSet:

		return KVersitTokenISO10;

	case Versit::EGB231280CharSet:

		return KVersitTokenGB2312;

	case Versit::EGBKCharSet:

		return KVersitTokenGBK;

	case Versit::EBIG5CharSet:

		return KVersitTokenBIG5;

	case Versit::EISO2022JPCharSet:

		return KVersitTokenISO2022JP;

	case Versit::EEUCJPCharSet:

		return KVersitTokenEUCJP;

	case Versit::EShiftJISCharSet:

		return KVersitTokenShiftJIS;

	case Versit::EJISCharSet:

		return KVersitTokenJIS;

	default:

		break;

		}

	__ASSERT_DEBUG(EFalse, User::Invariant());

	return KNullDesC8;

	}

EXPORT_C const TDesC8& VersitUtils::IANAEncodingName(Versit::TVersitEncoding aEncoding)

/** Returns the MIME encoding type corresponding to the specified encoding.

@param aEncoding An encoding type.

@return The MIME encoding type corresponding to the specified encoding. */

	{

	switch(aEncoding)

		{

	case Versit::EQuotedPrintableEncoding:

		return KVersitTokenQUOTEDPRINTABLE;

	case Versit::EBase64Encoding:

		return KVersitTokenBASE64;

	case Versit::EEightBitEncoding:

		return KVersitToken8BIT;

	default:

	case Versit::ENoEncoding:

		break;

		}

	__ASSERT_DEBUG(EFalse, User::Invariant());

	return KNullDesC8;

	}

EXPORT_C TUid VersitUtils::CharConvCharSetUid(Versit::TVersitCharSet aVersitSet)

/** Returns the character converter UID associated with the specified Versit character 

set identifier. 

@param aVersitSet A character set identifier.

@return The character converter UID associated with the specified Versit character set 

identifier. These UIDs are defined in charconv.h. */

	{

	switch(aVersitSet)

		{

	// ASCII

	case Versit::EUSAsciiCharSet:

		return TUid::Uid(KCharacterSetIdentifierAscii);

	// ISO's

	case Versit::EISO88591CharSet:

		return TUid::Uid(KCharacterSetIdentifierIso88591);

	case Versit::EISO88592CharSet:

		return TUid::Uid(KCharacterSetIdentifierIso88592);

	case Versit::EISO88594CharSet:

		return TUid::Uid(KCharacterSetIdentifierIso88594);

	case Versit::EISO88595CharSet:

		return TUid::Uid(KCharacterSetIdentifierIso88595);

	case Versit::EISO88597CharSet:

		return TUid::Uid(KCharacterSetIdentifierIso88597);

	case Versit::EISO88599CharSet:

		return TUid::Uid(KCharacterSetIdentifierIso88599);

	case Versit::EISO88593CharSet:

		return TUid::Uid(KCharacterSetIdentifierIso88593);

	case Versit::EISO885910CharSet:

		return TUid::Uid(KCharacterSetIdentifierIso885910);

	case Versit::EGB231280CharSet:

		return TUid::Uid(KCharacterSetIdentifierGb2312);

	case Versit::EGBKCharSet:

		return TUid::Uid(KCharacterSetIdentifierGbk);

	case Versit::EBIG5CharSet:

		return TUid::Uid(KCharacterSetIdentifierBig5);

	case Versit::EISO2022JPCharSet:

		return TUid::Uid(KCharacterSetIdentifierIso2022Jp);

	case Versit::EEUCJPCharSet:

		return TUid::Uid(KCharacterSetIdentifierEucJpPacked);

	case Versit::EShiftJISCharSet:

		return TUid::Uid(KCharacterSetIdentifierShiftJis);

	case Versit::EJISCharSet:

		return TUid::Uid(KCharacterSetIdentifierJis);

	// UTF

	case Versit::EUTF7CharSet:

		return TUid::Uid(KCharacterSetIdentifierUtf7);

	case Versit::EUTF8CharSet:

		return TUid::Uid(KCharacterSetIdentifierUtf8);

	default:

		return KNullUid;

		}

	}

Versit::TVersitCharSet VersitUtils::CharSet(TUint aCharConvCharSetUid)

/** Returns the Versit character set identifier associated with the specified 

character converter UID. 

@param aCharConvCharSetUid A character converter UID. These UIDs are defined in charconv.h.

@return A Versit character set identifier associated with the specified character 

converter UID. */

	{

	switch(aCharConvCharSetUid)

		{

	// ASCII

	case KCharacterSetIdentifierAscii:

		return Versit::EUSAsciiCharSet;

	// ISO's

	case KCharacterSetIdentifierIso88591:

		return Versit::EISO88591CharSet;

	case KCharacterSetIdentifierIso88592:

		return Versit::EISO88592CharSet;

	case KCharacterSetIdentifierIso88594:

		return Versit::EISO88594CharSet;

	case KCharacterSetIdentifierIso88595:

		return Versit::EISO88595CharSet;

	case KCharacterSetIdentifierIso88597:

		return Versit::EISO88597CharSet;

	case KCharacterSetIdentifierIso88599:

		return Versit::EISO88599CharSet;

	case KCharacterSetIdentifierIso88593:

		return Versit::EISO88593CharSet;

	case KCharacterSetIdentifierIso885910:

		return Versit::EISO885910CharSet;

	case KCharacterSetIdentifierGb2312:

		return Versit::EGB231280CharSet;

	case KCharacterSetIdentifierGbk:

		return Versit::EGBKCharSet;

	case KCharacterSetIdentifierBig5:

		return Versit::EBIG5CharSet;

	case KCharacterSetIdentifierIso2022Jp:

		return Versit::EISO2022JPCharSet;

	case KCharacterSetIdentifierEucJpPacked:

		return Versit::EEUCJPCharSet;

	case KCharacterSetIdentifierShiftJis:

		return Versit::EShiftJISCharSet;

	case KCharacterSetIdentifierJis:

		return Versit::EJISCharSet;

	// UTF

	case KCharacterSetIdentifierUtf7:

		return Versit::EUTF7CharSet;

	case KCharacterSetIdentifierUtf8:

		return Versit::EUTF8CharSet;

	default:

		return Versit::EUnknownCharSet;

		}

	}

EXPORT_C TBool VersitUtils::DescriptorContainsOnlySevenBitCharacters(const TDesC& aText)

/** Tests whether all of the characters in the specified text can be represented 

in 7-bit ASCII. 

@param aText Text to be tested.

@return ETrue if all of the characters in the specified text can be 

represented in 7 bit ASCII, otherwise EFalse. */

	{

	const TInt KMax7BitValue = 127;

	//

	const TInt length = aText.Length();

	const TText* pText = aText.Ptr();

	for(TInt i=0; i<length; i++)

		{

#ifdef _DEBUG

		const TPtrC pChar(aText.Mid(i, 1));

		(void) pChar;

#endif

		if	(pText[i] > KMax7BitValue)

			return EFalse;

		}

	// Can be represented in pure 7 bit ASCII

	return ETrue;

	}

EXPORT_C TBool VersitUtils::RequiresEncoding(const TDesC& aText)

/** Tests whether the specified text requires encoding.

@param aText Text to be tested.

@return ETrue if the specified text needs encoding, otherwise EFalse. */

	{

	// See http://www.freesoft.org/CIE/RFC/1521/6.htm for details on the QP tests

	// below.

	const TInt length = aText.Length();

	const TUint KVersitCharacterValueSpace = 0x20;

	const TUint KVersitCharacterValueTab = 0x09;

	const TUint KVersitCharacterValueEquals = 0x3d;

	const TUint KVersitCharacterValueExclamationPoint = 0x21;

	const TUint KVersitCharacterValueTilde = 0x7e;

	const TUint KVersitCharacterValueDoubleQuotes   = 0x22;

	const TUint KVersitCharacterValueDollarSign   = 0x24;

	const TUint KVersitCharacterValueAtSign   = 0x40;

	const TUint KVersitCharacterValueSquareBracketOpen   = 0x5B;

	const TUint KVersitCharacterValueBackSlash   = 0x5C;

	const TUint KVersitCharacterValueSquareBracketClose   = 0x5D;

	const TUint KVersitCharacterValueCircumflex   = 0x5E;

	const TUint KVersitCharacterValueSingleQuote   = 0x60;

	const TUint KVersitCharacterValueCurlyBracketOpen   = 0x7B;

	const TUint KVersitCharacterValueOrOperatorSign   = 0x7C;

	const TUint KVersitCharacterValueCurlyBracketClose   = 0x7D;

	//

	const TText* pText = aText.Ptr();

	for(TInt i=0; i<length; i++)

		{

		// Test for BASE64 and QP special characters

		//	QP also protects punctuation characters listed in 

		//  RFC1521 as being affected by EBCDIC gateways.

		const TUint character = pText[i];

		switch(character)

			{

		case KVersitCharacterValueTab:

		case KVersitCharacterValueEquals: // EQUALS SIGN

		case CVersitParser::ECarriageReturn:

		case CVersitParser::ELineFeed:

		case KVersitCharacterValueDoubleQuotes:

		case KVersitCharacterValueDollarSign:

		case KVersitCharacterValueAtSign:

		case KVersitCharacterValueSquareBracketOpen:

		case KVersitCharacterValueBackSlash:

		case KVersitCharacterValueSquareBracketClose:

		case KVersitCharacterValueCircumflex:

		case KVersitCharacterValueSingleQuote:

		case KVersitCharacterValueCurlyBracketOpen:

		case KVersitCharacterValueOrOperatorSign:

		case KVersitCharacterValueCurlyBracketClose:

			return ETrue;

		// It's okay to allow spaces in property values without

		// encoding.

		case KVersitCharacterValueSpace:

			continue;

		// Check for non-printable characters

		default:

			if	(character <= KVersitCharacterValueExclamationPoint || character >= KVersitCharacterValueTilde)

				{

				return ETrue;

				}

			}

		}

	// No encoding required

	return EFalse;

	}

EXPORT_C void VersitUtils::UncodeToNarrowL(const TDesC& aUnicode, TDes8& aNarrow, const Versit::TEncodingAndCharset& aEncodingCharset)

/** Converts Unicode text to 8-bit, using the specified character set converter. 

@param aUnicode The Unicode text to be converted.

@param aNarrow On return, the converted text.

@param aEncodingCharset Specifies the character set converter to use. */

	{

	User::LeaveIfError(CVersitParser::ConvertFromUnicodeToISOL(aNarrow, aUnicode, aEncodingCharset.iConverter));

	}

EXPORT_C void VersitUtils::AddEscapedString(TDes& aDestination,const TDesC& aTextToEscape,Versit::TVersitCharSet aCharSet)

/** Adds an escape character before the semi-colons in a given text string.

@param aDestination On return, the escaped text.

@param aTextToEscape Text to be escaped.

@param aCharSet A Versit character set identifier. */

	{

	AddEscapedString(aDestination,aTextToEscape,aCharSet==Versit::EShiftJISCharSet);

	}

EXPORT_C void VersitUtils::AddEscapedString(TDes& aDestination,const TDesC& aTextToEscape,TUint aCharSetId)

/** Adds an escape character before the semi-colons in a given text string. 

@param aDestination On return, the escaped text.

@param aTextToEscape Text to be escaped.

@param aCharSetId A character set ID. These are defined in charconv.h. */

	{

	AddEscapedString(aCharSetId==KCharacterSetIdentifierShiftJis,aDestination,aTextToEscape);

	}

void VersitUtils::AddEscapedString(TBool aIsShiftJis,TDes& aDestination,const TDesC& aTextToEscape)

	{

	const TInt length = aTextToEscape.Length();

	const TText* pText = aTextToEscape.Ptr();

	const TDesC &escapeChar = EscapeChar(aIsShiftJis);

	const TText* pEscape = escapeChar.Ptr();

	for(TInt ii=0; ii<length; pText++, ii++)

		{

		if	(*pText==KVersitSemiColon || *pText==*pEscape)

			{

			aDestination.Append(escapeChar);

			}

		aDestination.Append(*pText);

		}

	}

EXPORT_C void VersitUtils::ConArcEncodeL(RReadStream& aReadStream, CBufBase& aTarget, TUid aConArcEncodingUid)

/** Encodes a buffer using the specified character set converter. 

@param aSource Buffer to be encoded.

@param aTarget On return, the encoded buffer.

@param aConArcEncodingUid Converter UID, as returned by VersitUtils::ConArcEncodingUid(). */

	{

	__ASSERT_DEBUG(aConArcEncodingUid != KNullUid, User::Invariant());

	if	(aConArcEncodingUid != KNullUid)

		{

		CCnaConverterList* converterList = CCnaConverterList::NewLC();

		CConverterBase* converter = converterList->NewConverterL(aConArcEncodingUid);

		__ASSERT_DEBUG(converter, User::Invariant());

		if	(!converter)

			{

			CleanupStack::PopAndDestroy(converterList);

			return;

			}

		CleanupStack::PushL(converter);	

		RBufWriteStream writeStream;

		writeStream.Open(aTarget);

		converter->ConvertObjectL(aReadStream, writeStream);

		writeStream.Close();

		CleanupStack::PopAndDestroy(2, converterList);	// converter, convList

		}

	}

EXPORT_C void VersitUtils::WrapLinesL(CBufBase& aBuffer, TInt aMaxLineLength)

/** Ensures that a buffer doesn't contain any lines longer than the specified length. 

Any lines longer than the specified length are wrapped.

@param aBuffer Buffer to be wrapped.

@param aMaxLineLength The maximum line length. */

	{

	_LIT8(KVersitLineIndent, "    ");

	const TInt KLineIndentLength = KVersitLineIndent().Length();

	const TInt KCarriageReturnLineFeedLength = 2;

	const TInt length = aBuffer.Size();

	//

	TInt pos = 0;

	TInt cycles = length / aMaxLineLength;

	if	(length % aMaxLineLength != 0)

		cycles++;

	//

	for(; cycles>0; pos += (aMaxLineLength + KLineIndentLength + KCarriageReturnLineFeedLength))

		{

		aBuffer.InsertL(pos, KVersitLineIndent);

		aBuffer.InsertL(pos, KVersitTokenCRLF);

		cycles--;

		}

	}

EXPORT_C TBool VersitUtils::CheckAndIgnoreCustomErrorL(TInt aError)

/** Tests whether an error code is Versit-specific or not and leaves (with that 

error code) if it is not.

@param aError Error code to test.

@return ETrue if the error code is Versit-specific. */

	{

	switch(aError)

		{

		case KVersitErrBadDateTime:			

		case KVersitErrRepeatTypeNotHandled:	

		case KVersitErrBadRepeatValue:			

		case KVersitErrBadTimeZone:		

		case KVersitErrBadTimePeriod:			

		case KVersitErrNumberExpected:

		case KVersitErrNestedVcardExpected:

		case KVersitErrNoPropertyName:

			return ETrue;

		default:;

		}

	//Standard Epoc Error

	User::LeaveIfError(aError);

	return EFalse;

	}

EXPORT_C void VersitUtils::RemoveEscapeChars(TPtr8& aText)

/** Removes escape characters (backslashes) from the specified 8-bit string. 

@param aText A raw 8-bit string value. */

	{

	TInt dest=aText.Find(KVersitEscapedSemiColon);