/*

* 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:         Western Find Utilities implementation file.

*

*/

#include "FindUtilWestern.h"

#include <collate.h>

#include <PtiIndicDefs.h>

#include "FindUtilKorean.h"

#include <avkon.rsg>

#include <StringLoader.h>

const TInt KLitTab('\t');

const TInt KLitSpace(' ');

const TInt KLitHyphen('-');

const TInt KLitLineFeed(8233);

const TInt KLitStar('*');

const TInt KLitQuestion('?');

const TInt KMatchingBufferLength(256);

const TInt KAknStringBufferSize = 256;

namespace {

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

// IsFindWordSeparator

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

//

inline TBool IsFindWordSeparator(TChar aCh)

    {

    return aCh == KLitSpace || aCh == KLitHyphen || aCh == KLitTab || aCh == KLitLineFeed;

    }

void ReplaceCharacters(TDes &aDes, const TDesC &aChars, TChar aReplacement)

    //

    // Running time O(aDes.Length() * aChars.Length())

    // Does not change length of the string.

    // 

    {

    TInt src = 0;

    TInt srclength = aDes.Length();

    while(src < srclength)

        {

        TChar c = aDes[src];

        if (aChars.LocateF(c) != KErrNotFound)

            aDes[src] = TUint16(aReplacement);

        ++src;

        }

    }

inline TInt MyFindC(const TDesC &aItemString, const TDesC &aSearchText)

    {

    TBuf<200> searchText;

    TBuf<200> itemString;

    searchText.Append(aSearchText);

    // The replacecharacters are to disable regexp matching provided

    // by MatchC().

	_LIT(KQuestion,"?");

	_LIT(KStar,"*");

    ReplaceCharacters(searchText, KQuestion, TChar('\t'));

    ReplaceCharacters(searchText, KStar, TChar('\r'));

    searchText.Append(KStar);

    if (aItemString.Length() < 200)

        itemString.Append(aItemString);

    else

        itemString.Append(aItemString.Left(200));

    ReplaceCharacters(itemString, KQuestion, TChar('\t'));

    ReplaceCharacters(itemString, KStar, TChar('\r'));

    TInt length = itemString.Length();

    for(int i=0;i<length;i++)

        {

        if (i==0 || IsFindWordSeparator(aItemString[i-1]))

            {

            if (itemString.Mid(i).MatchC(searchText) != KErrNotFound)

                {

                return i;

                }

            }

        }

    return KErrNotFound;

    }

inline TBool IsFindMatchClassic(const TDesC& aItemString, const TDesC& aSearchText, TInt /*aInputLang = 0*/)

    {

    TPtrC itemptr = aItemString;

    TPtrC searchptr = aSearchText;

    TBool match = EFalse;

    for(;;) 

        {

        // Loop invariant: itemptr is next character from ' ' or '-'

        // Loop invariant: seachptr is at beginning of searched item

        TInt val = MyFindC(itemptr,searchptr);

        if (val == 0)

            {

            match = ETrue;

            break;

            }

        if (val != KErrNotFound && IsFindWordSeparator(itemptr[val-1]))

            {

            match = ETrue;

            break;

            }

        // find the word separator characters from list item

        TInt spacepos = itemptr.LocateF(TChar(' '));

        TInt minuspos = itemptr.LocateF(TChar('-'));

        TInt tabpos = itemptr.LocateF(TChar('\t'));

        if (spacepos != KErrNotFound)

            {

            itemptr.Set(itemptr.Mid(spacepos+1));

            }

        else if (minuspos != KErrNotFound)

            {

            itemptr.Set(itemptr.Mid(minuspos+1));

            }

        else if (tabpos != KErrNotFound)

            {

            itemptr.Set(itemptr.Mid(tabpos+1));

            }

        else

            {

            match = EFalse;

            break;

            }

        if (itemptr.Length() == 0)

            {

            match = EFalse;

            break;

            }

        }

    return match;

    }

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

// IsFindMatch

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

//

inline TBool IsFindMatch(const TDesC& aItemString, const TDesC& aSearchText, TInt aInputLang = 0)

    {

    TBuf<200> searchText;

    TInt itemStringLength = aItemString.Length();

    if ( aSearchText.Length() < 200 )

        {

        searchText.Append( aSearchText );

        }

    else

        {

        searchText.Append( aSearchText.Left(199) );

        }

    // To disable the wildchar matching provided by MatchC

    if (aSearchText.Locate( KLitQuestion ) != KErrNotFound)

        {

        return IsFindMatchClassic(aItemString, aSearchText, aInputLang);

        }

    if (aSearchText.Locate( KLitStar ) != KErrNotFound)

        {

        return IsFindMatchClassic(aItemString, aSearchText, aInputLang);

        }

    searchText.Append( KLitStar );

    TInt result = KErrNone;

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

        {

        if ( i==0 || IsFindWordSeparator( aItemString[i-1] ) )

            {

            if(aInputLang == ELangHindi

#ifdef RD_MARATHI

                || aInputLang == ELangMarathi

#endif

#ifdef RD_HINDI_PHONETIC_INPUT

                || aInputLang == KLangHindiPhonetic

#endif            

            )

            {

            TUint flag = ( TCollationMethod::EIgnoreNone | TCollationMethod::EFoldCase | TCollationMethod::EIgnoreCombining );

        	TCollationMethod m = *Mem::GetDefaultMatchingTable();

  			m.iFlags |= flag;

        	result = aItemString.Mid(i).MatchC( searchText, &m, 3);

            }

            else

            {

            	result = aItemString.Mid(i).MatchC( searchText );

            }

            if(result != KErrNotFound)

            	{

            		return ETrue;

            	}

            }

        }

    return EFalse;

	}	

}

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

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

