/*

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

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

    // 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 j = 0; j < TKeyMappingData::EKeyMapNumberArr; j++)

            {

            }

        }

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

    }

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

// CPcsKeyMap::GetMixedKeyStringForQueryL

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

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

    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(

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

                {

                }

            }

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

//

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

    {

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

            {

                {

                countArr[j]++;

                }

            }

        }

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

#ifdef __WINS__

    // Check in debug mode if we have wrong situations

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

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

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

    RArray<TInt> poolIndexArr;

        {

            {

            poolIndexArr.Append(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 )

        {

                 (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'"),

        }

    /* 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.

         */

            {

            for ( TInt i = 0; i < poolIndexArr.Count() ; 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'"),

                }

            }

#ifdef _DEBUG

#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++ )

                    {

                    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'"),

                            break;

                            }

                        }

                    }

                }

            }

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

    // Set the key value from the pool index

    TPtiKey key = EPtiKeyNone;

    if ( KErrNotFound != poolIndex )

        {

        }

    poolIndexArr.Close();

    return key;

    }

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

// CPcsKeyMap::PoolIdForKey

//

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

    {

        {

        }