/*

* Copyright (c) 2008 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  TAknFepInputStateEntryMiniQwertyPinyinPhrase methods.

*

*/

#include "AknFepUIManagerStateInterface.h"  //MAknFepUIManagerStateInterface

#include "AknFepUiCtrlContainerChinese.h"

#include "AknFepManagerUIInterface.h"       //MAknFepManagerUIInterface

#include "AknFepUICtrlCandidatePane.h"

#include "aknfepuiinputstateentryhalfqwertyphrase.h"

#include "AknFepManager.h"                  //FepMan flag

#include "AknFepUICtrlInputPane.h"

#include "AknFepUICtrlPinyinPopup.h"        //Pinyin phrase

#include "AknFepUiCtrlContainerChinese.h"

#include <PtiEngine.h>      //CPtiEngine

#include <e32keys.h>        //keys  

#include <avkon.rsg>

const TInt KFnMappedCharacters = 5;

const TInt KInputPaneLength = 32;

const TText KPinyinTone4Valid = 0x02D9;

const TText KPinyinTone4Invalid = 0x0020;

const TInt KMaxPhraseCount = 150;

//For Pinyin

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

// TAknFepInputStateEntryHalfQwertyPinyinPhrase::TAknFepInputStateEntryHalfQwertyPinyinPhrase

// the construt funtion 

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

//

TAknFepInputStateEntryHalfQwertyPinyinPhrase::TAknFepInputStateEntryHalfQwertyPinyinPhrase(

                               MAknFepUIManagerStateInterface* aOwner,

                               MAknFepUICtrlContainerChinese* aUIContainer)

    :TAknFepInputStateEntryQwertyBaseChinesePhrase(aOwner,aUIContainer)                           

    {

    iState = EEntry;

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    uiContainer->FocusCandidatePane(EFalse);

    uiContainer->CandidatePane()->ShowCandidateOrdinals(EFalse);

    uiContainer->SetLayout(MAknFepUICtrlContainerChinese::ELayoutInput);

    uiContainer->CandidatePane()->SelectFirstPhrase(); 

    uiContainer->ShowHorizontalScrollArrows(EFalse); 

    uiContainer->ShowVerticalScrollArrows(EFalse);

    uiContainer->InputPane()->SetOverrideFontId(0);

    // in the case that we are coming back to the input pane from the candidate pane, 

    // we need to ensure that the current selection is selected correctly

    ImplicitlyUpdateSelection();

    UpdateIndicator();

    ClearDeliberateSelection();

    iOwner->PtiEngine()->SetInputMode(EPtiEnginePinyinPhraseHalfQwerty);

    iOwner->PtiEngine()->SetCandidatePageLength(KMaxPhraseCount);

    iOwner->PtiEngine()->SetCase(EPtiCaseLower);

    }

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

// TAknFepUiInputStateCandidateMiniQwertyZhuyinPhrase::HandleKeyL

// handle key event

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

