/*

* Copyright (c) 2002-2005 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:  Implementation of HWR engine

*

*/

//FEP INCLUDES

#include <AknFepGlobalEnums.h>

#include <aknfeppeninputenums.h>

#include <PtiHwrRecognizer.h>

//USER INCLUDES

#include "peninputhwrengine.h"

#include "peninputhwrfscndatastore.h"

// CONSTANT DEFINITION HEADER

#include "peninputhwrfscnstoreconstants.h"

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

// SplitString()

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

//

static TInt SplitString( const TPtrC &aPtr, 

    TUint16 aSeperator, 

    RPointerArray<HBufC>& aStringArray )

	{

	// phrase input mode

    TInt start = 0;

    TInt length = 0;

    for ( TInt i = 0; i < aPtr.Length(); i++ )

        {

        if ( aPtr[i] == aSeperator )

            {

            TPtrC segment( aPtr.Ptr() + start, length );

            TRAP_IGNORE( aStringArray.AppendL( segment.AllocL() ) );

            start += ( length + 1 );

            length = 0;

            }

        else

            {

            length++;               

            }

        }

    if ( length )

        {

        TPtrC segm( aPtr.Ptr() + start, length );

        TRAP_IGNORE( aStringArray.AppendL( segm.AllocL() ) );

        }

    return aStringArray.Count();

	}

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

// Symbian constructor

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

//

CAknFepHwrEngine* CAknFepHwrEngine::NewL( CPtiEngine* aPtiEngine, 

    CPeninputHwrfscnDataStore* aOwner )

    {

    CAknFepHwrEngine* self = new ( ELeave ) CAknFepHwrEngine();

    CleanupStack::PushL( self );

    self->ConstructL( aPtiEngine, aOwner );

    CleanupStack::Pop( self );//self

    return self;

    }

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

// C++ constructor

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

//

CAknFepHwrEngine::CAknFepHwrEngine()

    {

    iNeedSetNumberMode = EFalse;

    iNeedSetCase = EFalse;

    iNeedSetRange = EFalse;

    iRecognizer = NULL;    

    iOwnPtiEngine = EFalse;

    }

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

// destructor

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

//

CAknFepHwrEngine::~CAknFepHwrEngine()

    {

    if( iOwnPtiEngine )

        {

        delete iPtiEngine;

        }

    delete iCustomKeymap;

    delete iIdle;

    iNeedPermittedRanges.Close();

    }

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

// Second phase constructor

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

//

void CAknFepHwrEngine::ConstructL( CPtiEngine* aPtiEngine, 

    CPeninputHwrfscnDataStore* aOwner )

    {

    if( !aPtiEngine )

        {

        iPtiEngine = CPtiEngine::NewL( ETrue );

        iOwnPtiEngine = ETrue;

        }

    else

    	{

    	iPtiEngine = aPtiEngine;

    	}

    iIdle = CIdle::NewL( CActive::EPriorityIdle );

    iOwner = aOwner;

    }

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

// Convert stroke end mark

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

//

void CAknFepHwrEngine::ConvertStrokeEndMark( RArray<TPoint>& aTraceData, 

    TPoint aPnt1, TPoint aPnt2 )

    {

    TInt count = aTraceData.Count();

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

        {

    	if ( aTraceData[i] == aPnt1 )

    	    {

    		aTraceData.Remove( i );

    		aTraceData.Insert( aPnt2, i );

    	    }

        }

    }

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

// Do recoginize by engine

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

//

void CAknFepHwrEngine::DoRecognizeL( const RArray<TPoint>& aTraceData, 

    RPointerArray<HBufC>& aCandidates )

    {

    if ( !iRecognizer )

        {

        DoIdleConstructL();

        }

    TPoint ctrlStrokeEndMark = iOwner->StrokeEndMarkFromControl();

    if ( ctrlStrokeEndMark != iRecognizer->StrokeEndMark() )

        {

        ConvertStrokeEndMark( CONST_CAST( RArray<TPoint>&, aTraceData ), 

            iOwner->StrokeEndMarkFromControl(), 

            iRecognizer->StrokeEndMark() );

        iOwner->SetStrokeEndMark(); // make control's stroke end mark info same to engine

        }

    aCandidates.ResetAndDestroy();

    //Do recognition for number only    

    if ( iOwner->IsNumberOnly() )

        {     

        DoRecognizeOfNumberOnly( aTraceData,aCandidates );

        return;

        }

    TInt primaryCount = iRecognizer->Recognize( aTraceData, aCandidates ); 

    // filter recognized candidate, set start position for all ranges    

    TPtrC ptr( KSeparator );

    // remove uncessary aux candidate, including range separator 

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

        {

        if ( aCandidates[i]->Compare( KGestureBackspace ) == 0 )

        	{

        	// convert backspace returned by engine, to make sure it display correctly.

            *aCandidates[i] = KDisplayBackspace;

            break;

        	}

        }

    //reorder the secondary range

    ReorderSecondaryRange( aCandidates );

    // remove uncessary primary candidate

    TInt totallyCount = aCandidates.Count();

    TInt removePos = iTotalCandidateNum;        

    for ( TInt i = removePos; i < totallyCount; i++ )

         {

         delete aCandidates[removePos];

         aCandidates.Remove( removePos );

         } 

    // not allowing '-' to be the first char in chinese range 

    // not allowing '/' to be the first char in English and Number range 

    TPtrC dashPtr( KDash );

    TPtrC solidusPtr( KSolidus );

    if ( ( iPremaryRange == ERangeNative ) && 

        ( aCandidates[0]->Compare( dashPtr ) == 0 ) )

        {

        *aCandidates[0] = *aCandidates[1];

        *aCandidates[1] = dashPtr;

        }

    else if ( ( ( iPremaryRange == ERangeEnglish ) || 

        ( iPremaryRange == ERangeNumber ) ) 

        && ( aCandidates[0]->Compare( solidusPtr ) == 0 ) )

        {

        *aCandidates[0] = *aCandidates[1];

        *aCandidates[1] = solidusPtr;

        }

    }

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

