/*

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

*

*/

#include "AknFepPanic.h"

#include "AknFepUiInputStateEntryPinyinPhrase.h"

#include "AknFepUIManagerStateInterface.h"      //MAknFepUIManagerStateInterface

#include "AknFepManagerUIInterface.h"           //MAknFepManagerUIInterface

#include "AknFepUiCtrlContainerChinese.h"

#include "AknFepUICtrlInputPane.h"

#include "AknFepUICtrlCandidatePane.h"

#include "AknFepUICtrlPinyinPopup.h"		//Pinyin phrase

#include "AknFepManager.h"

#include <PtiEngine.h>                          //CPtiEngine

#include <PtiDefs.h>                            //keys

#include <avkon.rsg>

#include <aknnotewrappers.h>

const TText KPinyinTone0Valid = 0x02C9;

const TText KPinyinTone1Valid = 0x02CA;

const TText KPinyinTone2Valid = 0x02C7;

const TText KPinyinTone3Valid = 0x02CB;

const TText KPinyinTone4Valid = 0x02D9;

const TText KPinyinTone4Invalid = 0x0020;

const TInt KMaxPhraseCount = 100;

const TInt KMaxKeystrokeCount = 100;

const TInt KMaxShowKeystrokeCount = 31;

const TInt KMaxPinyinLength = 60;

const TInt KMaxStarCount = 5;

const TInt KKey0Code = 48;

const TInt KKey1Code = 49;

const TInt KKey2Code = 50;

const TInt KKey3Code = 51;

const TInt KKey4Code = 52;

const TInt KKey5Code = 53;

const TInt KKey6Code = 54;

const TInt KKey7Code = 55;

const TInt KKey8Code = 56;

const TInt KKey9Code = 57;

_LIT( KPinyinListSeparator, "'" );

_LIT( KPinyinStar, "*" );

_LIT( KPinyinNote,"\x9020\x65B0\x8BCD" );

_LIT( KPinyinManualSeparator, "\x002E");

TAknFepInputStateEntryPinyinPhrase::TAknFepInputStateEntryPinyinPhrase(

                                MAknFepUIManagerStateInterface* aOwner,

                                MAknFepUICtrlContainerChinese* aUIContainer)

    :TAknFepInputStateChineseBase(aOwner, aUIContainer)

    {

    iState = EEntry;

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    uiContainer->FocusCandidatePane(EFalse);

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

    uiContainer->SetLayout(MAknFepUICtrlContainerChinese::ELayoutInput);

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

    uiContainer->ShowVerticalScrollArrows(ETrue);

    uiContainer->ShowHorizontalScrollArrows(EFalse);

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

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

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

    uiContainer->PinyinPopupWindow()->SetTonemarkState( ETrue );

    // set the state is in input state,

    // so that it could handle EKeyCBA1

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

    uiContainer->SetFepMan( iOwner->FepMan() );

    ClearKeystrokeBuf();

    // 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();

    // however we also need to clear the deliberate selection, in case we are not

    // coming back to the input pane from the candidate pane

    if ( uiContainer->PinyinPopupWindow()->GetFromCandidateChangeStateFlag() )

        {

        uiContainer->PinyinPopupWindow()->SetFromCandidateChangeStateFlag( EFalse );

        }

    else

        {

        ClearDeliberateSelection();

        }

    UpdateIndicator();

    TRAP_IGNORE( ChangeCbaL() );

    }

