/*
* Copyright (c) 2008-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: 
*
*/
// There are 2 reasons why not use existing unicodeconv.cpp:
// 1) "unicode->foreign" in existing unicodeconv.cpp is quite slow, especially
//    for huge code pages (e.g, Asia code pages). See INC127598.
//
// 2) GB18030 has 32-bit code that existing unicodeconv.cpp cannot handle.
//
// The algorithm of this special version unicodeconv.cpp is straightforward:
// 1) foreign->unicode:
//    1.1) 1 byte/2 byte->unicode bmp: use existing mechanism; mapping table in
//              "cp54936_2byte_tounicode.cpp", which is generated with command
//              "perl -w ..\group\FatConversionTable.pl cp54936_2byte.txt".
//
//    1.2) 4 byte->unicode bmp: convert the 4-byte code to a 16-bit index, then
//              search into the mapping table in "cp54936_4byte_tounicode.cpp",
//              which is generated with command
//              "perl -w ..\group\cp54936_4byte_tounicode.pl cp54936_4byte.txt".
//
//    1.3) 4 byte->unicode non-bmp: calculate with formula in this file.
//
// 2) unicode->foreign:
//    2.1) unicode bmp->1/2/4 byte: the huge table in "cp54936_allbmp_fromunicode.cpp"
//              can map directly, which is generated with command
//              "perl -w ..\group\cp54936_allbmp_fromunicode.pl cp54936_2byte.txt cp54936_4byte.txt".
//
//    2.2) unicode non-bmp->4 byte: calculate with formula in this file.
//
// The function cp54936_2byte_tounicode.cpp::TConvDataStruct::
// ConvertSingleUnicode() is not used anymore. It's reserved just because not
// changing the tool FatConversionTable.pl.
//
// About the mapping table "cp54936_2byte.txt" and "cp54936_4byte.txt":
// 1) All Private Used Area (PUA) code points are reserved.
// 2) All GB18030 code points that mapping to undefined Unicode are reserved.
//
//
// About the formula for non-bmp calculation:
// 1) All code points from 0x10000 to 0x10FFFF are supported.
// 2) Code points in 0x10000-0x1FFFF and 0x30000-0x10FFFF are summarized from
//    the GB18030 standard, since the standard does not define the mapping for
//    code points out of 0x20000-0x2FFFF.


#include <e32std.h>
#include <e32def.h>
#include <e32des8.h> 
#include "unicodeconv.h"
#include "cp54936.h"


enum TFccPanic
	{
	EBadForeignCode = 0,
	E4ByteIndexOutOfRange,
	EPanicBadIndices1,
	EInavlidUnicodeValue
	};
void Panic(TFccPanic aPanic)
	{

	User::Panic(_L("FatCharsetConv"),aPanic);
	}


//replacement character to be used when unicode cannot be converted
const TUint8 KForeignReplacement = 0x5F;

const TUint8 KU10000Byte1 = 0x90;
const TUint8 KU10000Byte2 = 0x30;
const TUint8 KU10000Byte3 = 0x81;
const TUint8 KU10000Byte4 = 0x30;

inline TBool IsSupplementary(TUint aChar)
/**
@param aChar The 32-bit code point value of a Unicode character.

@return True, if aChar is supplementary character; false, otherwise.
*/
	{
	return (aChar > 0xFFFF);
	}

inline TBool IsSurrogate(TText16 aInt16)
/**
@return True, if aText16 is high surrogate or low surrogate; false, otherwise.
*/
	{
	return (aInt16 & 0xF800) == 0xD800;
	}

inline TBool IsHighSurrogate(TText16 aInt16)
/**
@return True, if aText16 is high surrogate; false, otherwise.
*/
	{
	return (aInt16 & 0xFC00) == 0xD800;
	}

inline TBool IsLowSurrogate(TText16 aInt16)
/**
@return True, if aText16 is low surrogate; false, otherwise.
*/
	{
	return (aInt16 & 0xFC00) == 0xDC00;
	}