// CFindUtilWestern::CFindUtilWestern

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CFindUtilWestern::CFindUtilWestern()

    {

    iRepository = NULL;

    iNotifyHandler = NULL;

    }

// Destructor

CFindUtilWestern::~CFindUtilWestern()

    {

    if ( iNotifyHandler )

        {

        iNotifyHandler->StopListening();

        delete iNotifyHandler;

        iNotifyHandler=NULL;

        }

    if(iRepository)

        {

        delete iRepository;

        iRepository = NULL;    

        }    	

    if ( iFindUtilKorean )

        {

    	delete iFindUtilKorean;

    	iFindUtilKorean = NULL;

        }

    if( iDigraphChars )       

        {

        delete iDigraphChars;

        }

    }

void CFindUtilWestern::OpenL()

	{

	CFindUtilBase::OpenL();

    if(!iRepository)

    	{

		iRepository = CRepository::NewL(KCRUidAknFep);

		iRepository->Get(KAknFepInputTxtLang, iInputLanguage);

	    }

	if(!iNotifyHandler)

	    {

		iNotifyHandler = CCenRepNotifyHandler::NewL( *this, 

                                              *iRepository,

                                              CCenRepNotifyHandler::EIntKey,

                                              KAknFepInputTxtLang );

		iNotifyHandler->StartListeningL();

	    }	

//TSW: LYEE-7Q2GRV  

	if(!iFindUtilKorean)

	    {

        iFindUtilKorean = CFindUtilKorean::NewL();

	    }

	}

void CFindUtilWestern::HandleNotifyInt( TUint32 aId, TInt aNewValue )

	{

	if(aId == KAknFepInputTxtLang)

	    iInputLanguage = aNewValue;

	}

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

// CFindUtilWestern::Match

// (other items were commented in a header).

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

//

TBool CFindUtilWestern::Match(const TDesC& aContactsField, const TDesC& aWord)

    {

    if ( iFindUtilKorean->IsKoreanLanguage( aContactsField ) || iFindUtilKorean->IsKoreanLanguage( aWord ) )

        {

        return iFindUtilKorean->Match( aContactsField, aWord );	

        }

    else

    	{

    TInt numChar = 1;

    	if (!aContactsField.Length())

        	{

                _LIT( KNone, "*" );

    	        if( aWord.CompareC(KNone()) == 0 )

                    {

    	            return ETrue;

                    }

                else

                    {

        	    return EFalse;

                    }

        	}        

    	if((aWord.Length() > 1) && aWord[aWord.Length()-2] == 0x200B)

    		{

    		numChar = 2;

    		}    	

    	if ( IsFindMatch(aContactsField, aWord.Left(aWord.Length()-numChar), iInputLanguage) )

        	{

        	return ETrue;

        	}

  		return EFalse;

   		}

    }

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

// CFindUtilWestern::MatchRefineL

// (other items were commented in a header).

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

//

TBool CFindUtilWestern::MatchRefineL( const TDesC& aItemString, const TDesC& aSearchText )

    {

    if ( iFindUtilKorean->IsKoreanLanguage( aItemString ) || iFindUtilKorean->IsKoreanLanguage( aSearchText ) )

        {

        return iFindUtilKorean->MatchRefineL( aItemString, aSearchText );	

        }

    else

    {

    if ( aItemString.Length() == 0 )

        {

        return EFalse;

        }

    if ( aSearchText.Length() == 0 )

        {

        return ETrue;

        }

    return IsFindMatch( aItemString, aSearchText, iInputLanguage );

    	}

    }

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

// CFindUtilWestern::IsWordValidForMatching

// (other items were commented in a header).

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

//

TBool CFindUtilWestern::IsWordValidForMatching(const TDesC& /*aWord*/)

    {

    return ETrue;

    }

// ========================= FOR ADAPTIVE FIND ================================

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

// For Vietnamese AS

// 

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

//