void TAknFepInputStateEntryPinyinPhrase::HandleCommandL( TInt aCommandId)

    {

    CPtiEngine* ptiengine = iOwner->PtiEngine( );

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer( );

    MAknFepUICtrlPinyinPopup* popup = uiContainer->PinyinPopupWindow( );

    CDesCArrayFlat* keystrokeArray = popup->KeystrokeArray( );

    CDesCArrayFlat* inEffectKeystrokeArray = popup->InEffectKeystrokeArray( );

    CDesCArrayFlat* showKeystrokeArray = popup->ShowKeystrokeArray( );

    TInt currentSelect = popup->CurrentSelection( );

    TInt inEffectSpellingCount = ptiengine->PhoneticSpellingCount( );

    TBuf<KMaxKeystrokeCount> keystrokeBuf;

    switch ( aCommandId )

        {

        // Handle the event frome command.

        case EAknSoftkeyCancel:

            //  case (TUint16)EAknSoftkeyCancel: //the Cancle in soft CBA

            TAknFepInputStateChineseBase::HandleCommandL( aCommandId );

            break;

        case EAknSoftkeySelect:

            //case (TUint16)EAknSoftkeySelect: //the Selected in soft CBA

            if ( (currentSelect < inEffectSpellingCount)

                && (keystrokeArray->Count( )

                    == inEffectKeystrokeArray->Count( ) )

                && (popup->GetTonemarkState( ) ) )

                {

                if ( popup->IsEnabled( ) )

                    {

                    popup->Enable( EFalse );

                    }

                iOwner->FepMan()->PinyinPhraseCreation( EFalse );

                popup->SetChangeState( ETrue );

                iOwner->ChangeState( ECandidate );

                }

            else

                {

                GetKeystrokeBuf( *keystrokeArray, keystrokeBuf );

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

                popup->SetChangeState( ETrue );

                popup->SetPhraseCreationState( ETrue );

                if ( GetChangeState( ) )

                    {

                    ClearDeliberateSelection( );

                    popup->Enable( EFalse );

                    iOwner->ChangeState( ESpellingSelection );

                    }

                else

                    {

                    ClearDeliberateSelection( );

                    popup->Enable( EFalse );

                    iOwner->ChangeState( EKeySequenceEdit );

                    }

                }

            break;

        default:

            DeliberatelyUpdateSelection( );

            break;

        }

    }

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

    {

    CPtiEngine* ptiengine = iOwner->PtiEngine();

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlPinyinPopup* popup = uiContainer->PinyinPopupWindow();

    CDesCArrayFlat* keystrokeArray = popup->KeystrokeArray();

    CDesCArrayFlat* inEffectKeystrokeArray = popup->InEffectKeystrokeArray();

    CDesCArrayFlat* showKeystrokeArray = popup->ShowKeystrokeArray();

    TInt currentSelect = popup->CurrentSelection();

    TInt inEffectSpellingCount = ptiengine->PhoneticSpellingCount();

    TInt offset = 0;

    TBuf<1> keyBuf;

    TBuf<1> keyShow;

    TBuf<KMaxKeystrokeCount> keystrokeBuf;

    if(aKey == EKeyBackspace)

        {

        TBool state = ETrue;

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

            {

            state = EFalse;

            }

        else

            {

            popup->SetChangeState( EFalse );

            }

        if ( state )

            {

            DeleteCurrentKeystroke();

            showKeystrokeArray->Delete( showKeystrokeArray->Count() - 1 );

            showKeystrokeArray->Compress();

            if ( inEffectKeystrokeArray->Count()> 0 )

                {

                ImplicitlyUpdateSelection();

                }

            else

                {

                ClearDeliberateSelection();

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

                if (aLength == ELongKeyPress)

                    {

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

                    }

                }

            }

        }

    else if(aKey == EKeyRightArrow)

        {

        if(popup->IsEnabled())

            {

            if(popup->SelectNextPhrase())

                {

                DeliberatelyUpdateSelection();

                }

            }

        }

    else if(aKey == EKeyLeftArrow)

        {

        if(popup->IsEnabled())

            {

            if(popup->SelectPrevPhrase())

                {

                DeliberatelyUpdateSelection();

                }

            }

        }

    else if( ( aKey == EKeyOK || aKey == EKeyDownArrow || aKey == EKeyCBA1)

        && aLength == EShortKeyPress)

        {

        if ( ( currentSelect < inEffectSpellingCount) && 

            ( keystrokeArray->Count() == inEffectKeystrokeArray->Count() ) &&

            ( popup->GetTonemarkState() ) )

            {

            if(popup->IsEnabled())

                {

                popup->Enable(EFalse);

                }

            iOwner->FepMan()->PinyinPhraseCreation( EFalse );

            popup->SetChangeState( ETrue );

            iOwner->ChangeState(ECandidate);              

            }

        else

            {

            GetKeystrokeBuf( *keystrokeArray, keystrokeBuf );

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

            popup->SetChangeState( ETrue );

            popup->SetPhraseCreationState( ETrue );

            if ( GetChangeState() )

                {

                ClearDeliberateSelection();

                popup->Enable( EFalse );

                iOwner->ChangeState(ESpellingSelection);

                }

            else

                {

                ClearDeliberateSelection();

                popup->Enable( EFalse );

                iOwner->ChangeState(EKeySequenceEdit);

                }

            }

        }

    else if (aLength == EShortKeyPress) // don't want repeats on these keys

        {

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

        if ( ( iOwner->IsValidChineseInputKey(aKey) ) &&

             ( CheckKeystroke( aKey, *keystrokeArray ) ) )

            {

            TInt stringBeforeLength(0);

            TInt stringAfterLength(0);

            GetKeystrokeNum( aKey, keyBuf );

            keystrokeArray->AppendL( keyBuf );

            showKeystrokeArray->AppendL( keyBuf );

            if ( popup->GetTonemarkState() )

                {

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

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

                if (stringBeforeLength != stringAfterLength)

                    {

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

                        {

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

                        }

                    inEffectKeystrokeArray->AppendL(keyBuf);

                    ImplicitlyUpdateSelection();

                    }

                else

                    {

                    ptiengine->EnableToneMarks(ETrue);

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

                    RefreshUI(0);

                    } 

                }

            else

                {

                ImplicitlyUpdateSelection();

                }

            }

        else if ( ( aKey == EPtiKeyStar ) &&  

                  ( CheckKeystroke( aKey, *keystrokeArray ) ) ) // we increment the tone mark.

            {

            keyBuf.Append( EPtiKeyStar );

            if ( keystrokeArray->Count() == inEffectKeystrokeArray->Count() )

                {

                inEffectKeystrokeArray->AppendL(keyBuf);

                keystrokeArray->AppendL( keyBuf );

                GetPinyinToneMark( *keystrokeArray, keyShow );

                ShowKeystrokeAppendL( *showKeystrokeArray, *keystrokeArray, keyShow );

                CheckTonemarkL();

                }

            else

                {

                keystrokeArray->AppendL( keyBuf );

                GetPinyinToneMark( *keystrokeArray, keyShow );

                ShowKeystrokeAppendL( *showKeystrokeArray, *keystrokeArray, keyShow );

                for ( TInt i = keystrokeArray->Count() - 1; i >= 0; i-- )

                    {

                    if ( 0 == keystrokeArray->MdcaPoint( i ).

                            Compare( KPinyinStar ) )

                        {

                        offset = offset + 1;

                        }

                    else

                        {

                        break;

                        }

                    }

                if ( offset > KMaxStarCount )

                    {

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

                        {

                        keystrokeArray->Delete( keystrokeArray->Count() - 1 );

                        }

                    keystrokeArray->Compress();

                    }

                }

            ImplicitlyUpdateSelection();

            }

        else

            {

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

            }

        }

    return ETrue;

    }

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