inline TUint JoinSurrogate(TText16 aHighSurrogate, TText16 aLowSurrogate)
/**
Combine a high surrogate and a low surrogate into a supplementary character.

@return The 32-bit code point value of the generated Unicode supplementary
        character.
*/
	{
	return ((aHighSurrogate - 0xD7F7) << 10) + aLowSurrogate;
	}

inline TText16 GetHighSurrogate(TUint aChar)
/**
Retrieve the high surrogate of a supplementary character.

@param aChar The 32-bit code point value of a Unicode character.

@return High surrogate of aChar, if aChar is a supplementary character; 
        aChar itself, if aChar is not a supplementary character.
*/
	{
	return STATIC_CAST(TText16, 0xD7C0 + (aChar >> 10));
	}

inline TText16 GetLowSurrogate(TUint aChar)
/**
Retrieve the low surrogate of a supplementary character.

@param aChar The 32-bit code point value of a Unicode character.

@return Low surrogate of aChar, if aChar is a supplementary character; 
        zero, if aChar is not a supplementary character.
*/
	{
	return STATIC_CAST(TText16, 0xDC00 | (aChar & 0x3FF));
	}

//This function converts from Unicoded characters, to foreign characters and adds them into a descriptor
EXPORT_C void UnicodeConv::ConvertFromUnicodeL(TDes8& aForeign, const TDesC16& aUnicode)
	{
    UnicodeConv::ConvertFromUnicodeL(aForeign, aUnicode, ETrue);
    }

//This function converts from Unicoded characters, to foreign characters and adds them into a descriptor
EXPORT_C TInt UnicodeConv::ConvertFromUnicodeL(TDes8& aForeign, const TDesC16& aUnicode, TBool leaveWhenOverflow)
	{
	const TInt length = aUnicode.Length();
	const TUint16* unicode = aUnicode.Ptr();
	const TUint16* guard = unicode + length;
	
	TUint8* foreign = const_cast<TUint8*>(aForeign.Ptr());
	TUint8* foreignguard = foreign + aForeign.MaxLength();
	
	//loop going through the character of the unicode descriptor
	while (unicode < guard)
		{
		TUint32 unicodeChar = *unicode++;
		if (IsHighSurrogate(unicodeChar))
			{
			if (unicode >= guard || !IsLowSurrogate(*unicode))
				{
				if (foreign >= foreignguard)
					{
                    aForeign.SetLength(foreign-aForeign.Ptr());
					if (leaveWhenOverflow)
						User::Leave(KErrOverflow);
                    else
                    	return KErrOverflow;
					}
				*foreign++ = KForeignReplacement;
				continue;
				}
			unicodeChar = JoinSurrogate(unicodeChar, *unicode++);
			}
		if (IsLowSurrogate(unicodeChar))
			{
			if (foreign >= foreignguard)
				{
				aForeign.SetLength(foreign-aForeign.Ptr());
				if (leaveWhenOverflow)
					User::Leave(KErrOverflow);
				else
					return KErrOverflow;
				}
			*foreign++ = KForeignReplacement;
			continue;
			}
		
		TUint8 b1, b2, b3, b4;		// byte 1,2,3,4 of result GB18030 code.
		TInt count;					// byte count of result GB18030 code; can be 1, 2 or 4.
		
		// unicode to cp54936
		if (IsSupplementary(unicodeChar))
			{
			unicodeChar -= 0x10000;
			b4 = unicodeChar % 10 + KU10000Byte4;
			unicodeChar /= 10;
			b3 = unicodeChar % 126 + KU10000Byte3;
			unicodeChar /= 126;
			b2 = unicodeChar % 10 + KU10000Byte2;
			b1 = unicodeChar / 10 + KU10000Byte1;
			count = 4;
			}
		else
			{
			TUint32 foreignChar;
			foreignChar = KMappingTableUnicodeBmp2CP54936[unicodeChar];
			b1 = ((foreignChar >> 24) & 0xFF);
			b2 = ((foreignChar >> 16) & 0xFF);
			b3 = ((foreignChar >> 8) & 0xFF);
			b4 = (foreignChar & 0xFF);
			count = 1;
			if (b1)
				{
				count = 4;
				}
			else
				{
				__ASSERT_DEBUG(b2==0, Panic(EBadForeignCode));
				if (b3)
					{
					count = 2;
					}
				}
			}
		
		if (foreign + count > foreignguard)
			{
			aForeign.SetLength(foreign-aForeign.Ptr());
            if (leaveWhenOverflow)
            	User::Leave(KErrOverflow);
            else
            	return KErrOverflow;
			}
		if (count == 4)
			{
			*foreign++ = b1;
			*foreign++ = b2;
			}
		if (count >= 2)
			*foreign++ = b3;
		*foreign++ = b4;
		}
	aForeign.SetLength(foreign-aForeign.Ptr());
	return KErrNone;
	}


