/*

* Copyright (c) 2007 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:  Retrieves the character map for each of the numeric keys.

*               Uses services provided by the PTI Engine.

*

*/

// INCLUDE FILES

#include "CPcsDebug.h"

#include "CPcsKeyMap.h"

#include <CPcsDefs.h>

#include <bldvariant.hrh>

#include <PtiEngine.h>

#include <PtiKeyMapData.h>

#include <AknFepInternalCRKeys.h>

#include <AvkonInternalCRKeys.h>

#include <centralrepository.h>

#include <CPsQuery.h>

#include <CPsQueryItem.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

// ============================== MEMBER FUNCTIONS ============================

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

// CPcsKeyMap::NewL

// Two Phase Construction

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

CPcsKeyMap* CPcsKeyMap::NewL()

    {

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

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

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

    return self;

    }

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

// CPcsKeyMap::CPcsKeyMap

// Constructor

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

CPcsKeyMap::CPcsKeyMap()

    {

    }

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

// CPcsKeyMap::ConstructL

// 2nd Phase Constructor

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

void CPcsKeyMap::ConstructL()

    {

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

    // UI Language

    iUILanguage = User::Language();

    // List of non-supported languages for this Algorithm

    iLanguageNotSupported.Append(ELangJapanese);

    iLanguageNotSupported.Append(ELangPrcChinese);

    iLanguageNotSupported.Append(ELangHongKongChinese);

    iLanguageNotSupported.Append(ELangTaiwanChinese);

    iLanguageNotSupported.Append(ELangKorean);

    TPtiKeyboardType physicalItutKbType;

    TPtiKeyboardType physicalQwertyKbType;    

    GetPhysicalKeyboardTypesL( physicalItutKbType, physicalQwertyKbType );

    iItutKeyboardType = EPtiKeyboard12Key; // We want to support Virtual Itu-T in most devices

    CreateKeyMappingL( EPredictiveItuT ); // Create structure for holding characters<-->key mappings

    if (iItutKeys.Count() == 0)

        {

        iItutKeyboardType = EPtiKeyboardNone;

        }

    iQwertyKeyboardType = physicalQwertyKbType;

    if (physicalQwertyKbType != EPtiKeyboardNone)

        {

        CreateKeyMappingL( EPredictiveQwerty ); // Create structure for holding characters<-->key mappings

        if (iQwertyKeys.Count() == 0)

            {

            iQwertyKeyboardType = EPtiKeyboardNone;

            }

        }

    // Set the Default Predictive keyboard mode. If Qwerty keyboard exists, it is always physical.

    iPredictiveDefaultKeyboardMode =

        (IsItutPredictiveAvailable() && physicalItutKbType != EPtiKeyboardNone) || !IsQwertyPredictiveAvailable() ?

            EPredictiveItuT : EPredictiveQwerty;

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

    // Sets attribute for holding info if "0" and " " are on the same key

    // Needed for decision if the "0" should be considered as a possible separator

    SetSpaceAndZeroOnSameKey();

    PRINT ( _L("CPcsKeyMap::ConstructL: ----------------------------------------"));

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

    }

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

// CPcsKeyMap::~CPcsKeyMap

// Destructor

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

CPcsKeyMap::~CPcsKeyMap()

    {

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

    // Cleanup local arrays

    iLanguageNotSupported.Reset();

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

        {

        for (TInt j = 0; j < TKeyMappingData::EKeyMapNumberArr; j++)

            {

            iItutKeyMaps[i]->iKeyMapCharArr[j].Close();

            }

        }

    iItutKeyMaps.ResetAndDestroy();

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

        {

        for (TInt j = 0; j < TKeyMappingData::EKeyMapNumberArr; j++)

            {

            iQwertyKeyMaps[i]->iKeyMapCharArr[j].Close();

            }

        }

    iQwertyKeyMaps.ResetAndDestroy();

    iItutKeys.Close();

    iQwertyKeys.Close();

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

    }

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

// CPcsKeyMap::IsItutPredictiveAvailable

// 

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

TBool CPcsKeyMap::IsItutPredictiveAvailable() const

    {

    return ( iItutKeyboardType != EPtiKeyboardNone );

    }

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

// CPcsKeyMap::IsQwertyPredictiveAvailable

// 

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

TBool CPcsKeyMap::IsQwertyPredictiveAvailable() const

    {

    return ( iQwertyKeyboardType != EPtiKeyboardNone );

    }

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