// Optimize spelling

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

//

void TAknFepInputStateEntryPinyinPhrase::OptimizeSpellingL( CDesCArrayFlat& aOptimizeBefore, CDesCArrayFlat& aOptimizeAfter )

    {

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlPinyinPopup* popup = uiContainer->PinyinPopupWindow();

    CDesCArrayFlat* inEffectKeystrokeArray = popup->InEffectKeystrokeArray();

    TBool checkSeparator = EFalse;

    TBuf<KMaxPinyinLength> spellingBuf;

    TInt bufLength = 0;

    TInt countSeparator = 0;

    TInt countBuf[KMaxPhraseCount];

    memset( countBuf, 0, sizeof( countBuf ) );

    TInt position = 0;

    TInt i = 0;

    TInt j = 0;

    if ( 0 == inEffectKeystrokeArray->Count() )

        {

        return;

        }

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

        {

        if ( 0 == inEffectKeystrokeArray->MdcaPoint( i ).Compare( KPinyinListSeparator ) )

            {

            checkSeparator = ETrue;

            countBuf[countSeparator] = j;

            countSeparator = countSeparator + 1;

            }

        else

            {

            if (  0 == i  )

                {

                j = j + 1;

                }

            else

                {

                if ( ( 0 == inEffectKeystrokeArray->MdcaPoint( i ).Compare( KPinyinStar ) ) &&

                    ( 0 != inEffectKeystrokeArray->MdcaPoint( i - 1 ).Compare( KPinyinStar ) ))

                    {

                    j = j + 1;

                    }

                else if ( 0 != inEffectKeystrokeArray->MdcaPoint( i ).Compare( KPinyinStar ) )

                    {

                    j = j + 1;

                    }

                }

            }

        }

    j = 0;

    for ( i = 0; i < aOptimizeBefore.Count(); ++i )

        {

        j = 0;

        bufLength = 0;

        position = 0;

        spellingBuf.Size();

        spellingBuf.Copy( aOptimizeBefore.MdcaPoint( i ) );

        bufLength = spellingBuf.Length();

        while( j < bufLength )

            {

            position = spellingBuf.Find( KPinyinListSeparator );

            if ( position != KErrNotFound )

                {

                spellingBuf.Replace( position, 1, KPinyinManualSeparator );

                j = position + 1;

                }

            else

                {

                break;

                }

            }

        aOptimizeAfter.AppendL( spellingBuf );

        }    

    if ( !checkSeparator )

        {

        return;

        }

    aOptimizeBefore.Reset();

    aOptimizeBefore.Compress();

    for ( i = 0; i < aOptimizeAfter.Count(); ++i )

        {

        aOptimizeBefore.AppendL( aOptimizeAfter.MdcaPoint( i ) );

        }

    aOptimizeAfter.Reset();

    aOptimizeAfter.Compress();

    for ( TInt k = 0; k < aOptimizeBefore.Count(); ++k )

        {

        j = 0;

        bufLength = 0;

        position = 0;

        spellingBuf.Size();

        spellingBuf.Copy( aOptimizeBefore.MdcaPoint( k ) );

        bufLength = spellingBuf.Length();

        for ( TInt kk = 0; kk < bufLength; ++kk )

            {

            if ( 0 == spellingBuf.Mid( kk, 1 ).Compare( KPinyinManualSeparator ) )

                {

                for ( TInt kkk = 0; kkk < countSeparator; ++kkk)

                    {

                    if ( j == countBuf[kkk] )

                        {

                        spellingBuf.Replace( kk, 1, KPinyinListSeparator );

                        }

                    }

                }

            else

                {

                j = j + 1;

                }

            }

        aOptimizeAfter.AppendL( spellingBuf );

        }

    }

void TAknFepInputStateEntryPinyinPhrase::DeliberatelyUpdateSelection()

    {

    TPtr deliberateSelection = iOwner->GetLatestDeliberateSelection();

    CPtiEngine* ptiengine = iOwner->PtiEngine();

    MAknFepUICtrlContainerChinese* uiContainer = UIContainer();

    MAknFepUICtrlPinyinPopup* popup = uiContainer->PinyinPopupWindow();

    TInt selected = popup->CurrentSelection();

    ptiengine->EnableToneMarks(EFalse);

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

    deliberateSelection = spelling.Left(

                        MAknFepUICtrlInputPane::EMaxInputCharsPinyinPopupNotIncludingToneMark);

    ptiengine->EnableToneMarks(ETrue);

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

    RefreshUI(popup->CurrentVisibleSelection());

    }

void TAknFepInputStateEntryPinyinPhrase::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 ?