//This function converts from foreign characters into unicode and adds them into a descriptor
EXPORT_C void UnicodeConv::ConvertToUnicodeL(TDes16& aUnicode, const TDesC8& aForeign)
	{
    UnicodeConv::ConvertToUnicodeL(aUnicode, aForeign, ETrue);
    }

//This function converts from foreign characters into unicode and adds them into a descriptor
EXPORT_C TInt UnicodeConv::ConvertToUnicodeL(TDes16& aUnicode, const TDesC8& aForeign, TBool leaveWhenOverflow)
	{
	const TInt foreignLength = aForeign.Length();
	const TUint8* foreign = aForeign.Ptr();
	const TUint8* guard = foreign + foreignLength;
	
	TUint16* unicode = const_cast<TUint16*>(aUnicode.Ptr());
	TUint16* unicodeguard = unicode + aUnicode.MaxLength();
	
	TUint8 b1, b2, b3, b4;
	enum TCodeType
	{
	E1Byte = 0,
	E2Byte,
	E4ByteBmp,
	E4ByteSupplementary,
	EError,
	};
	TCodeType codetype;
	TUint32 unicodeChar;

	//loop going through the characters of the foreign descriptor
	while (foreign < guard)
		{
		// roughly, detect which area the foreign code belongs to
		b1 = *foreign++;
		if (b1 <= 0x7F)
			codetype = E1Byte;
		else if (b1 == 0x80 || b1 > 0xFE)
			codetype = EError;
		else if (foreign >= guard)
			codetype = EError;
		else
			{
			b2 = *foreign++;
			if (b2 >= 0x40 && b2 <= 0xFE && b2 != 0x7F)
				codetype = E2Byte;
			else if (b2 < 0x30 || b2 > 0x39)
				codetype = EError;
			else if (foreign+1 >= guard)
				codetype = EError;
			else
				{
				b3 = *foreign++;
				if (b3 < 0x81 || b3 > 0xFE)
					codetype = EError;
				else
					{
					b4 = *foreign++;
					if (b4 < 0x30 || b4 > 0x39)
						codetype = EError;
					else if (b1 >= 0x81 && b1 <= 0x84)		// 0x81308130-0x8439FE39
						codetype = E4ByteBmp;
					else if (b1 >= 0x90 && b1 <= 0xE3)		// 0x90308130-0xE339FE39
						codetype = E4ByteSupplementary;
					else
						codetype = EError;					// others are reserved
					}
				}
			}
		
		// cp54936 to unicode
		if (codetype == E1Byte)
			{
			unicodeChar = b1;
			}
		else if (codetype == E2Byte)
			{
			// conventional algorithm used in FatCharsetConv
			const TLeadOrSingle* structPtr = TConvDataStruct::KFirstByteConversions + (b1-0x80);
			if (structPtr->iUnicodeIfSingle)
				unicodeChar = structPtr->iUnicodeIfSingle;
			else if (TConvDataStruct::KMinTrailByte <= b2 && b2 <= TConvDataStruct::KMaxTrailByte)
				unicodeChar = TConvDataStruct::KDoubleByteConversions[structPtr->iDoubleByteIndex + (b2 - TConvDataStruct::KMinTrailByte)];
			else
				unicodeChar = 0xFFFD;
			}
		else if (codetype == E4ByteBmp)
			{
			TUint index = (b1-0x81)*12600 + (b2-0x30)*1260 + (b3-0x81)*10 + (b4-0x30);
			__ASSERT_DEBUG(index<39420, Panic(E4ByteIndexOutOfRange));
			unicodeChar = KMappingTable4ByteBmp2Unicode[index];
			}
		else if (codetype == E4ByteSupplementary)
			{
			unicodeChar = 0x10000 + (b1 - KU10000Byte1) * 12600 +
									(b2 - KU10000Byte2) * 1260 +
									(b3 - KU10000Byte3) * 10 +
									(b4 - KU10000Byte4);
			__ASSERT_DEBUG(unicodeChar >= 0x10000 && unicodeChar <= 0x10FFFF, Panic(EInavlidUnicodeValue));
			}
		else
			{
			unicodeChar = 0xFFFD;
			}
		
		// append to output buffer
		if (IsSupplementary(unicodeChar))
			{
			if (unicode + 1 >= unicodeguard)
				{
				aUnicode.SetLength(unicode-aUnicode.Ptr());
				if (leaveWhenOverflow)
					User::Leave(KErrOverflow);
				else
					return KErrOverflow;
				}
			*unicode++ = GetHighSurrogate(unicodeChar);
			*unicode++ = GetLowSurrogate(unicodeChar);
			}
		else
			{
			if (unicode >= unicodeguard)
				{
				aUnicode.SetLength(unicode-aUnicode.Ptr());
                if (leaveWhenOverflow)
                	User::Leave(KErrOverflow);
                else
                	return KErrOverflow;
				}
			*unicode++ = unicodeChar;
			}
		}
	aUnicode.SetLength(unicode-aUnicode.Ptr());
	return KErrNone;
	}