// Do recognition when the range is only number

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

//

void CAknFepHwrEngine::DoRecognizeOfNumberOnly( const RArray<TPoint>& aTraceData, 

    RPointerArray<HBufC>& aCandidates )

    {

    if ( iNumberMode == EAknEditorPlainNumberModeKeymap )

        {

        TBuf<KPlainNumSize> buf;

        buf.Append( KNumberString() );

        buf.Append( KGestureBackspace );

        iRecognizer->RecognizeWithCharSet( aTraceData, aCandidates, buf );

        }

    else

        {

        iRecognizer->Recognize( aTraceData, aCandidates );

        }

    //find special char and do special handling

    TInt count = aCandidates.Count();

    for ( TInt i = count - 1; i >= 0; i-- )

        {

         //the space and enter are not allowed to be appeared in candidates

         if( ( *aCandidates[i] )[0] == KGestureSpace()[0] || 

             ( *aCandidates[i] )[0] == KGestureEnter()[0] )

             {

             delete aCandidates[i];

             aCandidates.Remove( i );

             }

         else if( aCandidates[i]->Compare( KGestureBackspace ) == 0 )

             {

             *aCandidates[i] = KDisplayBackspace; 

             }                    

        }

    if ( iCustomKeymap )

        {

        count = aCandidates.Count();

        for( TInt i = count - 1; i >= 0; i-- )

            {

            if( iCustomKeymap->Find( *aCandidates[i] ) == KErrNotFound )

                {

                delete aCandidates[i];

    	    	aCandidates.Remove( i );

                }

            }

        }

    // remove uncessary primary candidate

    count = aCandidates.Count() - iTotalCandidateNum;

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

        {

        delete aCandidates[iTotalCandidateNum];

        aCandidates.Remove( iTotalCandidateNum );

        }

    }

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

// Reorder secondary range in candidate list

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

//

void CAknFepHwrEngine::ReorderSecondaryRange( RPointerArray<HBufC>& aCandidates )

    {

    if( iRangeCount <= 1 )

        {

        return;

        }

    RPointerArray<HBufC> secondary;

    TInt auxCandidateNum = GetAuxCandidateNum();

    HBufC* secCandidate = NULL;          

    TInt candiateCount = aCandidates.Count();

    TInt primaryCountFromEng = 0;

    // Get all secondary candidates

    for( TInt i = 0; i < candiateCount; i++ )// "i" is the index of separater 

        {

        if( aCandidates[i]->CompareC( KSeparator ) == 0 )

            {

            if(primaryCountFromEng == 0)

                {

                // Save the primary candidates count from ptiengine

                primaryCountFromEng = i;

                }

            TInt auxCountFromEng = 0;

            while(i < candiateCount - 1 && aCandidates[++i]->CompareC( KSeparator ) != 0)

                {

                // calculate the secondary range candidate count

                auxCountFromEng++;

                // Copy all the secondary candidate to an array

                secCandidate = aCandidates[i]->Alloc();

                secondary.Append( secCandidate );

                }

            for(TInt j = 0; j < auxCandidateNum - auxCountFromEng ; j++ )

                {

                // supply empty secondary candidate when engine not return

                // enough cell

                secondary.Append( KNullDesC().Alloc() );

                }

            i--; // go back to the separator index

            }

        }

    // caculate the primary candidate count

    TInt primaryCount = 0;

    TInt rowCount = 0;

    if( iPremaryRange == ERangeNumber )

        {

        primaryCount = KCandidateCountNumMode - iRangeCount + 1;

        rowCount = 1;

        }

    else

        {

        primaryCount = KCandidateCountPerRow - iRangeCount + 1;

        rowCount = KCandidateRowCount;

        }

    // supply empty primary candidate when engine not return

    // enough cell

    if(primaryCountFromEng < primaryCount * rowCount)

        {

        for(TInt y = 0; y < primaryCount * rowCount - primaryCountFromEng; y++)

            {

            aCandidates.Insert( KNullDesC().Alloc(), primaryCountFromEng );

            }

        }   

    // insert secondary candidates into the end of each row

   	for( ; rowCount > 0; rowCount-- )

        {

        for( TInt m = 0; m < iRangeCount - 1; m++ )

            {

            TInt secondaryIndex = rowCount - 1 + m * auxCandidateNum;

            TInt insertPos = primaryCount * rowCount + m;

            aCandidates.Insert( secondary[secondaryIndex], insertPos );

            }

        }

    secondary.Reset();

    secondary.Close();

    }

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