//

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

    {

    CPtiEngine* ptiengine = iOwner->PtiEngine();

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlPinyinPopup* popup = uiContainer->PinyinPopupWindow();

    MAknFepUICtrlCandidatePane* candidatePane = uiContainer->CandidatePane();

    TBool state = ETrue;

    TPtrC text;

    TBool ret = ETrue;

    if ( aLength == EShortKeyPress )

    	{

    	switch (aKey)

			{

			case EPtiKeyQwerty1:

				{

				aKey = EPtiKeyQwertyE;

				break;

			}

		case EPtiKeyQwerty2:

			{

			aKey = EPtiKeyQwertyT;

			break;

			}

		case EPtiKeyQwerty3:

			{

			aKey = EPtiKeyQwertyU;

			break;

			}

		case EPtiKeyQwerty4:

			{

			aKey = EPtiKeyQwertyD;

			break;

			}

		case EPtiKeyQwerty5:

			{

			aKey = EPtiKeyQwertyG;

			break;

			}

		case EPtiKeyQwerty6:

			{

			aKey = EPtiKeyQwertyJ;

			break;

			}

		case EPtiKeyQwerty7:

			{

			aKey = EPtiKeyQwertyC;

			break;

			}

		case EPtiKeyQwerty8:

			{

			aKey = EPtiKeyQwertyB;

			break;

			}

		case EPtiKeyQwerty9:

			{

			aKey = EPtiKeyQwertyM;

			break;

			}

			case EPtiKeyQwerty0:

				{

				aKey = EPtiKeyQwertySpace;

				break;

				}

			}

    	}

    if ( aKey != EStdKeyLeftFunc && 

        (iOwner->FepMan()->IsFlagSet(CAknFepManager::EFlagQwertyChrKeyDepressed) ||

        iOwner->FepMan()->IsFlagSet(CAknFepManager::EFlagShiftKeyDepressed)))

        {

        iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);

        return ETrue;

        }

    if(( aKey == EStdKeyLeftFunc  || aKey == EStdKeyFullStop) && aLength == EShortKeyPress) //chr and punctuation key to tone mark   

        {

        if(ptiengine->IncrementToneMark(ETrue))

            {

            ImplicitlyUpdateSelection();

            }

        }

    else if( CAknFepFnKeyManager::EFnKeyNext == iOwner->FepMan()->FnKeyState() ||     //

        CAknFepFnKeyManager::EFnKeyLock == iOwner->FepMan()->FnKeyState() ||

        CAknFepFnKeyManager::EFnKeyDown == iOwner->FepMan()->FnKeyState())

        {

        popup->SetPreStateIsPredictive( EFalse );

        iOwner->FepMan()->TryCloseUiL();

        ret = EFalse;

        }                                                    

    else if(aKey == EStdKeyBackspace )

        {

        if ( popup->IsChangeStatet() && aLength == ELongKeyPress )

            {

            state = EFalse;

            }

        else

            {

            popup->SetChangeState( EFalse );

            }

        if ( state )

            {

            if (iOwner->PtiEngine()->DeleteKeyPress().Length())

                {

                ImplicitlyUpdateSelection();

                }

            else

                {

                iOwner->FepMan()->TryCloseUiL(); //no more keys, close the UI.

                popup->SetPreStateIsPredictive( EFalse );

                if ( aLength == ELongKeyPress )

                    {

                    iOwner->FepMan()->SetLongClearAfterCloseUI(ETrue);

                    }

                }

            }

        } 

    else if(aKey ==EStdKeyDevice1)//sk2

        {

        iOwner->FepMan()->TryCloseUiL();

        popup->SetPreStateIsPredictive( EFalse );

        }

    else if(aKey == EStdKeyRightArrow)

        {

        if(popup->IsEnabled())

            {

            if(popup->SelectNextPhrase())

                {

                DeliberatelyUpdateSelection();

                }

            }

        }

    else if(aKey == EStdKeyLeftArrow)

        {

        if(popup->IsEnabled())

            {

            if(popup->SelectPrevPhrase())

                {

                DeliberatelyUpdateSelection();

                }

            }

        } 

    else if (aKey == EStdKeyDownArrow

            || aKey == EStdKeyDevice3

            || aKey == EStdKeyDevice0

            ||aKey == EStdKeyEnter) //Downkey,sk1,selection,enter key

        {

        if(popup->IsEnabled())

            {

            popup->Enable(EFalse);

            }

        iOwner->ChangeState(ECandidate);

        popup->SetPreStateIsPredictive( EFalse );

        popup->SetChangeState( ETrue );

        }  

    else if ( aKey == EStdKeyUpArrow )

        {

        if ( !candidatePane->IsFirstPage() )

            {

            candidatePane->PreviousCandidatePage();

            candidatePane->SetCandidateBuffer();

            candidatePane->SelectFirst();

            UpdateIndicator();

            }

        }

    else if(aLength == EShortKeyPress) 

        {

        iOwner->FepMan()->SetCcpuFlag(CAknFepManager::ECcpuStateIgnoreStarUp);            

        if(iOwner->IsValidChineseInputKeyQwerty(aKey) || aKey ==EStdKeySpace ) //seperator

            {

            TInt stringBeforeLength(0);

            TInt stringAfterLength(0);

            stringBeforeLength = ptiengine->GetPhoneticSpelling(1).Length();

            stringAfterLength = ptiengine->AppendKeyPress((TPtiKey)aKey).Length();

            if (stringAfterLength==0 && aKey == EPtiKeyQwertyU )  //u,i should not as first character in pinyin

               {

               iOwner->FepMan()->TryCloseUiL();

               popup->SetPreStateIsPredictive( EFalse );

               iOwner->FepMan()->UpdateCbaL(NULL);

//               iOwner->ChangeState(EQwerty);

               iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);

               return ETrue;     

               }

            if (stringBeforeLength != stringAfterLength)

                {

                if (ptiengine->GetPhoneticSpelling(1).Length() == 1)

                    {

                    iOwner->FepMan()->UpdateCbaL(R_AKNFEP_SOFTKEYS_OK_SELECT_CANCEL);

                    }

                ImplicitlyUpdateSelection();

                }

            else

                {

                iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);

                }

            }

        else

            {

            iOwner->FepMan()->PlaySound(EAvkonSIDErrorTone);

            }

        if ( popup->PhoneticSpellingArray()->Count() > 0 &&

            popup->PhoneticSpellingArray()->MdcaPoint( 0 ).Length() > 1 )

            {

            popup->SetPreStateIsPredictive( EFalse );

            }

        }

    else 

        {

        if ( popup->GetPreStateIsPredictive() && 

            popup->PhoneticSpellingArray()->Count() > 0 &&

        		popup->PhoneticSpellingArray()->MdcaPoint( 0 ).Length() == 1)    //long press fn mode character should inputted

            {

            iOwner->FepMan()->TryCloseUiL();

            popup->SetPreStateIsPredictive( EFalse );

            if (aKey == EStdKeyEnter)

                {

                // PtiEngine does not have mapping for the enter key.

                const TText KAknFEPLineFeedSymbol = 0x21B2;

                TBuf<1> lineFeed;

                lineFeed.Zero();

                lineFeed.Append(KAknFEPLineFeedSymbol);

                text.Set(lineFeed);

                }

            else

                {

                TBuf<KFnMappedCharacters> allFnMappedCharacters;

                ptiengine->MappingDataForKey((TPtiKey)aKey, allFnMappedCharacters, EPtiCaseFnLower);

                text.Set(allFnMappedCharacters);

                }

            if (text.Length() > 0)

                {

                TBuf<1> chr;

                chr.Append(text[0]);

                iOwner->FepMan()->NewCharacterL(chr);

                iOwner->FepMan()->CommitInlineEditL();

                ptiengine->ClearCurrentWord();

                ret = ETrue;

                }

            }

        }

    return ret;

    }

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

