/*

* Copyright (c) 2002-2004 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:           

*       Provides the TAknFepInputStateEntryWesternPredictive methods.

*

*/

#include "AknFepUiInputStateEntryWesternPredictive.h"

#include "AknFepUIManagerStateInterface.h"      //MAknFepUIManagerStateInterface

#include "AknFepManagerUIInterface.h"           //MAknFepManagerUIInterface

#include "AknFepManager.h"

#include "AknFepPanic.h"

#include "AknFepCaseManager.h"

#include "AknFepPluginManager.h"

#include "AknFepManagerInterface.h" // MAknFepManagerInterface

#include <aknedsts.h> 

#include <PtiEngine.h>                             //CPtiEngine

#include <PtiDefs.h>                            //keys

#include <featmgr.h>                //FeatureManager

#include <e32keys.h>

#include <PtiUserDicEntry.h>

// The Maximum world size

const TInt KMaxWordSize = 63;

TAknFepInputStateEntryWesternPredictive::

TAknFepInputStateEntryWesternPredictive(MAknFepUIManagerStateInterface* aOwner)

    :TAknFepInputStateBase(aOwner)

    {

    //this class insists on the existence of a case manager

    __ASSERT_DEBUG(iOwner->CaseMan(), AknFepPanic(EAknFepPanicNoCaseManager));

    MAknFepManagerUIInterface* fepMan = iOwner->FepMan();

    iState = EEntry;

    iMatchState = EWordMatchNone;

    CPtiEngine* ptiengine = iOwner->PtiEngine();

    TPtiTextCase caseMode = ptiengine->Case();

	ptiengine->SetInputMode(EPtiEnginePredictive);  

#ifdef RD_SCALABLE_UI_V2

    if (fepMan->PluginUIManager()->MatchCandidateList().Count() > 0)

        {

        fepMan->PluginUIManager()->ResetCandidateList();

        }

        iIsLastWord = EFalse;        

/*

    if (fepMan->PluginUIManager()->GetSpellText())

        {

        TBuf<CAknFepManager::EMaximumFepWordLength> textToUncommit;

        textToUncommit.Zero();

        textToUncommit.Copy(*fepMan->PluginUIManager()->GetSpellText());

        ptiengine->SetCurrentWord(textToUncommit); 

        }

*/        

#ifdef RD_INTELLIGENT_TEXT_INPUT

    	ptiengine->SetInputMode(EPtiEnginePredictive);  

        TBool isUnlimitedEditor = EFalse;

        ptiengine->SetMaxLengthForAutoCompletedCandidates(

                          fepMan->EditorFreeSpaceForAutoWordCompletion(isUnlimitedEditor ));

        // To set the input mode

        if(fepMan->IsAutoCompleteOn())

        	{

        	TRAP_IGNORE(ptiengine->HandleCommandL(EPtiCommandEnableAutoCompletion));

        	}

        else

        	{

        	TRAP_IGNORE(ptiengine->HandleCommandL(EPtiCommandDisableAutoCompletion));

        	}

        TPtiKeyboardType keyboard = fepMan->KeyboardLayout();

    	ptiengine->SetKeyboardType(keyboard);

    	TBool isNumberCandidateShown = fepMan->IsAdvancedPredictiveNumberCandidateShown();

    	TRAP_IGNORE(ptiengine->HandleCommandL( EPtiCommandSetNumberCandidateStatus, 

                 &isNumberCandidateShown ));

#endif

#else

    ptiengine->ClearCurrentWord();

#ifndef RD_INTELLIGENT_TEXT_INPUT

    // To set the input mode

    if(fepMan->IsAutoCompleteOn())

    	{

    	   ptiengine->SetInputMode(EPtiEngineWordCompletion);

    	}

#endif // RD_PRED_AW_COMPLETION

#endif //RD_SCALABLE_UI_V2

    ptiengine->SetCase(caseMode);

    }

