/*

* Copyright (c) 2003-2006 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:   Predective text input engine API implementation

*

*/

#include <f32file.h>

#include <barsc.h>

#include <barsread.h> 

#include "PtiEngineImpl.h"

#include "PtiDefaultCore.h"

#include "PtiLanguage.h"

#include <ptiengine.rsg>

#include "PtiUserDicEntry.h"

#include "PtiEngine.h"

#include "PtiKeyMappings.h"

#include <ecom/ecom.h>

#include <PtiHwrRecognizer.h>

#include <PtiKeyMapData.h>

#include <data_caging_path_literals.hrh> 

#ifdef RD_HINDI_PHONETIC_INPUT

#include <Languages.hrh>

#endif

#include <AknUtils.h>

#include <e32property.h>

#include <AknFepInternalCRKeys.h>

#include <AknFepInternalPSKeys.h>

#include <AvkonInternalCRKeys.h>

const TInt KDefaultLanguageGran = 5;

const TInt KDefaultLangNamesGran = 40;

const TInt KPhraseSeparator = 0x0020;

const TInt KMaxPhraseBufferSize = 255;

const TInt KMaxCandPages = 100;

const TInt KPtiChineseHash = 0xff03;

const TInt KPtiChineseStar = 0xff0a;

const TInt KPtiChinesePlus = 0xff0b;

const TInt KUserDictionaryMaxSize = 32768; 

const TInt KDirectlyAllowedScanCodesStart = 0x0021;

const TInt KDirectlyAllowedScanCodesEnd = 0x005f;

// This is needed for resource reading.

const TInt KCCMask(0x00000fff);

const TPtiKey qwertyKeys[] =

	{

	EPtiKeyQwerty1, EPtiKeyQwerty2, EPtiKeyQwerty3, EPtiKeyQwerty4, EPtiKeyQwerty5,

    EPtiKeyQwerty6, EPtiKeyQwerty7, EPtiKeyQwerty8, EPtiKeyQwerty9, EPtiKeyQwerty0,

#if defined(__WINS__)

	(TPtiKey)EStdKeyNkpPlus,  // Emulator produces different scancode for plus key than real hardware.

#else    

    EPtiKeyQwertyPlus, 

#endif    

    EPtiKeyQwertyMinus, EPtiKeyQwertyComma, EPtiKeyQwertySemicolon,EPtiKeyQwertyChr,EPtiKeyQwertyLeftShift,

    EPtiKeyQwertyFullstop, EPtiKeyQwertyHash, EPtiKeyQwertySlash, EPtiKeyQwertyApostrophe,    

    EPtiKeyQwertySpace,  EPtiKeyQwertyA, EPtiKeyQwertyB, EPtiKeyQwertyC, EPtiKeyQwertyD,

    EPtiKeyQwertyE, EPtiKeyQwertyF, EPtiKeyQwertyG, EPtiKeyQwertyH, EPtiKeyQwertyI,

    EPtiKeyQwertyJ, EPtiKeyQwertyK, EPtiKeyQwertyL, EPtiKeyQwertyM, EPtiKeyQwertyN,

    EPtiKeyQwertyO, EPtiKeyQwertyP, EPtiKeyQwertyQ, EPtiKeyQwertyR, EPtiKeyQwertyS,

    EPtiKeyQwertyT, EPtiKeyQwertyU, EPtiKeyQwertyV, EPtiKeyQwertyW, EPtiKeyQwertyX,

    EPtiKeyQwertyY, EPtiKeyQwertyZ, EPtiKeyQwertyAtCharacter, (TPtiKey)0

	};	

// Currently Japanese doesn't have real qwerty keymappings data file, but

// GetNumericModeKeysForQwertyL needs to work also for ELangJapanese. We'll handle

// it as a hardcoded special case for now.

const TInt KNumBindingsForNonLatinNumberLanguages = 15;

const TInt KNumExtendedBindingsForNonLatinNumberLanguages = 22;

const TPtiNumericKeyBinding NumericModeKeysForNonLatinNumberLanguages[] =

	{

	{'0', EPtiKeyQwerty0, EPtiCaseLower},

	{'1', EPtiKeyQwerty1, EPtiCaseLower},

	{'2', EPtiKeyQwerty2, EPtiCaseLower},

	{'3', EPtiKeyQwerty3, EPtiCaseLower},

	{'4', EPtiKeyQwerty4, EPtiCaseLower},

	{'5', EPtiKeyQwerty5, EPtiCaseLower},

	{'6', EPtiKeyQwerty6, EPtiCaseLower},

	{'7', EPtiKeyQwerty7, EPtiCaseLower},

	{'8', EPtiKeyQwerty8, EPtiCaseLower},

	{'9', EPtiKeyQwerty9, EPtiCaseLower},

	{'p', EPtiKeyQwertyP, EPtiCaseLower},

	{'w', EPtiKeyQwertyW, EPtiCaseLower},

	{'+', EPtiKeyQwertyPlus, EPtiCaseLower},

	{'#', EPtiKeyQwerty3, EPtiCaseUpper},

	{'*', EPtiKeyQwertyApostrophe, EPtiCaseUpper},

	{';', EPtiKeyQwertySemicolon, EPtiCaseLower},

	{'.', EPtiKeyQwertyFullstop, EPtiCaseLower},

	{',', EPtiKeyQwertyComma, EPtiCaseLower},

	{'-', EPtiKeyQwertyMinus, EPtiCaseLower},			

	{'E', EPtiKeyQwertyE, EPtiCaseUpper},

	{'?', EPtiKeyQwertySlash, EPtiCaseUpper},

	{'/', EPtiKeyQwertySlash, EPtiCaseLower}	

	};	