inline TChar ReplaceVietnameseChar( const TChar aCh )   

    {

    TChar Char = aCh.GetUpperCase();

    if ( (Char >= 0x00C0 && Char <= 0x00C3) || Char == 0x102  ||

         ((Char >= 0x1EA0 && Char <= 0x1EB6) && Char%2 == 0) )  

        {

        Char = 0x0041; // A

        return Char; 

        }        

    if ( (Char >= 0x00C8 && Char <= 0x00CA) || 

        ((Char >= 0x1EB8 && Char <= 0x1EC6) && Char%2 == 0) )

        {

        Char = 0x0045; // E

        return Char; 

        }               

    if ( Char == 0x00CC || Char == 0x00CD || Char == 0x0128 || 

         Char == 0x1EC8 || Char == 0x1ECA  )

        {

        Char = 0x0049; // I

        return Char; 

        }    

    if ( (Char >= 0x00D2 && Char <= 0x00D5 ) || Char == 0x1ECE || Char == 0x1ECC ||

        ((Char >= 0x1ED0 && Char <= 0x1ED8) && Char%2 == 0)) 

        {

        Char = 0x004F; // O

        return Char; 

        }            

    if ( Char == 0x1EDA || Char == 0x1EDC || Char == 0x1EDE || 

         Char == 0x1EE0 || Char == 0x1EE2  )

        {

        Char = 0x01A0; // O-horn

        return Char; 

        }          

    if ( Char == 0x00DA || Char == 0x00D9 || Char == 0x0168 || 

         Char == 0x1EE4 || Char == 0x1EE6  )

        {

        Char = 0x0055; // U

        return Char; 

        }         

     if ( (Char >= 0x1EE8 && Char <= 0x1EF0) && Char%2 == 0 )

        {

        Char = 0x01AF; // U-horn        

        return Char; 

        }         

     if ( ((Char >= 0x1EF2 && Char <= 0x1EF8) && Char%2 == 0) || Char == 0x00DD ) 

        {

        Char = 0x0059; // Y

        return Char; 

        }              

    return Char;

    } 

 /**

 * Checks current character is it special character from Vietnamese language . 

 *

 * @since 5.0

 * @return @c ETrue If it is accent from Vietnamese language, otherwise EFalse. 

 */	

inline TBool IsVietnameseSpecialCharacter( TChar aCh )

    {   

    if ( ( aCh >= 0x0300 && aCh <= 0x0303 ) ||       

        aCh == 0x0306 || aCh == 0x0309 || aCh == 0x0323 || aCh == 0x031B )

        {

        return ETrue;            

        }  

    return EFalse;

    }

/**

 * Update next characters if find pane state was changed.

 *

 * @since 5.0

 * @param aNextChars reference to the next characters for the adaptive search grid

 * @param aCh Criteria from the search field.    

 */

inline void UpdateNextCharsL( HBufC*& aNextChars, TChar aCh )

    {

        TChar ch_temp = aCh;          

    TLanguage lang = User::Language();  

    if ( lang == ELangVietnamese )

	   {

	   aCh = ReplaceVietnameseChar ( ch_temp );

	   }

    if( ( aNextChars->Locate(aCh.GetLowerCase() ) == KErrNotFound ) &&

        ( aNextChars->Locate(aCh.GetUpperCase() ) == KErrNotFound ) )

        {               

        if( aNextChars->Des().Length() == aNextChars->Des().MaxLength() )

            {

            aNextChars = aNextChars->ReAllocL( aNextChars->Des().MaxLength()+10 );

            TInt length1 = aNextChars->Des().Length();

            TInt maxlength1 = aNextChars->Des().MaxLength();

            }       

        aNextChars->Des().Append( aCh );            

        }

    }

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

// For Devanagari AS

// Checks if aCh denotes a consonant with nukta. 

// @return ETrue if aCh is a consonant with nukta EFalse otherwise.

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

//

inline TBool IsIndicCombinedChar( const TChar aCh )

    {   

    if ( aCh < 0x0900 || aCh > 0x0980 )

        {

        return EFalse;

        }

    else

        {

        return ( aCh == 0x0929 || aCh == 0x0931 || aCh == 0x0934 || 

                (aCh >= 0x0958 && aCh <= 0x095F) );

        }

    }

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

// For Devanagari AS

// Returns the correcponding character without nukta

// @param aCh - character to be stripped of nukta

// @return corresponding character with nukta

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

//

inline TChar RemoveIndicNukta( const TChar aCh )

    {

    switch (aCh)

        {

        case 0x0929 : return 0x0928; //vocallic 'nna' to 'na'

        case 0x0931 : return 0x0930; //vocallic 'rra' to 'ra'

        case 0x0934 : return 0x0933; //vocallic 'lllla' to 'lla'

        case 0x0958 : return 0x0915; //vocallic 'qa' to 'ka'

        case 0x0959 : return 0x0916; //vocallic 'khha' to 'kha'

        case 0x095A : return 0x0917; //vocallic 'ghha' to 'ga'

        case 0x095B : return 0x091C; //letter 'za' to 'ja'

        case 0x095C : return 0x0921; //vocallic 'dddha' to 'da'

        case 0x095D : return 0x0922; //vocallic 'rha' to 'ddha'

        case 0x095E : return 0x092B; //letter 'fa' to 'pha'

        case 0x095F : return 0x092F; //letter 'yya' to 'ya'        

        default : return aCh;

        }

    }

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

// For Devanagari AS

// Checks if the given character is a Indic consonant.

// @param aSearchChar - character to be checked.