// CPcsKeyMap::IsModePredictive

// 

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

TBool CPcsKeyMap::IsModePredictive( TKeyboardModes aKbMode )

    {

    return ( (EPredictiveDefaultKeyboard == aKbMode) ||

             (EPredictiveItuT == aKbMode) ||

             (EPredictiveQwerty == aKbMode) );

    }

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

// CPcsKeyMap::ResolveKeyboardMode

// Resolve EPredictiveDefaultKeyboard or ENonPredictive mode to EPredictiveItuT

// or EPredictiveQwerty mode

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

TKeyboardModes CPcsKeyMap::ResolveKeyboardMode( TKeyboardModes aKbMode,

                                                TKeyboardModes aKbModeToResolve ) const

    {    

    // Substitute "default predictive" mode with actual mode

    if ( (aKbMode == aKbModeToResolve) &&

         ((aKbMode == ENonPredictive) || (aKbMode == EPredictiveDefaultKeyboard)) )

        {

        return iPredictiveDefaultKeyboardMode;

        }

    else

        {

        return aKbMode;

        }

    }

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

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

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

        {

        TChar character( aSrcData[i] );

        character.LowerCase();

        if ( i < aSrcQuery.Count() )

            {

            CPsQueryItem& currentItem = aSrcQuery.GetItemAtL(i);

            TPtiKey key = KeyForCharacterMultiMatch( aSrcData[i], currentItem.Mode() );

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

            // then append the character.

            if ( EPtiKeyNone == key )

                {

                PRINT3 ( _L("CPcsKeyMap::GetMixedKeyStringForDataL: Char at index %d not mapped to a key, appending char '%c' (#%d)"),

                         i, (TUint) character, (TUint) character );

                aDestStr.Append( character );

                }

            else 

                {

                aDestStr.Append( key );

                }

            }

        else

            {            

            PRINT2 ( _L("CPcsKeyMap::GetMixedKeyStringForDataL: Char '%c' (#%d) is taken exact (over query length)"),

                    (TUint) character, (TUint) character );

            aDestStr.Append( character );

            }

        }

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

             &aDestStr );

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

    }

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

// CPcsKeyMap::CharacterForKeyMappingExists

// Returns true if the character is mapped to the key

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

TBool CPcsKeyMap::CharacterForKeyMappingExists(

        TKeyMappingData& aKeyMap, TUint aIntChar) const

    {

    TBool found = EFalse;

    for (TInt j = TKeyMappingData::EKeyMapUILangArr; j <= TKeyMappingData::EKeyMapOthersLangArr; j++)

        {

        if ( KErrNotFound != aKeyMap.iKeyMapCharArr[j].Find(aIntChar) )

            {

            found = ETrue;

            break;

            }

        }

    return found;

    }

#ifdef _DEBUG

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

// CPcsKeyMap::CheckPotentialErrorConditions

//

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

void CPcsKeyMap::CheckPotentialErrorConditions(const RArray<TInt>& aPoolIndexArr, 

                                               const TChar& aChar,

                                               const RArray<TPtiKey>& aPtiKeys,

                                               const RPointerArray<TKeyMappingData>& aKeyMappings) const

    {

    PRINT ( _L("CPcsKeyMap::CheckPotentialErrorConditions: ===================================================") );

    PRINT ( _L("CPcsKeyMap::CheckPotentialErrorConditions: Checking potential error conditions") );

    PRINT ( _L("CPcsKeyMap::CheckPotentialErrorConditions: ---------------------------------------------------") );

    _LIT(KTextCharArr0, "is single char");

    _LIT(KTextCharArr1, "has \"UI\" priority");

    _LIT(KTextCharArr2, "has \"English\" priority");

    _LIT(KTextCharArr3, "has \"Others\" priority");

    const TPtrC charArrStr[] =

        { KTextCharArr0(), KTextCharArr1(), KTextCharArr2(), KTextCharArr3() };

    TFixedArray<TUint, TKeyMappingData::EKeyMapNumberArr> countArr;

    for ( TInt j = TKeyMappingData::EKeyMapSingleCharArr; j <= TKeyMappingData::EKeyMapOthersLangArr; j++ )

        {

        countArr[j] = 0;

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

            {

            if ( KErrNotFound != aKeyMappings[aPoolIndexArr[i]]->iKeyMapCharArr[j].Find((TUint) aChar) )

                {

                PRINT5 ( _L("CPcsKeyMap::CheckPotentialErrorConditions: Char '%c' (0x%04X) %S for pool %d with key '%c'"),

                        (TUint) aChar, (TUint) aChar, &charArrStr[j], aPoolIndexArr[i], aPtiKeys[aPoolIndexArr[i]] );

                countArr[j]++;

                }

            }

        }

    PRINT ( _L("CPcsKeyMap::CheckPotentialErrorConditions: ===================================================") );

#ifdef __WINS__

    /*

    The reference 4x10 QWERTY mappings of 9.2 emulator have each number mapped to two keys.

    That kind of mappings can't be handled correctly, so panic in debug would basically be correct.

    However, assertions are commented out for now to be able to do some testing.

    // Check in debug mode if we have wrong situations

    __ASSERT_DEBUG( (countArr[TKeyMappingData::EKeyMapSingleCharArr]  <= 1), Panic(EPanicPreCond_MultipleSingleCharMatching) );

    __ASSERT_DEBUG( (countArr[TKeyMappingData::EKeyMapUILangArr]      <= 1), Panic(EPanicPreCond_MultipleUIPriorityMatching) );

    __ASSERT_DEBUG( (countArr[TKeyMappingData::EKeyMapEnglishLangArr] <= 1), Panic(EPanicPreCond_MultipleEnglishPriorityMatching) );

    __ASSERT_DEBUG( (countArr[TKeyMappingData::EKeyMapOthersLangArr]  <= 1), Panic(EPanicPreCond_MultipleOthersPriorityMatching) );

    */

#endif // __WINS__

    }