// Resource file name.

_LIT(KCEResourceFile, "z:PtiEngine.rsc");

_LIT(KNumericLangName, "Numeric");

_LIT(KPtiDefaultUdbPath, "c:\\Predic\\");

_LIT(KAllowedNumericChars, "0123456789pw+#*");

_LIT(KAllAllowedNumericChars, "*+pw#1234567890;.,-E?/");

_LIT(KExtendedNumericModeChars, ";.,-E?/");

#ifdef _DEBUG

_LIT(KPtiEngineImplPanic, "PtiEngineImpl");

#endif

// CONSTANTS

const TInt16 KStrokeHorizontalValue = 0x4e00; 

const TInt16 KStrokeVerticalValue = 0x4e28;

const TInt16 KStrokeDownToLeftValue = 0x4e3f;

const TInt16 KStrokeDownToRightValue = 0x4e36;

const TInt16 KStrokeBendingValue = 0x4e5b;

const TInt16 KStrokeQuestionValue = 0x003f;

const TInt16 KStrokeUnicode = 0x2461;

const TInt16 KZhuyinIndicator = 0x2462;

const TText KZhuyinTone2 = 0x02CA; // qwerty key6

const TText KZhuyinTone3 = 0x02C7; // qwerty key3

const TText KZhuyinTone4 = 0x02CB; // qwerty key4

const TText KZhuyinTone5 = 0x02D9; // qwerty key7

static const TUint KShortCombine = 0xF010;

const TInt KMaxMapping = 10;

// Local method declarations.

LOCAL_C TInt RemapVietnameseAccentedCharacter(TUint16 aChr);

LOCAL_C TBool IsRegionalLang(TInt aVariantCode, TInt& aMainCode)

    {   

    TBool ret = ETrue;

    switch(aVariantCode)

        {

        case ELangBrazilianPortuguese:

            aMainCode = ELangPortuguese;

            break;

        case ELangCanadianFrench:

            aMainCode = ELangFrench;

            break;

        case ELangLatinAmericanSpanish:

            aMainCode = ELangSpanish;

            break;

        case ELangEnglish_Taiwan:

        case ELangEnglish_HongKong:

        case ELangEnglish_Prc:

            aMainCode = ELangEnglish;

            break;

        default:

            aMainCode = aVariantCode; 

            ret = EFalse;

        }

    return ret;

    }

LOCAL_C TBool AlreadyExistLang(CArrayPtrFlat<CPtiCoreLanguage>* aLangArray, TInt aLangCode)

    {

    if (aLangArray)

        {

        for (TInt i=0; i < aLangArray->Count(); i++)

            {

            if (aLangArray->At(i)->LanguageCode() == aLangCode)

                {

                return ETrue;

                }

            }

        }

    return EFalse;

    }

const TUid KXt9ImplementationUid = {0x102830B9};

//

// CPtiEngineImpl implementation

//

// ---------------------------------------------------------------------------

// CPtiEngineImpl::NewL

// 

// ---------------------------------------------------------------------------

//

CPtiEngineImpl* CPtiEngineImpl::NewL(CPtiEngine* aFrontEnd)

	{

	CPtiEngineImpl *engine = new (ELeave) CPtiEngineImpl();

	CleanupStack::PushL( engine );

	engine->ConstructL(aFrontEnd);

	CleanupStack::Pop(); // engine

	return engine;

	}

// ---------------------------------------------------------------------------

// CPtiEngineImpl::CPtiEngineImpl

// 

// ---------------------------------------------------------------------------

//

CPtiEngineImpl::CPtiEngineImpl()

	{	

	}

// ---------------------------------------------------------------------------

// CPtiEngineImpl::~CPtiEngineImpl

// 

// ---------------------------------------------------------------------------

//

