// character_converter.cpp
// 
// Copyright (c) 2005 - 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "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:
// Accenture - Initial contribution
//


#include "character_converter.h"

const TInt KSlack = 20;


CCharacterConverter* CCharacterConverter::NewL(TInt aMaxBlockSize, RFs& aFs, TUint aCharset)
	{
	CCharacterConverter* self = new(ELeave) CCharacterConverter(aMaxBlockSize, aFs, aCharset);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CCharacterConverter::~CCharacterConverter()
	{
	delete iCharSets;
	delete iConverter;
	delete iNarrowBuf;
	delete iWideBuf;
	}

const TDesC& CCharacterConverter::ConvertChunkL(const TDesC8& aNarrowBuf, TChunkType aType)
	{
	ASSERT(aNarrowBuf.Length() <= iMaxBlockSize);

	switch (aType)
		{
		case EFirst:
			{
			iCharConvState = CCnvCharacterSetConverter::KStateDefault;
			iNarrowPtr = aNarrowBuf;
			if (iCharset == 0)
				{
				// Only spend time autodetecting if we haven't been told the charset to use
				const TUint16* p = (const TUint16*)aNarrowBuf.Ptr();
				if ((*p == 0xFEFF) || (*p == 0xFFFE))
					{
					iNarrowPtr.Delete(0, 2);
					iCharset = (*p == 0xFEFF) ? KCharacterSetIdentifierUnicodeLittle : KCharacterSetIdentifierUnicodeBig;
					}
				else
					{
					iCharSets = CCnvCharacterSetConverter::CreateArrayOfCharacterSetsAvailableL(iFs);
					TInt confidenceLevel;
					CCnvCharacterSetConverter::AutoDetectCharacterSetL(confidenceLevel, iCharset, *iCharSets, iNarrowPtr.Left(32));
					}
				}
			iConverter->PrepareToConvertToOrFromL(iCharset, iFs);
			}	// Deliberate fall through.
		case EMiddle:
			{
			if (aType == EMiddle)
				{
				iNarrowPtr += aNarrowBuf;
				}
			TInt numUnconvertibleChars;
			const TInt ret = iConverter->ConvertToUnicode(iWidePtr,	iNarrowPtr,	iCharConvState, numUnconvertibleChars);
			iNumUnconvertibleChars += numUnconvertibleChars;
			if (ret < 0)
				{
				User::Leave(ret);
				}
			else if (ret > KSlack)
				{
				User::Leave(KErrCorrupt);
				}
			else if (ret > 0)
				{
				iNarrowPtr = iNarrowPtr.Right(ret);
				}
			else
				{
				iNarrowPtr.Zero();
				}
			break;
			}
		case ELast:
			{
			iNarrowPtr += aNarrowBuf;
			TInt numUnconvertibleChars;
			const TInt ret = iConverter->ConvertToUnicode(iWidePtr,	iNarrowPtr,	iCharConvState, numUnconvertibleChars);
			iNumUnconvertibleChars += numUnconvertibleChars;
			if (ret < 0)
				{
				User::Leave(ret);
				}
			else if (ret > 0)
				{
				User::Leave(KErrCorrupt);
				}
			iNarrowPtr.Zero();
			break;
			}
		default:
			{
			ASSERT(EFalse);
			}
		}

	return iWidePtr;
	}

CCharacterConverter::CCharacterConverter(TInt aMaxBlockSize, RFs& aFs, TUint aCharset)
	: iFs(aFs), iMaxBlockSize(aMaxBlockSize), iNarrowPtr(NULL, 0), iWidePtr(NULL, 0), iCharset(aCharset)
	{
	}

void CCharacterConverter::ConstructL()
	{
	iNarrowBuf = HBufC8::NewL(iMaxBlockSize + KSlack);
	iWideBuf = HBufC16::NewL(iMaxBlockSize + KSlack);
	iNarrowPtr.Set(iNarrowBuf->Des());
	iWidePtr.Set(iWideBuf->Des());
	iConverter = CCnvCharacterSetConverter::NewL();
	}