#endif // _DEBUG        

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

// CPcsKeyMap::KeyForCharacterMultiMatch

// Considers possible that the same character can be in more pools.

// This case was verified at least in the following verified cases:

// - For some language version (i.e. Scandinavian with keys 'ä', 'å', 'ö'.

// - For some special characters in ITU-T 12 keys keyboards.

//   Example: '$' is under key '1' and '7', '£' is under key '1' and '5'.

// In case the character is in more pools the selection strategy is the following:

//   - 1st choice: if the keyboard is EPtiKeyboard12Key exclude the pool with '1'.

//   - 2nd choice: choose the 1st pool that has for a language the char as single char.

//   - 3rd choice: choose the 1st pool that has the char mapped for the UI language.

//   - 4th choice: choose the 1st pool that has the char mapped for the English language.

//   - 5th choice: choose the 1st pool that has the char mapped for the Other languages.

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

TPtiKey CPcsKeyMap::KeyForCharacterMultiMatch( const TChar& aChar, TKeyboardModes aKbMode ) const

    {    

    aKbMode = ResolveKeyboardMode( aKbMode, EPredictiveDefaultKeyboard ); 

    // Select key arrays to use according to keyboard mode

    const RArray<TPtiKey>* ptiKeyArray;

    const RPointerArray<TKeyMappingData>* keyMappingArray;

    TPtiKeyboardType kbType;

    GetPredictiveKeyboardData( aKbMode, ptiKeyArray, keyMappingArray, kbType );

    if ( !ptiKeyArray || !keyMappingArray || ptiKeyArray->Count() == 0 )

        {

        // No mappings available. This may be, for example, because aKbMode is non-predictive.

        // Return no mapping in that case to indicate that character should be treated in

        // non-predictive way.

        return EPtiKeyNone;

        }

    // Set an array of pool index matches (more matches are possible)

    RArray<TInt> poolIndexArr;

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

        {

        if ( CharacterForKeyMappingExists(*(*keyMappingArray)[i], (TUint) aChar) )

            {

            poolIndexArr.Append(i);

            PRINT4 ( _L("CPcsKeyMap::KeyForCharacterMultiMatch: Char '%c' (0x%04X) found in pool %d with key '%c'"),

                    (TUint) aChar, (TUint) aChar, i, (*ptiKeyArray)[i] );

            }

        }

    /* Choose the pool index depending on the number of matches.

     * If there are 2 or more matches, then the choice of the pool index depends on

     * a serie of conditions.

     */

    TInt poolIndex = KErrNotFound;

    // Character not found in any pool

    if ( poolIndexArr.Count() == 0 )

        {

        PRINT2 ( _L("CPcsKeyMap::KeyForCharacterMultiMatch: Char '%c' (0x%04X) NOT found from any pool"),

                 (TUint) aChar, (TUint) aChar );

        }

    // Character found in one pool (normal case)

    else if ( poolIndexArr.Count() == 1 )

        {

        poolIndex = poolIndexArr[0];

        PRINT2 ( _L("CPcsKeyMap::KeyForCharacterMultiMatch: Chosen (for unique match) pool %d with key '%c'"),

                poolIndex, (*ptiKeyArray)[poolIndex] );

        }

    /* Character found in more pools, this can happen in some known conditions:

     * - In some variants 'Ä' is in key 'A' and in key 'Ä'

     * - In ITUT keyboard '$' is in keys '1' and '7'. This happens for more chars.

     * - For different languages in N97 '/' is in different keys.

     */

    else // ( poolIndexArr.Count() > 1 )

        {

        /* If keybord is ITUT we exclude the key '1' from the posibility of being choosen,

         * infact some characters can be typed by key '1' and another key.

         * For example:

         *     '$' is under key '1' and '7',

         *     '£' is under key '1' and '5'.

         *

         * This is needed when the client passes updated chars to the engine.

         * i.e.: Existing contact are "!Mat" and "$Nathan",

         *       User types '7' and client passes '7' or 'p' matching only contact "$Nathan",

         *       In next query user types '2' and client passes '$2' or '$a' matching "!Mat" and "$Nathan".

         *       This is wrong, as "!Mat" should not be matched.

         * When the client will not pass updated chars to the engine, but the original (i.e.: "72" or "pa"),

         * this piece of code shall be removed.

         * With "client" it is referred to MCL contacts client.

         */

        if (EPtiKeyboard12Key == kbType)

            {

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

                {

                if ( EPtiKey1 == (*ptiKeyArray)[poolIndexArr[i]] )

                    {

                    poolIndexArr.Remove(i);

                    PRINT ( _L("CPcsKeyMap::KeyForCharacterMultiMatch: Key '1' excluded (for multi match - EPtiKeyboard12Key)") );

                    break;

                    }

                }

            if ( poolIndexArr.Count() == 1 )

                {

                poolIndex = poolIndexArr[0];

                PRINT2 ( _L("CPcsKeyMap::KeyForCharacterMultiMatch: Chosen (for unique match after removing key '1') pool %d with key '%c'"),

                        poolIndex, (*ptiKeyArray)[poolIndex] );

                }

            }

#ifdef _DEBUG

        CheckPotentialErrorConditions(poolIndexArr, aChar, *ptiKeyArray, *keyMappingArray);

#endif // _DEBUG        

        // Search the char in the char arrays in priority order, the 1st match is taken

        for ( TInt j = TKeyMappingData::EKeyMapSingleCharArr; j <= TKeyMappingData::EKeyMapOthersLangArr; j++ )

            {

            if ( KErrNotFound == poolIndex )

                {

                TInt positionLeftMostOnKeys = KErrNotFound; 

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

                    {

                    TInt position = (*keyMappingArray)[poolIndexArr[i]]->iKeyMapCharArr[j].Find((TUint) aChar);

                    if ( KErrNotFound != position )

                        {

                        // Get the key that has the char in the leftmost index.

                        // We consider that the char can be mapped in more than one key (this is really

                        // the case for instance in some Scandinavian variants).

                        // With this guess there is more possibility that we choose the key where the

                        // char is physically printed on the keyboard key.

                        // In order for this guessing strategy to work, chars for TPtiTextCase EPtiCaseUpper

                        // have to be added to the char arrays before any other TPtiTextCase.

                        if ( TKeyMappingData::EKeyMapUILangArr == j )

                            {

                            if ( ( KErrNotFound == positionLeftMostOnKeys ) || ( position < positionLeftMostOnKeys ) )

                                {

                                poolIndex = poolIndexArr[i];

                                positionLeftMostOnKeys = position;

                                }

                            }

                        // Get the 1st key that has the char mapped to it

                        else

                            {

                            poolIndex = poolIndexArr[i];

                            PRINT3 ( _L("CPcsKeyMap::KeyForCharacterMultiMatch: Chosen (for multi match - char arr: %d) pool %d with key '%c'"),

                                     j, poolIndex, (*ptiKeyArray)[poolIndex] );

                            break;

                            }

                        }

                    }

                }

            }

        } // else -> ( poolIndexArr.Count() > 1 )

    // Set the key value from the pool index

    TPtiKey key = EPtiKeyNone;

    if ( KErrNotFound != poolIndex )

        {

        key = (*ptiKeyArray)[poolIndex];

        }

    poolIndexArr.Close();

    return key;

    }