CPtiEngineImpl::~CPtiEngineImpl()

	{	

	iExtendedNumricSet.Close();

	DetachUserDictionaries();

	iUserDictionaries.ResetAndDestroy();	

	if (iCores)

		{

		iCores->ResetAndDestroy();

		delete iCores;

		}

	if (iLanguages)

		{

		iLanguages->ResetAndDestroy();

		delete iLanguages;

		}

	REComSession::FinalClose();		

	delete iCurrentHwrImpl;

	iImpIdList.Close();

	}

// ---------------------------------------------------------------------------

// CPtiEngineImpl::ConstructL

// 

// ---------------------------------------------------------------------------

//

void CPtiEngineImpl::ConstructL(CPtiEngine* aFrontEnd)

	{

	iFrontEnd = aFrontEnd;

	iLanguages = new( ELeave ) CArrayPtrFlat<CPtiCoreLanguage>( KDefaultLanguageGran ); 

	iCores = new (ELeave) CArrayPtrFlat<CPtiCore>( KDefaultCoresGran );

    TBuf<KPtiMaxWordSize > mapChars;

	mapChars.Zero();

	iPunctuationCharacters.Zero();

    MappingDataForKey((TPtiKey)EStdKeyFullStop,mapChars,EPtiCaseLower);

    iPunctuationCharacters.Copy(mapChars);

    MappingDataForKey((TPtiKey)EStdKeyFullStop,mapChars,EPtiCaseUpper);

    iPunctuationCharacters.Append(mapChars);

    MappingDataForKey((TPtiKey)EStdKeyFullStop,mapChars,EPtiCaseFnLower);

    iPunctuationCharacters.Append(mapChars);

    MappingDataForKey((TPtiKey)EStdKeyFullStop,mapChars,EPtiCaseFnUpper);

    iPunctuationCharacters.Append(mapChars);

	}

// ---------------------------------------------------------------------------

// CPtiEngineImpl::InitializeL

// 

// ---------------------------------------------------------------------------

//

void CPtiEngineImpl::InitializeL(TBool aUseDefaultUserDictionary)

	{

	CPtiCore* mtCore = CPtiDefaultCore::NewL(iFrontEnd, &iTextBuffer);

	CleanupStack::PushL(mtCore);

	iCores->AppendL( mtCore );

	CleanupStack::Pop(); // mtCore

	mtCore->InitializeL(iFrontEnd, &iTextBuffer, iLanguages, aUseDefaultUserDictionary);

	CPtiCoreLanguage* numLang = CreateNumericLanguageL(mtCore);

	CleanupStack::PushL(numLang);

	iLanguages->AppendL(numLang);

	CleanupStack::Pop(); // numLang

	LoadCoresInDefaultDirL(aUseDefaultUserDictionary);

	RefreshLanguageNamesL();

	}

// ---------------------------------------------------------------------------

// CPtiEngineImpl::GetLanguage

// 

// ---------------------------------------------------------------------------

//

MPtiLanguage* CPtiEngineImpl::GetLanguage(TInt aCode) const

	{

	const TInt count = iLanguages->Count();

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

		{

		if (iLanguages->At(i)->LanguageCode() == aCode)

			{

			return iLanguages->At(i);

			}	

		}

	return NULL;

	}

// ---------------------------------------------------------------------------

// CPtiEngineImpl::GetAvailableLanguagesL

// 

// ---------------------------------------------------------------------------

//

void CPtiEngineImpl::GetAvailableLanguagesL(CArrayFix<TInt>* aResult)

	{

	if (aResult)

		{		

		aResult->Reset();

		const TInt count = iLanguages->Count();

#ifdef RD_HINDI_PHONETIC_INPUT

              TBool isIndicPhoneticInputPresent = EFalse;

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

			{

			if (iLanguages->At(i)->LanguageCode() == KLangHindiPhonetic) 

				{			

				isIndicPhoneticInputPresent = ETrue;

				}

			}

#endif

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

			{

		    TInt code = 0;		    

			if ((iLanguages->At(i)->LanguageCode() != ELangNumeric)

#ifdef RD_HINDI_PHONETIC_INPUT

				&& (iLanguages->At(i)->LanguageCode() != KLangHindiPhonetic)

#endif

                )

				{

			    if(IsRegionalLang(iLanguages->At(i)->LanguageCode(),code))

                    {

                    if(AlreadyExistLang(iLanguages,code))

                        {

                        continue;

                        }

                    }

				aResult->AppendL(code);

#ifdef RD_HINDI_PHONETIC_INPUT

				if (iLanguages->At(i)->LanguageCode() == ELangHindi && isIndicPhoneticInputPresent)

					aResult->AppendL(KLangHindiPhonetic);

#endif

				}

			}

		}

	}

// ---------------------------------------------------------------------------

// CPtiEngineImpl::CreateUserDictionaryL

// 

// ---------------------------------------------------------------------------

//