// TAknFepInputStateEntryHalfQwertyPinyinPhrase::DeliberatelyUpdateSelection

// DeliberatelyUpdateSelection

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

//

void TAknFepInputStateEntryHalfQwertyPinyinPhrase::DeliberatelyUpdateSelection()

    {

    TPtr deliberateSelection = iOwner->GetLatestDeliberateSelection();

    CPtiEngine* ptiengine = iOwner->PtiEngine();

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlPinyinPopup* popup = uiContainer->PinyinPopupWindow();

    TInt selected = popup->CurrentSelection();

    ptiengine->EnableToneMarks(EFalse);

    // our index is zero based, engine index is one based

    TPtrC spelling = ptiengine->GetPhoneticSpelling(selected + 1); 

    deliberateSelection = spelling.Left(MAknFepUICtrlInputPane::EMaxInputCharsPinyinPopupNotIncludingToneMark);

    ptiengine->EnableToneMarks(ETrue);

    UIContainer()->PinyinPopupWindow()->SetFlag(MAknFepUICtrlPinyinPopup::ESpellingNavigation);    

    RefreshUI(popup->CurrentVisibleSelection());

    }

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

// TAknFepInputStateEntryHalfQwertyPinyinPhrase::ImplicitlyUpdateSelection

// update the selection

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

//

