#include "CPsQueryItem.h"

#include <PtiEngine.h>

#include <PtiKeyMapData.h>

// Unnamed namespace for local definitions

namespace {

#ifdef _DEBUG

    enum TPanicCode

    {

        EPanicPreCond_MultipleSingleCharMatching = 1,

        EPanicPreCond_MultipleUIPriorityMatching = 2,

        EPanicPreCond_MultipleEnglishPriorityMatching = 3,

        EPanicPreCond_MultipleOthersPriorityMatching = 4,

        EPanic_OverflowInPoolIndex = 5,

        EPanic_InvalidKeyboardType = 6

   };

    void Panic(TInt aReason)

    {

        _LIT(KPanicText, "CPcsKeyMap");

        User::Panic(KPanicText, aReason);

    }

#endif // DEBUG

} // namespace

    iLanguageNotSupported.Append(ELangKorean);

    SetupKeyboardTypesL();

    SetSpaceAndZeroOnSameKey();

    // Always add English mappings first

    AddKeyMapforConcreteKeyboardL( ELangEnglish );

    // Then append the mappings of the current input language

    TLanguage lang = iAlgorithm->FindUtilECE()->CurrentInputLanguage();

    if ( lang != ELangEnglish && IsLanguageSupportedL(lang) )

        {

        AddKeyMapforConcreteKeyboardL( lang );

        }

    ConstructConcreteKeyMapL();

    // Always add English mappings first

    AddKeyMapforConcreteKeyboardL( ELangEnglish );

    // Then append the mappings of the current input language

    if ( lang != ELangEnglish && IsLanguageSupportedL(lang) )

        {

        AddKeyMapforConcreteKeyboardL( lang );

        }

// CPcsKeyMap::SetupKeyboardTypesL

// Initialise the keyboard type variables

void CPcsKeyMap::SetupKeyboardTypesL()

    PRINT1 ( _L("CPcsKeyMap::ConstructL: Physical keyboard support flag = 0x%02X"), physicalKeyboard );

    const TInt KPtiKeyboard12Key = 0x01;

    const TInt KPtiKeyboardQwerty4x12 = 0x02;

    const TInt KPtiKeyboardQwerty4x10 = 0x04;

    const TInt KPtiKeyboardQwerty3x11 = 0x08;

    const TInt KPtiKeyboardHalfQwerty = 0x10;

    const TInt KPtiKeyboardCustomQwerty = 0x20; 

    // Setup ITU-T mode first.

    // Use always 12-key mode since all the supported devices should have at least

    // virtual ITU-T available.

    iItutKeyboardType = EPtiKeyboard12Key;

    // TODO: ITU-T type could be set to "none" if device does not have either

    // virtual keypad or hardware ITU-T available. This could be decided according

    // some cenrep value, feature flag, device model, or platform version.

    // Then setup QWERTY mode. On real-life devices there should never

    // be more than one QWERTY keyboard available but on emulator there can be several.

    // Use the first one found in the following precedence

    if ( physicalKeyboard & KPtiKeyboardQwerty3x11 )

        iQwertyKeyboardType = EPtiKeyboardQwerty3x11;

    else if ( physicalKeyboard & KPtiKeyboardQwerty4x10 )

        iQwertyKeyboardType = EPtiKeyboardQwerty4x10;

        }

    else if ( physicalKeyboard & KPtiKeyboardQwerty4x12 )

        {

        iQwertyKeyboardType = EPtiKeyboardQwerty4x12;

    else if ( physicalKeyboard & KPtiKeyboardCustomQwerty )

        iQwertyKeyboardType = EPtiKeyboardCustomQwerty;

        }

    else if ( physicalKeyboard & KPtiKeyboardHalfQwerty )

        {

        iQwertyKeyboardType = EPtiKeyboardHalfQwerty;

        iQwertyKeyboardType = EPtiKeyboardNone;

    // Decide, which keyboard is used for the "default" matching mode.

    // If there is physical ITU-T available, or there's no physical QWERTY,

    // then ITU-T is default.

    iItutIsDefault = (physicalKeyboard & KPtiKeyboard12Key) || 

                     (iQwertyKeyboardType == EPtiKeyboardNone);

    PRINT1 ( _L("CPcsKeyMap::ConstructL: ITU-T Keyboard chosen for Predictive Search = %d"), iItutKeyboardType );

    PRINT1 ( _L("CPcsKeyMap::ConstructL: QWERTY Keyboard chosen for Predictive Search = %d"), iQwertyKeyboardType );

void CPcsKeyMap::ConstructConcreteKeyMapL()

    if ( iItutKeyboardType != EPtiKeyboardNone )

        // Construct for Itut keyboard by default

        PRINT ( _L("CPcsKeyMap::ConstructConcreteKeyMapL: Construct keymap for ITU-T"));

        ConstructForItutKeyboardL();

        }

    if ( iQwertyKeyboardType != EPtiKeyboardNone )

        {

        // Construct for any QWERTY keyboard

        PRINT1 ( _L("CPcsKeyMap::ConstructConcreteKeyMapL: Construct keymap for QWERTY keyboard type %d"), 

                 iQwertyKeyboardType );

        ConstructForQwertyKeyboardL( iQwertyKeyboardType );

void CPcsKeyMap::AddKeyMapforConcreteKeyboardL( TLanguage aLanguage )

    if ( iItutKeyboardType != EPtiKeyboardNone )

        AddKeyMapforItutL( aLanguage );

        }

    if ( iQwertyKeyboardType != EPtiKeyboardNone )

        {

        AddKeyMapForQwertyKeyboardL( aLanguage, iQwertyKeyboardType );

    const TInt ItutKeyMappingsCount = iItutKeyMappings.Count();

    const TInt qwertyKeyMappingsCount = iQwertyKeyMappings.Count();

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

        iItutKeyMappings[i]->iKeyMappingArray.Reset();

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

        {

        iQwertyKeyMappings[i]->iKeyMappingArray.Reset();

        }

    }

    iItutKeyMappings.ResetAndDestroy();

    iItutKeys.Close();

    iQwertyKeyMappings.ResetAndDestroy();

    iQwertyKeys.Close();

