/*

* 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 <PtiDefs.h>

#include <PtiKeyMappings.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,

   };

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

#ifdef RD_INTELLIGENT_TEXT_INPUT

    TInt physicalKeyboard = 0;

    CRepository* aknFepRepository = CRepository::NewL( KCRUidAknFep );

    aknFepRepository->Get( KAknFepPhysicalKeyboards, physicalKeyboard );

    delete aknFepRepository;

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

    // Constants follow the definition of KAknFepPhysicalKeyboards

    const TInt ptiKeyboard12Key = 0x01;

    //const TInt ptiKeyboardQwerty4x12 = 0x02;    // Not used at the moment

    const TInt ptiKeyboardQwerty4x10 = 0x04;

    const TInt ptiKeyboardQwerty3x11 = 0x08;

    const TInt ptiKeyboardHalfQwerty = 0x10;

    //const TInt ptiKeyboardCustomQwerty = 0x20;  // Not used at the moment

    // The following if contains the order of precedence given for keyboards

    // i.e. one phone has both "ITUT 12 Key" and "Qwerty 4x10" physical keyboards

    if ( physicalKeyboard & ptiKeyboard12Key )

        {

        iKeyboardType = EPtiKeyboard12Key;

        }

    else if ( physicalKeyboard & ptiKeyboardHalfQwerty )

        {

        iKeyboardType = EPtiKeyboardHalfQwerty;

        }

    else if ( physicalKeyboard & ptiKeyboardQwerty4x10 )

        {

        iKeyboardType = EPtiKeyboardQwerty4x10;

        }

    else if ( physicalKeyboard & ptiKeyboardQwerty3x11 )

        {

        iKeyboardType = EPtiKeyboardQwerty3x11;

        }

    else

#endif // RD_INTELLIGENT_TEXT_INPUT

        {

        iKeyboardType = EPtiKeyboard12Key; // default

        }

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

    // Create structure for holding characters<-->key mappings

    CreateKeyMappingL();

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

        {

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

            {

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

            }

        }

    iKeyMapPtrArr.ResetAndDestroy();

    iKeysArr.Close();

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

    }

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

// CPcsKeyMap::GetMixedKeyStringForQueryL

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

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

void CPcsKeyMap::GetMixedKeyStringForQueryL(CPsQuery& aSrcQuery, TDes& aDestStr)

{

    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)

{

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

            switch ( currentItem.Mode() )

                {

                case EItut:

                    {

                    TPtiKey key = KeyForCharacterMultiMatch(aSrcData[i]);

                    // If a character is not mapped to numeric key 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 );

                        }

                    }

                    break;

                case EQwerty:

                    //fall through

                default:

                    PRINT2 ( _L("CPcsKeyMap::GetMixedKeyStringForDataL: Char '%c' (#%d) is taken exact (non predictive in query)"),

                            (TUint) character, (TUint) character );

                    aDestStr.Append( character );

                    break;

                }

            }

        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, const TUint aIntChar)

    {

    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(RArray<TInt>& aPoolIndexArr, const TChar& aChar)

    {

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

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

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

    _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 != iKeyMapPtrArr[aPoolIndexArr[i]]->iKeyMapCharArr[j].Find((TUint) aChar) )

                {

                PRINT5 ( _L("CPcsKeyMap::KeyForCharacterMultiMatch: Char '%c' (#%d) %S for pool %d with key '%c'"),

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

                countArr[j]++;

                }

            }

        }

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

#ifdef __WINS__

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

    {

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

    RArray<TInt> poolIndexArr;

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

        {

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

            {

            poolIndexArr.Append(i);

            PRINT4 ( _L("CPcsKeyMap::KeyForCharacterMultiMatch: Char '%c' (#%d) found in pool %d with key '%c'"),

                    (TUint) aChar, (TUint) aChar, i, iKeysArr[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' (#%d) NOT found in all pools"),

                 (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, iKeysArr[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 == iKeyboardType)

            {

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

                {

                if ( EPtiKey1 == iKeysArr[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, iKeysArr[poolIndex] );

                }

            }

#ifdef _DEBUG

        CheckPotentialErrorConditions(poolIndexArr, aChar);

#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 = iKeyMapPtrArr[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, iKeysArr[poolIndex] );

                            break;

                            }

                        }

                    }

                }

            }

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

    // Set the key value from the pool index

    TPtiKey key = EPtiKeyNone;

    if ( KErrNotFound != poolIndex )

        {

        key = iKeysArr[poolIndex];

        }

    poolIndexArr.Close();

    return key;

    }

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

// CPcsKeyMap::PoolIdForKey

//

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

TInt CPcsKeyMap::PoolIdForKey(const TPtiKey aKey)

    {

    TInt poolId = iKeysArr.Find(aKey);

    // IF the key is not found, then it should go to the special pool,

    // which is the last pool of iKeyMapPtrArr

    if (KErrNotFound == poolId)

        {

        poolId = PoolCount() - 1;

        }

    return poolId;

    }

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

// CPcsKeyMap::PoolIdForCharacter

//

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

TInt CPcsKeyMap::PoolIdForCharacter(const TChar& aChar)

    {

    TPtiKey key = KeyForCharacterMultiMatch(aChar);

    TInt poolId = PoolIdForKey(key);

    return poolId;

    }

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

// CPcsKeyMap::PoolCount

//

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

TInt CPcsKeyMap::PoolCount()

    {

    return iKeyMapPtrArr.Count();

    }

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

// CPcsKeyMap::SetSpaceAndZeroOnSameKey

// 

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

void CPcsKeyMap::SetSpaceAndZeroOnSameKey()

    {

    const TInt KSpace = 32; // ASCII for " "

    const TInt KZero  = 48; // ASCII for "0"

    TChar charSpace(KSpace);

    TChar charZero(KZero);

    TPtiKey keySpace = KeyForCharacterMultiMatch(charSpace);

    TPtiKey keyZero = KeyForCharacterMultiMatch(charZero);

    iSpaceAndZeroOnSameKey = (keySpace == keyZero);