TInt CPtiEngineImpl::CreateUserDictionaryL(TDesC& aFileName, CDesCArrayFlat* aWords, TPtiEngineInputMode aMode) 

	{

	CPtiCore* core = CoreForInputMode( aMode );

	if (!SupportsUserDictionaries(core))   

		{

		return KErrNotSupported;

		}

	CPtiUserDictionary* ud = core->CreateEmptyUserDictionaryL(KUserDictionaryMaxSize);

	CleanupStack::PushL(ud);

	ud->SetFileName( aFileName );

	ud->SetCoreUID(core->GetCoreInfo()->Uid());

	TInt error = core->AttachUserDictionary( ud );

	if (error != KErrNone)

		{

		CleanupStack::PopAndDestroy(); // ud

		return error;

		}

	User::LeaveIfError(iUserDictionaries.Append(ud));

	CleanupStack::Pop(); // ud

	for (TInt i = 0; i < aWords->Count(); i++)

		{

		TPtiUserDictionaryEntry entry(aWords->MdcaPoint(i));

		error = core->AddUserDictionaryEntry(entry, ud);		

		if (error != KErrNone)

			{

			return error;

			}

		}

	return KErrNone;

	}

// ---------------------------------------------------------------------------

// CPtiEngineImpl::AttachUserDictionaryL

// 

// ---------------------------------------------------------------------------

//

MPtiUserDictionary* CPtiEngineImpl::AttachUserDictionaryL(TDesC& aFileName)

	{

	TInt coreUid = ReadUidFromUserDictionaryFileL(aFileName);

	CPtiUserDictionary* ud = NULL;

	CPtiCore *core = FindCoreByUid(coreUid);

	if (!SupportsUserDictionaries(core))

		{		

		return NULL;

		}

	ud = core->CreateEmptyUserDictionaryL(KUserDictionaryMaxSize);

	CleanupStack::PushL(ud);

	TRAPD(err, ud->OpenL(aFileName, KUserDictionaryMaxSize));

	if (err == KErrCorrupt)

		{

		// Checksum didn't match or there was some other corruption.

		// Try to delete corrupted file and leave.

		RFs fsSession;

		User::LeaveIfError( fsSession.Connect() );

		fsSession.Delete(aFileName);		

		fsSession.Close();

		User::Leave(KErrCorrupt);

		}

	User::LeaveIfError(err);

	TInt error = core->AttachUserDictionary( ud );

	if (error != KErrNone)

		{

		CleanupStack::PopAndDestroy(); // ud

		return NULL;

		}

	User::LeaveIfError(iUserDictionaries.Append( ud ));

	CleanupStack::Pop(); // ud

	return ud;

	}

// ---------------------------------------------------------------------------

// CPtiEngineImpl::AttachDefaultUserDictionaryL

// 

// ---------------------------------------------------------------------------

//

MPtiUserDictionary* CPtiEngineImpl::AttachDefaultUserDictionaryL(TUid aCoreUid, TInt aSymbolClass)

	{

	TFileName fileName;

	CreateUserDictName(fileName, aCoreUid, aSymbolClass);	

	return AttachUserDictionaryL(fileName);		

	}

// ---------------------------------------------------------------------------

// CPtiEngineImpl::DetachUserDictionary

// 

// ---------------------------------------------------------------------------

//

TInt CPtiEngineImpl::DetachUserDictionary(TDesC& aFileName)

	{

	for (TInt i = 0; i < iUserDictionaries.Count(); i++)

		{

		if (!iUserDictionaries[i]->FileName().Compare(aFileName))

			{

			CPtiCore* core = FindCoreByUid(iUserDictionaries[i]->CoreUID());

			if (SupportsUserDictionaries(core))

				{

				if ((core->DetachUserDictionary(iUserDictionaries[i])) ||

					(iUserDictionaries[i]->UpdateFlag()))

					{

					TRAPD(err, iUserDictionaries[i]->WriteL());

					return err;

					}			

				}

			else

				{

				return KErrCorrupt;

				}

			delete iUserDictionaries[i];

			iUserDictionaries.Remove(i);

			return KErrNone;

			}	

		}

	return KErrNotFound;

	}

// ---------------------------------------------------------------------------

// CPtiEngineImpl::DetachUserDictionary

// 

// ---------------------------------------------------------------------------

//

TInt CPtiEngineImpl::DetachUserDictionary(TInt aId)

	{

	for (TInt i = 0; i < iUserDictionaries.Count(); i++)

		{

		if (iUserDictionaries[i]->Id() == aId)

			{

			CPtiCore* core = FindCoreByUid(iUserDictionaries[i]->CoreUID());

			if (SupportsUserDictionaries(core))

				{

				if ((core->DetachUserDictionary(iUserDictionaries[i])) ||

					(iUserDictionaries[i]->UpdateFlag()))

					{

					TRAPD(err, iUserDictionaries[i]->WriteL());

					return err;

					}			

				return KErrNone;

				}

			else

				{