void TAknFepInputStateEntryHalfQwertyPinyinPhrase::ImplicitlyUpdateSelection()

    {

    TPtr oldDeliberateSelection = iOwner->GetLatestDeliberateSelection();

    TInt oldDeliberateSelectionLength = oldDeliberateSelection.Length();

    CPtiEngine* ptiengine = iOwner->PtiEngine();

    // previously selected is compared in turn to each of the new candidates

    ptiengine->EnableToneMarks(EFalse);

    TInt pinyinCount = ptiengine->PhoneticSpellingCount();

    TInt newSelection = 0;

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

        {

        TPtrC spelling = ptiengine->GetPhoneticSpelling(i + 1);  // our index is zero based, engine index is one based

        TInt spellingLength = spelling.Length();

        // figure out how many characters we are comparing, this depends on the 

        // direction of the edit

        TInt compareLength = oldDeliberateSelectionLength <= spellingLength ? 

            oldDeliberateSelectionLength : spellingLength;

        if(oldDeliberateSelection.Left(compareLength) == spelling.Left(compareLength))

            {

            // as soon as a substring match is found, the 

            // highlight position is set to that candidate in the new list. 

            // note that in the case of the first character entered, the

            // oldBuf will be empty so it will always match... which is 

            // fine as we want to select the top one anyway, so we will

            // quit the loop early.

            newSelection = i;

            break;

            }

        }

    ptiengine->EnableToneMarks(ETrue);

    UIContainer()->PinyinPopupWindow()->SetFlag(MAknFepUICtrlPinyinPopup::ESpellingChanged);

    RefreshUI(newSelection);

    }

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

// TAknFepInputStateEntryHalfQwertyPinyinPhrase::ClearDeliberateSelection

// clear the deliberate selection

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

//

void TAknFepInputStateEntryHalfQwertyPinyinPhrase::ClearDeliberateSelection()

    {

    MAknFepUICtrlPinyinPopup* popup = UIContainer()->PinyinPopupWindow();

    TInt spellingCount = popup->PhoneticSpellingArray()->Count();

    // we must have just deleted the last character, 

    // or we are starting a new zhuyin session, so wipe the last deliberate selection

    if ( 0 == spellingCount )

        {

        TPtr oldDeliberateSelection = iOwner->GetLatestDeliberateSelection();

        oldDeliberateSelection = KNullDesC;

        }

    }

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

// TAknFepInputStateEntryHalfQwertyPinyinPhrase::RefreshUI

// refresh ui 

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

//