// Do predictive using trigger string

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

//

void CAknFepHwrEngine::DoPredictiveL( const TDesC& aTriggerStr, 

    RPointerArray<HBufC>& aPredictives,

    TBool aNextPage )

    {

    // predictive only valid for Chinese

    if ( ( iLanguage != ELangPrcChinese ) &&

        ( iLanguage != ELangTaiwanChinese ) && 

        ( iLanguage != ELangHongKongChinese ) )

    	{

    	return;    	

    	}

    // activate correct pti language according to given language

    if ( !aNextPage )

        {

    	iPtiEngine->SetCandidatePageLength( KPredictiveCountPerPage );

    	aPredictives.ResetAndDestroy();

    	if( !iPtiEngine->SetPredictiveChineseChar( aTriggerStr ) )

    		{

    		return;

    		}

        }

    else

        {

        if ( !iPtiEngine->NextCandidatePage() )

            {

        	return;

            }

        }

    TPtrC ptr = iPtiEngine->CandidatePage();    

    if ( ( iPtiEngine->InputMode() == EPtiEnginePinyinVkb ) || 

        ( iPtiEngine->InputMode() == EPtiEngineStrokeByPhrase ) ||

        ( iPtiEngine->InputMode() == EPtiEngineZhuyinVkb ) )

    	{

    	SplitString( ptr, KSegment, aPredictives );

    	}

    else

        {

        TInt predictiveCandidateNum = ptr.Length();

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

            {

            aPredictives.Append( ptr.Mid( i,1 ).AllocL() );

            }

        }	

    }

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

// Do homophonic using trigger string

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

//

void CAknFepHwrEngine::DoHomophonicL( const TDesC& aTriggerStr, 

                                      RPointerArray<HBufC>& aHomophonic )

    {

    // homophonic only valid for PRC Chinese and Taiwan Chinese

    if ( ( iLanguage == ELangPrcChinese ) || 

        ( iLanguage == ELangTaiwanChinese ) )

        {

        iPtiEngine->SetCandidatePageLength( KMaxHomophonicCandidateCount );

        aHomophonic.ResetAndDestroy();

        // get the spelling of the character

        TBuf<KMaxSpellingsLettersNum> spelling;

        TPtiSpelling spellingType = EPtiPinyin;

        if ( iPtiEngine->InputMode() == EPtiEnginePinyinVkb )

            {

            spellingType = EPtiPinyin;

            }

        else if ( iPtiEngine->InputMode() == EPtiEngineZhuyinVkb )

            {

            spellingType = EPtiZhuyin;

            }

        TInt result = iPtiEngine->GetSpelling( aTriggerStr[0], 

            spelling, spellingType );    

        if( KErrNone != result )

            {

            return;

            }

        // get homophonic or polyphonic candidates by spelling    

        GetHomophonicAndPolyphonic( spelling, aHomophonic );  

        // delete the repeated characters                                        

        TInt count = aHomophonic.Count();

        for ( TInt i = count - 1; i >= 0; i-- )

            {

            if ( aTriggerStr == *( aHomophonic[i] ) )

                {

                delete aHomophonic[i];

                aHomophonic.Remove( i );

                }

            }

        // remove the seleted character to the first cell    

        aHomophonic.Insert( aTriggerStr.AllocL(), 0 );       

        }

    }

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

// Get homophonic or polyphonic candidates

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

//

void CAknFepHwrEngine::GetHomophonicAndPolyphonic( TDes& aSpelling, 

    RPointerArray<HBufC>& aHomophonic )

    {

    TInt index = KErrNotFound;

    TBuf<KMaxOneSpellingLettersNum> tmpSpelling;

    while( aSpelling != KNullDesC16 )

        {

        tmpSpelling.Zero();    

		// find the separator

        index = aSpelling.Find( KPolyphonicSeparator );

        if( index != KErrNotFound )

            {

			// get one spelling in the polyphonic string

            tmpSpelling = aSpelling.Left( index );

			// remove the left spelling and a separator

            aSpelling = aSpelling.Right( aSpelling.Length() - index - 1 );

            }

        else // only one spelling

            {

            tmpSpelling = aSpelling;

            aSpelling = KNullDesC16;

            }

		// get candidate for each spelling

        RPointerArray<HBufC> candidates;

        HBufC* formatString = iPtiEngine->GetCandidatesByInputString( 

            tmpSpelling, 

            candidates, 

            EFalse );

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

            {

            aHomophonic.Append( candidates[i] );        

            }

        delete formatString;