// CPcsKeyMap::GetMixedKeyStringForQueryL

// aDestStr will have the length as the number of items in aSrcQuery.

void CPcsKeyMap::GetMixedKeyStringForQueryL(

        CPsQuery& aSrcQuery, TDes& aDestStr) const

{

    PRINT ( _L("Enter CPcsKeyMap::GetMixedKeyStringForQueryL") ); 

    GetMixedKeyStringForDataL( aSrcQuery, aSrcQuery.QueryAsStringLC(), aDestStr );

    CleanupStack::PopAndDestroy(); //result of QueryAsStringLC

    PRINT ( _L("End CPcsKeyMap::GetMixedKeyStringForQueryL") );

}

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

// CPcsKeyMap::GetMixedKeyStringForDataL

// aDestStr will have the same length as aSrcData. aSrcQuery can be shorter.

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

void CPcsKeyMap::GetMixedKeyStringForDataL(

        CPsQuery& aSrcQuery, const TDesC& aSrcData, TDes& aDestStr) const

{

    PRINT ( _L("Enter CPcsKeyMap::GetMixedKeyStringForDataL") );

    const TInt srcDataLength = aSrcData.Length(); 

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

        TChar character( aSrcData[i] );

        character.LowerCase();

        if ( i < aSrcQuery.Count() )

            CPsQueryItem& currentItem = aSrcQuery.GetItemAtL(i);

            TKeyboardModes curMode = ResolveKeyboardMode( currentItem.Mode() );

            TPtiKey key = KeyForCharacter( aSrcData[i], curMode );

            // If a character is not mapped to any key or it's entered in non-predictive mode,

            // then append the character as exact.

            if ( EPtiKeyNone == key )

                {

                aDestStr.Append( character );

                }

            else

                {

                aDestStr.Append( DefaultCharForKey(key, curMode) );

                }

            // characters over query length are taken as exact

            aDestStr.Append( character );

    PRINT1 ( _L("CPcsKeyMap::GetMixedKeyStringForDataL: Return string: \"%S\""),

             &aDestStr );

    PRINT ( _L("End CPcsKeyMap::GetMixedKeyStringForDataL") );

}