TBool TAknFepInputStateEntryWesternPredictive::HandleKeyL(TInt aKey, TKeyPressLength aLength)

    {

    MAknFepManagerUIInterface* fepMan = iOwner->FepMan();

    CPtiEngine* ptiengine = iOwner->PtiEngine();

#ifdef RD_SCALABLE_UI_V2

    if (fepMan->PluginUIManager()->GetSpellText())

        {

        fepMan->PluginUIManager()->SpellText(NULL);

        }    

#endif //

    TBool response = ETrue;

    switch (aKey)

        {

    case EPtiKey1: //fall through

    case EPtiKey2:

    case EPtiKey3:

    case EPtiKey4:

    case EPtiKey5:

    case EPtiKey6:

    case EPtiKey7:

    case EPtiKey8:

    case EPtiKey9:

#ifdef RD_SCALABLE_UI_V2

        fepMan->PluginUIManager()->SetFingerMatchSelectionState(EFalse);    

#endif //RD_SCALABLE_UI_V2

        response = HandleStandardNumericKeysL(aKey, aLength);

        break;

    case EPtiKey0:

        if ( fepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction) )

            {

            fepMan->TryRemoveNoMatchesIndicatorL();

#ifndef RD_INTELLIGENT_TEXT_INPUT

 	    			// To rip off suggested word completion when user presses SPACE

				if(fepMan->IsAutoCompleteOn())

					{

					fepMan->RemoveSuggestedCompletionL();

					}

#endif

            }

        fepMan->UpdateCbaL(NULL);

        if (fepMan->IsFlagSet(CAknFepManager::EFlagCompoundWord))

            { 

            if (fepMan->IsCursorAtEndOfWord())

                {

                fepMan->AddCompoundWordToUdbL();                

                }

            fepMan->ClearFlag(CAknFepManager::EFlagCompoundWord);

            }		            

#ifdef RD_INTELLIGENT_TEXT_INPUT

        if ( fepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction) )

            {

            ptiengine->CommitCurrentWord();

			fepMan->CommitInlineEditL();

            fepMan->TryCloseUiL();

            response = EFalse;

            }

        else

        	{

#endif

		fepMan->SetDelayedCommit(); // Delayed 'commit'. 				                                        	

	    fepMan->TryCloseUiL();	                                

        response = EFalse;  //pass to initial state to handle key

#ifdef RD_INTELLIGENT_TEXT_INPUT

        	}

#endif        	

#ifdef RD_SCALABLE_UI_V2

        fepMan->PluginUIManager()->SetFingerMatchSelectionState(EFalse);    

#endif //RD_SCALABLE_UI_V2

        break;

    case EKeyLeftArrow: // fall through

    case EKeyRightArrow:

    case EKeyBackspace:

        response = HandleNaviKeysL(aKey, aLength);

#ifdef RD_SCALABLE_UI_V2

        fepMan->PluginUIManager()->SetFingerMatchSelectionState(EFalse);    

#endif //RD_SCALABLE_UI_V2

        break;

    case EPtiKeyStar:

            {

            response = HandleStarKeyL(aLength);    

            }

        break;

    case EKeyDownArrow: // Japanese input required

        if (fepMan->IsAbleScrollLatinPredictive())

            {

            if (fepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction))

                {

                DoNextMatch();

                }

            else

                {

                response = EFalse;

                }

            }

        else

            {

            response = EFalse;

            }

        break;

    case EKeyUpArrow: // Japanese input required

        if (fepMan->IsAbleScrollLatinPredictive())

            {

            if (fepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction))

                {

                DoPreviousMatchL();

                }

            else

                {

                response = EFalse;

                }

            }

        else

            {

            response = EFalse;

            }

        break;

    default:

        response = EFalse;

#ifdef RD_SCALABLE_UI_V2

        fepMan->PluginUIManager()->SetFingerMatchSelectionState(EFalse);            

#endif //RD_SCALABLE_UI_V2

        break;

        }

    return response;

    }

