/*

* Copyright (c) 1997-2005 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

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

#include <ecom/implementationproxy.h>

#include "charactersetconverter.h"

/**

Shift-JIS character converter wrapper

@internalTechnology 

@released 9.1

*/

class CShiftJisConverterImpl : 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 CShiftJisConverterImpl* NewL();

	virtual ~CShiftJisConverterImpl();

private:

	CShiftJisConverterImpl();

	void ConstructL();

	};

/**

Get the the Shift-JIS byte sequence which will replace any Unicode characters which can't be converted.

@return The Shift-JIS byte sequence which will replace any Unicode characters which can't be converted.

@internalTechnology 

*/

const TDesC8& CShiftJisConverterImpl::ReplacementForUnconvertibleUnicodeCharacters()

	{

	return CnvShiftJis::ReplacementForUnconvertibleUnicodeCharacters();

	}

TInt CShiftJisConverterImpl::ConvertFromUnicode(

		CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, 

		const TDesC8& aReplacementForUnconvertibleUnicodeCharacters, 

		TDes8& aForeign, 

		const TDesC16& aUnicode, 

		CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters)

	{

	return CnvShiftJis::ConvertFromUnicode(aDefaultEndiannessOfForeignCharacters, aReplacementForUnconvertibleUnicodeCharacters, aForeign, aUnicode, aIndicesOfUnconvertibleCharacters);

	}

/**

 Converts Shift-JIS encoded input text to Unicode

 NOTE: For debugging the selected character set is returned in the state.

  @released  9.1

  @param     aDefaultEndiannessOfForeignCharacters The default endian-ness to use when reading characters

             in the foreign character set.

  @param     aUnicode On return, contains the text converted into Unicode.

  @param     aForeign The non-Unicode source text to be converted.

  @param     aState Used to save state information across multiple calls

             to <code>ConvertToUnicode()</code>.

  @param     aNumberOfUnconvertibleCharacters On return, contains the number of bytes which were not

             converted.

  @param     aIndexOfFirstByteOfFirstUnconvertibleCharacter On return, contains the index of the first bytein the

             input text that could not be converted. A negative

             value indicates that all the characters were

             converted.

  @return 	 The number of unconverted bytes left at the end of the input descriptor 

 		     (e.g. because the output descriptor is not long enough to hold all the text), 

 		     or one of the error values defined in TError. 

  @internalTechnology 

*/

TInt CShiftJisConverterImpl::ConvertToUnicode(

		CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, 

		TDes16& aUnicode, 

		const TDesC8& aForeign, 

		TInt& /*aState*/, 

		TInt& aNumberOfUnconvertibleCharacters, 

		TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter)

	{

	return CnvShiftJis::ConvertToUnicode(aDefaultEndiannessOfForeignCharacters, aUnicode, aForeign, aNumberOfUnconvertibleCharacters, aIndexOfFirstByteOfFirstUnconvertibleCharacter);

	}

/**

 This API is used by CCnvCharacterSetConverter::AutoDetectCharacterSetL(). 

 This method returns a value between 0 and 100, indicating how likely it 

 is that this is the correct converter, for the text supplied.  

 @internalTechnology 

 */

TBool CShiftJisConverterImpl::IsInThisCharacterSetL(

		TBool& aSetToTrue, 

		TInt& aConfidenceLevel, 

		const TDesC8& aSample)

	{

	aSetToTrue=ETrue;

	TInt sampleLength = aSample.Length();

	aConfidenceLevel = 0;

	TInt numberOfShiftJis=0;

	TInt occurrence=0;

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

		{

		// Check for JISX 0208:1997 Charset

		// First Byte in range 0x81-0x9f, 0xe0-0xef

		if (((aSample[i] >= 0x81) && (aSample[i] <= 0x9f)) ||

			((aSample[i] >= 0xe0) && (aSample[i] <= 0xef)))

			{

			// check that the second byte is in range as well 

			TInt increment1 = i+1;

			if(increment1 >= sampleLength)

				break;

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

				((aSample[increment1] >= 0x80) && (aSample[increment1] <= 0xfc)))

				{

				// increase the confidence of this sample as ShiftJis

				aConfidenceLevel=(aConfidenceLevel >0)?aConfidenceLevel+5:60;

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

				if ((charShiftJis>=0x829f)&&(charShiftJis<=0x82f1)||

					(charShiftJis>=0x8340)&&(charShiftJis<=0x8396))//those are kanas range

					occurrence++;

				numberOfShiftJis++;

				i++;

				}

			}

		// Check That no other Japanese escape sequence occur... if they do, cancel this and return 0

		// eg EUC-JP's SS(Single shift) characters followed by the

		if(aSample[i]==0x8e)

			{

			TInt increment1 = i+1;

			if(increment1 >= sampleLength)

				break;

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

				{

				// This could be EUC-JP format..

				aConfidenceLevel=0;

				i++;

				}

			}

		if(aSample[i]==0x8f)

			{

			TInt increment1 = i+1;

			TInt increment2 = i+2;

			if((increment1 >= sampleLength) || (increment2 >= sampleLength))

				break;

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

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

				{

				// 	This is definitely EUC-JP format. 

				aConfidenceLevel=0;

				break;

				}

			}

        // Check the half width Katakana

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

            {

            // increase the confidence of this sample as ShiftJis

            aConfidenceLevel=(aConfidenceLevel > 0) ? aConfidenceLevel+5 : 75;

            occurrence++;

            numberOfShiftJis++;

            }

        else if (aSample[i]>=0xf0)

            {

            aConfidenceLevel=0;

            }

		} // for 

	if(numberOfShiftJis)

		{

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

		aConfidenceLevel=aConfidenceLevel-Max(0,(30-occurrence*100/numberOfShiftJis));

		}

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

	return ETrue;

	}

CShiftJisConverterImpl* CShiftJisConverterImpl::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CShiftJisConverterImpl::~CShiftJisConverterImpl()

	{

	}

CShiftJisConverterImpl::CShiftJisConverterImpl()

	{

	}

void CShiftJisConverterImpl::ConstructL()

	{

	}

const TImplementationProxy ImplementationTable[] = 

	{

		IMPLEMENTATION_PROXY_ENTRY(0x10000FBD,	CShiftJisConverterImpl::NewL)

	};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

	{

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

	return ImplementationTable;

	}