EXPORT_C TBool UnicodeConv::IsLegalShortNameCharacter (TUint aCharacter)
	{
	//1. aCharacter >= 0x0080 
	if (aCharacter>=0x0080)
		{
		// Since all Unicode characters can be mapped to GB18030, so no need to
		// test the converting.
		if (aCharacter <= 0x10FFFF && !IsSurrogate(aCharacter))
			return ETrue;
		else
			return EFalse;
		}

    // For most common cases: 
    // Note: lower case characters are considered legal DOS char here. 
	if ((aCharacter>='a' && aCharacter<='z') || 
	    (aCharacter>='A' && aCharacter<='Z') || 
	    (aCharacter>='0' && aCharacter<='9'))
			{
			return ETrue;
			}
    // Checking for illegal chars: 
    // 2. aCharacter <= 0x20 
    // Note: leading 0x05 byte should be guarded by callers of this function 
    //  as the information of the position of the character is required. 
	if (aCharacter < 0x20)
		return EFalse;
	// Space (' ') is not considered as a legal DOS char here.
	if (aCharacter == 0x20)
		return EFalse;
	
	// 3. 0x20 < aCharacter < 0x80 
    // According to FAT Spec, "following characters are not legal in any bytes of DIR_Name": 
    switch (aCharacter) 
            { 
            case 0x22:        // '"' 
            case 0x2A:        // '*' 
            case 0x2B:        // '+' 
            case 0x2C:        // ',' 
            //case 0x2E:        // '.'   // Although '.' is not allowed in any bytes of DIR_Name, it 
                                         // is a valid character in short file names. 
            case 0x2F:        // '/' 
            case 0x3A:        // ':' 
            case 0x3B:        // ';' 
            case 0x3C:        // '<' 
            case 0x3D:        // '=' 
            case 0x3E:        // '>' 
            case 0x3F:        // '?' 
            case 0x5B:        // '[' 
            case 0x5C:        // '\' 
            case 0x5D:        // ']' 
            case 0x7C:        // '|' 
            	return EFalse; 
            default: 
            	return ETrue; 
            } 
	}