TPtiKey CPcsKeyMap::KeyForCharacter(TText aChar, TKeyboardModes aKbMode) const

    const RPointerArray<TKeyMappingData>* keyMappings = KeyMappings( aKbMode );

    // Don't return any key in the exact mode

    if ( !keyMappings )

        {

        return EPtiKeyNone;

        }

    TText lChar = User::LowerCase(aChar);

    const TInt count = keyMappings->Count() - 1;

        index = (*keyMappings)[i]->iKeyMappingArray.Find(lChar);

            return (*keyMappings)[i]->iKey;

    return EPtiKeyNone;

// CPcsKeyMap::AddKeyMapForQwertyKeyboardL

void CPcsKeyMap::AddKeyMapForQwertyKeyboardL(TLanguage aLanguage, TPtiKeyboardType aKbType)

#ifdef RD_INTELLIGENT_TEXT_INPUT

    iPtiEngine->ActivateLanguageL(aLanguage);

    iPtiEngine->SetKeyboardType(aKbType);

    CPtiCoreLanguage* coreLanguage = static_cast<CPtiCoreLanguage*>(iPtiEngine->GetLanguage( aLanguage ));

    if (coreLanguage)

        CPtiKeyMapData* ptiKeyMapData = coreLanguage->RawKeyMapData();

        const TInt qwertyKeyMappingsCount = iQwertyKeyMappings.Count() - 1;

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

            AddDataForQwertyKeyboardL( ptiKeyMapData, aKbType, 

                    iQwertyKeys[i], *(iQwertyKeyMappings[i]) );

// CPcsKeyMap::ConstructForQwertyKeyboardL

// Destructor

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

void CPcsKeyMap::ConstructForQwertyKeyboardL(TPtiKeyboardType aKbType)

    {

#ifdef RD_INTELLIGENT_TEXT_INPUT

    CreateKeyListFromKeyBindingTable( iQwertyKeys, aKbType );

    // Now add the keymap arrays to hold the keymap data

    const TInt qwertyKeysCount = iQwertyKeys.Count();

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

        {

        TKeyMappingData* keyData = new (ELeave) TKeyMappingData;

        keyData->iKey = iQwertyKeys[i];

        iQwertyKeyMappings.Append(keyData);

        }

    PRINT ( _L("----------------------------------------"));

#endif //RD_INTELLIGENT_TEXT_INPUT

    }

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

// CPcsKeyMap::AddDataForQwertyKeyboardL

void CPcsKeyMap::AddDataForQwertyKeyboardL(CPtiKeyMapData* aPtiKeyMapData,

                                           TPtiKeyboardType aKbType,

                                           TPtiKey aKey,

                                           TKeyMappingData& aKeyDataList)

    for (TInt i = 0; i < sizeof(caseArray) / sizeof(TPtiTextCase); i++)

        TPtrC result = aPtiKeyMapData->DataForKey(aKbType, aKey, caseArray[i]);

        const TInt resultLength = result.Length(); 

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

            aKeyDataList.iKeyMappingArray.Append(result[j]);

        PRINT2 ( _L("CPcsKeyMap: Mapping for Key %c = %S"), aKey, &result)

void CPcsKeyMap::ConstructForItutKeyboardL()

    iItutKeys.Append(EPtiKey0);

    iItutKeys.Append(EPtiKey1);

    iItutKeys.Append(EPtiKey2);

    iItutKeys.Append(EPtiKey3);

    iItutKeys.Append(EPtiKey4);

    iItutKeys.Append(EPtiKey5);

    iItutKeys.Append(EPtiKey6);

    iItutKeys.Append(EPtiKey7);

    iItutKeys.Append(EPtiKey8);

    iItutKeys.Append(EPtiKey9);

    iItutKeys.Append(EPtiKeyNone);

    const TInt ltutKeysCount = iItutKeys.Count();

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

        keyData->iKey = iItutKeys[i];

        iItutKeyMappings.Append(keyData);

    // Activate given language and get corresponding language object

    iPtiEngine->ActivateLanguageL(aLanguage);

    CPtiCoreLanguage* coreLanguage = static_cast<CPtiCoreLanguage*> (iPtiEngine->GetLanguage(aLanguage));

    if (coreLanguage)