void TAknFepInputStateEntryWesternPredictive::HandleCommandL(TInt aCommandId)

    {

    MAknFepManagerUIInterface* fepMan = iOwner->FepMan();    

    if (aCommandId == EAknFepSoftkeyPrevious)

        {

        CPtiEngine* ptiengine = iOwner->PtiEngine();

        __ASSERT_DEBUG(fepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction), 

                       AknFepPanic(EAknFepPanicNotInsideInlineEdit));   

        if (iMatchState == EWordMatchLast || iMatchState == EWordMatchAfterLast)

            {

            fepMan->UpdateCbaL(R_AKNFEP_SOFTKEYS_EMPTY_PREVIOUS);

            }

        iMatchState = EWordMatchStd; 

        TPtrC prevText = ptiengine->PreviousCandidate();

        if(prevText.Length() == 1)

   			{

        	TDigitType digittype = fepMan->LocalDigit();

            TChar chchar(prevText[0]);

            if(!chchar.IsDigit() || (chchar.IsDigit() && !digittype))

            	{ 	

            	fepMan->UpdateInlineEditL(prevText, prevText.Length());    

            	}

            else 

            	{

            	TBuf<1> tempbuf;

	            tempbuf.Append(prevText[0]);

            	ConvertDigitToDigittype(digittype,tempbuf);

                fepMan->UpdateInlineEditL(tempbuf, tempbuf.Length());	

            	}

   			}

   		else 

   			{        

			fepMan->UpdateInlineEditL(prevText, prevText.Length());

   			}

        }

    else if (aCommandId == ESignalSelectMatchSelectionText)

        {

        //fepMan->UpdateCbaL(R_AKNFEP_SOFTKEYS_FINGER);

#ifdef RD_SCALABLE_UI_V2

        fepMan->PluginUIManager()->SetFingerMatchSelectionState(EFalse);

#endif //RD_SCALABLE_UI_V2

        iOwner->ChangeState(EInitial);

        }

    else if (aCommandId == ESignalNaviLeftMatchSelectionText)

        {

        //fepMan->UpdateCbaL(R_AKNFEP_SOFTKEYS_FINGER);

#ifdef RD_SCALABLE_UI_V2

        fepMan->PluginUIManager()->SetFingerMatchSelectionState(EFalse);

#endif //RD_SCALABLE_UI_V2

        iOwner->ChangeState(EEntry);

        TRawEvent event;

        event.Set(TRawEvent::EKeyDown, EStdKeyLeftArrow);

        CCoeEnv::Static()->WsSession().SimulateRawEvent(event);

        event.Set(TRawEvent::EKeyUp, EStdKeyLeftArrow);

        CCoeEnv::Static()->WsSession().SimulateRawEvent(event);

        }

    else if (aCommandId == ESignalNaviRightMatchSelectionText)

        {

        //fepMan->UpdateCbaL(R_AKNFEP_SOFTKEYS_FINGER);

#ifdef RD_SCALABLE_UI_V2

        fepMan->PluginUIManager()->SetFingerMatchSelectionState(EFalse);

#endif //RD_SCALABLE_UI_V2

        iOwner->ChangeState(EEntry);

        TRawEvent event;

        event.Set(TRawEvent::EKeyDown, EStdKeyRightArrow);

        CCoeEnv::Static()->WsSession().SimulateRawEvent(event);

        event.Set(TRawEvent::EKeyUp, EStdKeyRightArrow);

        CCoeEnv::Static()->WsSession().SimulateRawEvent(event);

        }        

    }