void TAknFepInputStateEntryHalfQwertyPinyinPhrase::RefreshUI(TInt aSelection)

    {

    CPtiEngine* ptiengine = iOwner->PtiEngine();

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlPinyinPopup* popup = uiContainer->PinyinPopupWindow();

    MAknFepUICtrlInputPane* inputPane = uiContainer->InputPane();   

    // get cursor position

    TPoint baseLine = TPoint(0,0);

    TInt height = 0;

    TInt ascent = 0;

    TRAPD(ret,iOwner->FepMan()->GetScreenCoordinatesL(baseLine,height,ascent));

    if (ret == KErrNone)

        {

        uiContainer->SetContainerPosition(baseLine, height);    

        }

    TText toneMark;

    TBool toneMarkEntered = ptiengine->ToneMark(toneMark);

    TBuf<1> validToneMarkBuf;

    if(toneMarkEntered)

        {

        // override specific invalid tonemark character only, the others are the same character 

        // when both valid and invalid

        if(toneMark == KPinyinTone4Invalid)

            toneMark = KPinyinTone4Valid;

        validToneMarkBuf.Append(toneMark);

        }

    // to start with, disable the tone marks so we can get the list of all zhuyin matches

    // later we will figure out which ones are invalid

    ptiengine->EnableToneMarks(EFalse);

    TInt pinyinCountWithoutToneMarks = ptiengine->PhoneticSpellingCount();

    if(pinyinCountWithoutToneMarks > 0)

        {

        if(popup->IsFlagSet(MAknFepUICtrlPinyinPopup::ESpellingChanged))

            {

            CDesCArrayFlat* spelling = popup->PhoneticSpellingArray();

            TRAPD(ignore, ptiengine->GetPhoneticSpellingsL(*spelling));

            if (ignore != KErrNone)

                {

                return;

                }

            popup->SplitPhraseSpellingIntoPages(); 

            }

        // set display page for delibrate selection

        popup->SetDisplayPage(aSelection);

        popup->SetPhraseItemTexts();

        // fill in input pane although it's invisible

        inputPane->SetText(ptiengine->GetPhoneticSpelling(popup->CurrentSelection() + 1));

        popup->PopupSizeChanged(); // phrase input

        }

    // turn tone marks back on so that we know where we are.

    ptiengine->EnableToneMarks(ETrue);

    // this is where we start to figure out whether the tonemarks are valid,

    // whether the selected tonemark is valid, and what is the index of the 

    // selected candidate in the list of candidates with tonemarks...

    TBool selectionToneMarkValid = EFalse;

    TInt selectionIndexAdjustedForToneMarkValidity = popup->CurrentSelection();

    // we only need to deal with tone marks if there is one

    if(toneMarkEntered)

        {

        if(pinyinCountWithoutToneMarks > 0)

            {

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

                {

                TBool valid = EFalse;

                TBuf<MAknFepUICtrlInputPane::EMaxInputCharsPinyinPopupNotIncludingToneMark> nextCandidateWithoutToneMark;

                nextCandidateWithoutToneMark.Copy(ptiengine->GetPhoneticSpelling

                    (i + 1).Left(MAknFepUICtrlInputPane::EMaxInputCharsPinyinPopupNotIncludingToneMark));

                ptiengine->EnableToneMarks(EFalse); 

                ptiengine->SelectPhoneticSpelling(i + 1);

                valid = ptiengine->IsToneMarkValidForSpelling();

                if(valid)

                    {

                    ptiengine->EnableToneMarks(ETrue); 

                    TInt pinyinCountWithToneMarks = ptiengine->PhoneticSpellingCount();

                    for(TInt j = 0; j < pinyinCountWithToneMarks; j++)

                        {

                        // use j here not i as we are looking at the list with tonemarks

                        TPtrC nextCandidateWithToneMark = ptiengine->GetPhoneticSpelling(j + 1);  

                        if(nextCandidateWithToneMark == nextCandidateWithoutToneMark)

                            {

                            if(i == aSelection)

                                {

                                selectionToneMarkValid = ETrue;

                                // fill in input pane even if it can't be seen, for when we have to hide popup window

                                inputPane->SetText(nextCandidateWithoutToneMark);

                                }

                            break;

                            }

                        }

                    }

                }

            }

        }

    ptiengine->EnableToneMarks(EFalse); 

    ptiengine->SelectPhoneticSpelling(popup->CurrentSelection() + 1); 

    // next two lines are for tonemark validity

    ptiengine->EnableToneMarks(selectionToneMarkValid); 

    ptiengine->SelectPhoneticSpelling(selectionIndexAdjustedForToneMarkValidity + 1); // our index is zero based, engine index is one based

    // update the candidate pane.

    if(popup->IsFlagSet(MAknFepUICtrlPinyinPopup::ESpellingChanged) 

        || popup->IsFlagSet(MAknFepUICtrlPinyinPopup::ESpellingNavigation))

        {

        TRAPD(ignore, ptiengine->GetChinesePhraseCandidatesL(*(uiContainer->CandidatePane()->CandidateArray())));

        if (ignore != KErrNone)

            {

            return;

            }

        uiContainer->CandidatePane()->SplitPhraseCandidatesIntoPages(); 

        popup->ClearFlag(MAknFepUICtrlPinyinPopup::ESpellingChanged 

                        | MAknFepUICtrlPinyinPopup::ESpellingNavigation);

        }

    uiContainer->CandidatePane()->SetCandidateBuffer();

    uiContainer->Enable(ETrue);

    // need to enable the pinyin popup after the container so that it is raised to the front

    popup->Enable(pinyinCountWithoutToneMarks > 0);

    UpdateIndicator();