/*

* 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 <e32std.h>

#include <charconv.h>

#include "big5.h"

#include <ecom/implementationproxy.h>

#include <charactersetconverter.h>

class CBIG5ConverterImpl : public CCharacterSetConverterPluginInterface

	{

public:

	virtual const TDesC8& ReplacementForUnconvertibleUnicodeCharacters();

	virtual TInt ConvertFromUnicode(

		CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, 

		const TDesC8& aReplacementForUnconvertibleUnicodeCharacters, 

		TDes8& aForeign, 

		const TDesC16& aUnicode, 

		CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters);

	virtual TInt ConvertToUnicode(

		CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, 

		TDes16& aUnicode, 

		const TDesC8& aForeign, 

		TInt& aState, 

		TInt& aNumberOfUnconvertibleCharacters, 

		TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter);

	virtual TBool IsInThisCharacterSetL(

		TBool& aSetToTrue, 

		TInt& aConfidenceLevel, 

		const TDesC8& aSample);

	static CBIG5ConverterImpl* NewL();

	virtual ~CBIG5ConverterImpl();

private:

	CBIG5ConverterImpl();

	};

const TDesC8& CBIG5ConverterImpl::ReplacementForUnconvertibleUnicodeCharacters()

	{

	return CnvBig5::ReplacementForUnconvertibleUnicodeCharacters();

	}

TInt CBIG5ConverterImpl::ConvertFromUnicode(

		CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, 

		const TDesC8& aReplacementForUnconvertibleUnicodeCharacters, 

		TDes8& aForeign, 

		const TDesC16& aUnicode, 

		CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters)

	{

	return CCnvCharacterSetConverter::DoConvertFromUnicode(CnvBig5::ConversionData(), aDefaultEndiannessOfForeignCharacters, aReplacementForUnconvertibleUnicodeCharacters, aForeign, aUnicode, aIndicesOfUnconvertibleCharacters);

	}

TInt CBIG5ConverterImpl::ConvertToUnicode(

		CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, 

		TDes16& aUnicode, 

		const TDesC8& aForeign, 

		TInt& /*aState*/, 

		TInt& aNumberOfUnconvertibleCharacters, 

		TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter)

	{

	return CCnvCharacterSetConverter::DoConvertToUnicode(CnvBig5::ConversionData(), aDefaultEndiannessOfForeignCharacters, aUnicode, aForeign, aNumberOfUnconvertibleCharacters, aIndexOfFirstByteOfFirstUnconvertibleCharacter);

	}

TBool CBIG5ConverterImpl::IsInThisCharacterSetL(

		TBool& aSetToTrue, 

		TInt& aConfidenceLevel, 

		const TDesC8& aSample)

	{

	aSetToTrue=ETrue;

	TInt sampleLength = aSample.Length();

	aConfidenceLevel = 0;

	//WBB the following is for distiguish between big5 and GBK

	TInt totalWeight=0;		//sum of the weights of 20 most frequent chars

	TInt sumOfGoodChar=0;		//the number of chars whose first byte and second are both in the range

	TInt sumOfWeight=0;		//sum of the weights of the chars which are included in the sample

	TInt sumOutChar=0;		//the number of chars which are not common

	TInt sumOfBadSecondByte=0;//the number of chars whose first byte is in the range but not the second

	TInt sumOfBadSingleByte=0;	//the number of bad single byte, which is not in valid range

	struct referenceChar

		{

		TUint charBig5;

		TInt weight;

		};

	referenceChar refBig5[20];

	static const TInt iniWeight[20]=

		{

		//occurence per 1000 chars

		30,20,20,10,10,10,10,10,5,5,

		5,5,5,5,5,5,5,5,5,5

		};

	static const TUint iniChar[20]=

		{

		0xa141,0xaaba,0xa446,0xadd3,0xa4a3,0xa7e2,0xa440,0xac4f,0xad6e,0xa45d,

		0xa4d1,0xa457,0xa457,0xa94d,0xa4a4,0xa569,0xa662,0xa470,0xa448,0xa455

		};

	for (TInt k=0; k<20; k++)

		{

		refBig5[k].charBig5=iniChar[k];

		refBig5[k].weight=iniWeight[k];

		totalWeight=totalWeight+iniWeight[k];

		}

	//WBB

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

		{

		// Big 5 encoding first byte range 0xA1-0xFE 

		//                second byte range 0x40-0x7E  0xA1-0xFE

		if((aSample[i] >= 0xa1) && (aSample[i] <= 0xfe))

			{

			TInt increment1 = i+1;

			if (increment1 >= sampleLength)

				break;

			if(((aSample[increment1] >= 0x40) && (aSample[increment1] <= 0x7e)) ||

				((aSample[increment1] >= 0xa1) && (aSample[increment1] <= 0xfe)))

				{

				TUint charBig5=(aSample[i]<<8)|(aSample[increment1]);

				if (charBig5>=0xc6a1)//Kanas start and rare chars follow after 

					sumOutChar++;

				TInt j;

				for (j=0; j<20; j++)

					{

					if (charBig5==refBig5[j].charBig5)

						{

						sumOfWeight=sumOfWeight+refBig5[j].weight;

						break;

						}

					}

				sumOfGoodChar++;

				i++;

				}

			else

				{

				sumOfBadSecondByte++;

				}

			}

		// if seldom used characters

		else if (aSample[i] < 0x20 || aSample[i] > 0x7F ) 

			{

			if (aSample[i]!=0x09 && aSample[i]!=0x0A && aSample[i]!=0x0D)

				sumOfBadSingleByte++;

			}

		} // for 

	if (sumOfGoodChar)

		{

		aConfidenceLevel=sumOfGoodChar*100/(sumOfBadSecondByte+sumOfGoodChar+sumOfBadSingleByte);

		aConfidenceLevel=aConfidenceLevel-Max(0,((totalWeight-sumOfWeight)*sumOfGoodChar/1000));//against frequent chars 

		aConfidenceLevel=aConfidenceLevel-sumOutChar*100/sumOfGoodChar;//against gap

		aConfidenceLevel=(aConfidenceLevel < 0)?0:aConfidenceLevel;

		}

	else

		aConfidenceLevel=0;

	return ETrue;

	}

CBIG5ConverterImpl* CBIG5ConverterImpl::NewL()

	{

	CBIG5ConverterImpl* self = new(ELeave) CBIG5ConverterImpl();

	return self;

	}

CBIG5ConverterImpl::~CBIG5ConverterImpl()

	{

	}

CBIG5ConverterImpl::CBIG5ConverterImpl()

	{

	}

const TImplementationProxy ImplementationTable[] = 

	{

		IMPLEMENTATION_PROXY_ENTRY(0x10000FBF,CBIG5ConverterImpl::NewL)

	};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

	{

	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

	return ImplementationTable;

	}