/*

* 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 <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;

// Local method declarations.

LOCAL_C TInt RemapVietnameseAccentedCharacter(TUint16 aChr);

//

// 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++)

			{

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

#ifdef RD_HINDI_PHONETIC_INPUT

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

#endif

                )

				{

				aResult->AppendL(iLanguages->At(i)->LanguageCode());

#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

				{

				return KErrCorrupt;

				}

			}	

		}

	return KErrNotFound;

	}

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

// CPtiEngineImpl::SetCurrentWord

// 

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

//

TInt CPtiEngineImpl::SetCurrentWord(TPtrC aWord)

	{

	if (aWord.Length() == 0)

		{

		return KErrNone;

		}

	if (IsCore())

		{

		if (aWord.Length() > iTextBuffer.MaxLength())

			{

			return KErrTooBig;

			}

		// Predictive QWERTY (XT9) changes ---->

		// The core may choose to ignore the resetting of the input sequence.

		// We should be prepared for that and make sure that the internal

		// state of the PtiEngine is consistent with the one in the core.

		/* Code which was replaced:

		iTextBuffer.Copy(aWord);

		ConvertToKeySequence(aWord, iInputSequence);

		MakeCaseSequence(aWord);

		return Core()->SetCurrentInputSequence(iInputSequence);

		*/

		TInt err = 0;

		TRAP_IGNORE(

		{

		HBufC16* oldTextBuf = iTextBuffer.AllocLC(); 

		HBufC8* oldInputSeq = iInputSequence.AllocLC();

		HBufC8* oldCaseBuf = iCaseBuffer.AllocLC();

		iTextBuffer.Copy(aWord);

		ConvertToKeySequence(aWord, iInputSequence);

		MakeCaseSequence(aWord);

		err = Core()->SetCurrentInputSequence(iInputSequence);

		// InputSequence is not incorrect, as there is mismatch present when autocompletion part is displayed  

		if(err == KErrLengthMismatch /*&& !iMaxEditorLengthCrossed*/)

		    {

		    TInt tailLength = 0;

		    TInt err = Core()->HandleCommandL( EPtiCommandGetAutoCompletionTailLength, &tailLength );

		    if(tailLength > 0)

		        {

		        iInputSequence.SetLength(iTextBuffer.Length() - tailLength);