TBool TAknFepInputStateEntryWesternPredictive::HandleStandardNumericKeysL(TInt aKey, 

                                                                          TKeyPressLength aLength)

    {

    MAknFepManagerUIInterface* fepMan = iOwner->FepMan();

    CPtiEngine* ptiengine = iOwner->PtiEngine();

    TBool response = ETrue;

    if (aLength == ELongKeyPress)

        {

        if (!fepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction))

        	{

        	// No edit transaction going on, we have ended here because of long

        	// key press created editor on UI or some other similar non-standard situation.

        	// We can't handle key press, so just consume it.

        	return ETrue;	

        	}

        // try and insert a digit

        if (!fepMan->TryRemoveNoMatchesIndicatorL())

            { 

            // remove last character

            TPtrC newText = ptiengine->DeleteKeyPress();

#ifndef RD_INTELLIGENT_TEXT_INPUT

            if(ptiengine->InputMode() == EPtiEngineWordCompletion 

           && (newText.Length() > ptiengine->CurrentInputSequence().Length()))

            	{

            	    	fepMan->RemoveSuggestedCompletionL();

            	}

       		else

#endif

	       		{

            fepMan->UpdateInlineEditL(newText, newText.Length());

	            }

            }

        //closing the UI will commit the current word and move to intial state

        fepMan->TryCloseUiL();

        //this flag to ensures that initial state does not send us back 

        //to this state as it would normally do for numeric keys

        fepMan->SetFlag(CAknFepManager::EFlagSuppressInputStateChange);

        response = EFalse;

        }

    else  // short keypress 

        {

        //To restrict up to 32 character..

        if(ptiengine->CurrentInputSequence().Length() >= KMaxWordSize)

        	{

            fepMan->SetFlag(CAknFepManager::EFlagNoMatches);

            // Enter word reach to max inline edit state

            // if we call upadte inline edit, it will insert '?' mark

            // which would be the 64th/33rd character

            // Not need to call appedkeypress/ updateinlineedit

            // ignore the current key press

            //fepMan->UpdateCbaL(R_AKNFEP_SOFTKEYS_SPELL_EMPTY);

            //TPtrC newText = ptiengine->CurrentWord();

			//fepMan->UpdateInlineEditL(newText, newText.Length());

            }

        if (fepMan->IsFlagSet(CAknFepManager::EFlagNoMatches))

            {

            //no matches, so just play tone

            fepMan->PlaySound(EAvkonSIDConfirmationTone);

            }           

        else //insert a letter

            {

            fepMan->SetCcpuFlag(CAknFepManager::ECcpuStateIgnoreStarUp |

                                CAknFepManager::ECcpuStateNewPredictiveWord);

            if (iMatchState == EWordMatchLast || iMatchState == EWordMatchAfterLast)

                {

                iMatchState = EWordMatchNone;

                }

            if (!(fepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction)))

                { // 'new' inline edit

                ptiengine->ClearCurrentWord();

                fepMan->StartInlineEditL();

                fepMan->TryStartCompoundWord();

                }

#ifndef RD_INTELLIGENT_TEXT_INPUT

  			TInt prevSeqLength = ptiengine->CurrentInputSequence().Length();

#endif 

            TPtrC newText = ptiengine->AppendKeyPress((TPtiKey)aKey);

 			fepMan->ClearFlag(CAknFepManager::EFlagRemoveMatchesMenuItem);   

#ifdef RD_INTELLIGENT_TEXT_INPUT

 			if (ptiengine->NumberOfCandidates() > 0)

#else

           if ((fepMan->IsMoreGoodWordsComing(newText.Length())

#ifndef RD_INTELLIGENT_TEXT_INPUT

				&& (ptiengine->InputMode() != EPtiEngineWordCompletion))

                || fepMan->IsMoreGoodAutoCompleteWordsComing(ptiengine->InputMode(), 

                										  prevSeqLength, ptiengine->CurrentInputSequence().Length()

#endif

		))

#endif

                {

                // more good words coming in from predictive text engine so carry on

                if(newText.Length() == 1)

           			{

	            	TDigitType digittype = fepMan->LocalDigit();

	                TChar chchar(newText[0]);

	                if(!chchar.IsDigit() || (chchar.IsDigit() && !digittype))

	                	{ 	

	                	fepMan->UpdateInlineEditL(newText, newText.Length());    

    	            	}

	                else 

	                	{

	                	TBuf<1> tempbuf;

	                	tempbuf.Append(newText[0]);

		            	ConvertDigitToDigittype(digittype,tempbuf);

		                fepMan->UpdateInlineEditL(tempbuf, tempbuf.Length());				                	

	                	}

           			}

           		else 

           			{

           			fepMan->UpdateInlineEditL(newText, newText.Length());	

           			}

                TBool lastEnteredDigitOne = (ptiengine->LastEnteredKey() == EPtiKey1);

                if (!lastEnteredDigitOne)

                    {

                    iOwner->CaseMan()->UpdateCase(ENullNaviEvent);

                    }

                fepMan->ClearFlag(CAknFepManager::EFlagRemoveMatchesMenuItem);

				if (ptiengine->NumberOfCandidates() <= 1)                    

					{

	                fepMan->SetFlag(CAknFepManager::EFlagRemoveMatchesMenuItem);                					

					}

                }

            else 

                {

                // engine has run out of matches

                fepMan->SetFlag(CAknFepManager::EFlagRemoveMatchesMenuItem);                

                fepMan->SetFlag(CAknFepManager::EFlagNoMatches);

                fepMan->UpdateCbaL(R_AKNFEP_SOFTKEYS_SPELL_EMPTY);

                if(newText.Length() == 1)

           			{

	            	TDigitType digittype = fepMan->LocalDigit();

	                TChar chchar(newText[0]);

	                if(!chchar.IsDigit() || (chchar.IsDigit() && !digittype))

	                	{ 	

	                	fepMan->UpdateInlineEditL(newText, newText.Length());    

    	            	}

	                else 

	                	{

	                	TBuf<1> tempbuf;

	                	tempbuf.Append(newText[0]);

		            	ConvertDigitToDigittype(digittype,tempbuf);

		                fepMan->UpdateInlineEditL(tempbuf, tempbuf.Length());					                	

	                	}

           			}

           		else 

           			{

#ifdef RD_INTELLIGENT_TEXT_INPUT

           			// Remove the autocompletion tail if present

                    if (fepMan->IsAutoCompleteOn())

                        {

                        TInt tailLength = 0;

                        ptiengine->HandleCommandL( EPtiCommandGetAutoCompletionTailLength, 

                                                  &tailLength );

                        if(tailLength > 0)

                            {

                            // To remove the autocompletion part, the below function is used. 

                            // DeleteKeyPress was used earlier. This is removed to fix the bug :

                            // enter characters to show autocompletion part. Now press a 

                            // character so that the no matches character is shown. Now press

                            // backspace key, last character is not deleted.

                            fepMan->RemoveSuggestedAdvanceCompletionL();

                            fepMan->PlaySound(EAvkonSIDConfirmationTone);

                            return response;

                            }

                        }

#endif

           			fepMan->UpdateInlineEditL(newText, newText.Length());	

           			}

                fepMan->PlaySound(EAvkonSIDConfirmationTone);

                }

            }

        }

    return response;

    }

TBool TAknFepInputStateEntryWesternPredictive::HandleNaviKeysL(TInt aKey, TKeyPressLength /*aLength*/)

    {

    MAknFepManagerUIInterface* fepMan = iOwner->FepMan();

    CPtiEngine* ptiengine = iOwner->PtiEngine();

    if (!(fepMan->IsFlagSet(CAknFepManager::EFlagInsideInlineEditingTransaction)))

        {

        TBuf<CAknFepManager::EMaximumFepWordLength> textToUncommit;

        TBool comsumeKey;

        if (!(fepMan->TryGetTextToUncommitL(textToUncommit, aKey, comsumeKey)))

            {

            // If T9 word length > 32, the navi key is consumed without action.

            // Maybe should navigate inside word.

            return comsumeKey;

            }

#ifdef RD_INTELLIGENT_TEXT_INPUT

        ptiengine->ClearCurrentWord(); // Clear the buffer or setting input may fail