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










// INCLUDE FILES
#include "FindUtilJapanese.h"
#include <jplangutil.h>

// CONSTANTS
_LIT(KDesWildCard, "*");

const TInt KLitTab('\t');
const TInt KLitSpace(' ');
const TInt KLitHyphen('-');
const TInt KLitQuestion('?');
const TInt KLitWildCard('*');
const TInt KLitFullWidthSpace(0x3000);
const TInt KLitFullWidthHyphen(0x2015);
const TInt KLitFullWidthQuestion(0xff1f);
const TInt KLitFullWidthWildCard(0xff0a);
const TInt KLitStartHiragana(0x3041);
const TInt KLitEndHiragana(0x3096);
const TInt KLitStartKatakana(0x30A1);
const TInt KLitLineFeed(8233);

const TInt KMaxWordLength = 200;
const TUint KFullWidthSpace = 0x3000;

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

// -----------------------------------------------------------------------------
// CFindUtilJapanese::CFindUtilJapanese
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CFindUtilJapanese::CFindUtilJapanese()
    {
    }

// Destructor
CFindUtilJapanese::~CFindUtilJapanese()
    {
    }

// -----------------------------------------------------------------------------
// CFindUtilJapanese::IsFindWordSeparator
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CFindUtilJapanese::IsFindWordSeparator(TChar aCh)
    {
    return aCh == KLitSpace || aCh == KLitHyphen || aCh == KLitTab ||
        aCh == KLitFullWidthSpace || aCh == KLitFullWidthHyphen ||
        aCh == KLitLineFeed;
    }


// -----------------------------------------------------------------------------
// CFindUtilJapanese::RemoveWordSeparatorsAndWildChars
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CFindUtilJapanese::RemoveWordSeparatorsAndWildChars( TDes16& aSearchPtr )
    {
    TInt len = aSearchPtr.Length();

    for ( TInt ii(0); ii < len; ii++ )
        {
        if ( IsFindWordSeparator(static_cast<TChar>(aSearchPtr[ii])) || 
            aSearchPtr[ii] == KLitWildCard || aSearchPtr[ii] == KLitQuestion ||
            aSearchPtr[ii] == KLitFullWidthWildCard || 
            aSearchPtr[ii] == KLitFullWidthQuestion)
            {
            aSearchPtr.Delete(ii, 1);
            len--;
            continue;
            }
        }

    }

inline TBool IsFindWordSeparator(TChar aCh)
    {
    return (aCh == ' '|| aCh == '-' || aCh == '\t' || aCh==KFullWidthSpace);
    }

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


// -----------------------------------------------------------------------------
// CFindUtilJapanese::MyFindC
// (other items were commented in a header).
// This method is called by MatchRefineL().
// -----------------------------------------------------------------------------
//
TInt CFindUtilJapanese::MyFindC(const TDesC &aItemString, const TDesC &aSearchText)
    {
    TBuf<KMaxWordLength> searchText;
    TBuf<KMaxWordLength> 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() < KMaxWordLength)
        {
        itemString.Append(aItemString);
        }
    else
        {
        itemString.Append(aItemString.Left(KMaxWordLength));
        }
    ReplaceCharacters(itemString, KQuestion, TChar('\t'));
    ReplaceCharacters(itemString, KStar, TChar('\r'));

    CnvKatakana(searchText);
    CnvKatakana(itemString);

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

// -----------------------------------------------------------------------------
// CFindUtilJapanese::IsMatch
// (other items were commented in a header).
// This method is called by MatchRefineL(). 
// This method separates by 4 characters, and this method calls MyFindC().
// -----------------------------------------------------------------------------
//
TBool CFindUtilJapanese::IsMatch( const TDesC& aItemString, const TDesC& aSearchText)
    {
    TPtrC itemptr(aItemString);
    TPtrC searchptr(aSearchText);

    TBool match = EFalse;
    
    FOREVER 
        {
        // 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
        const TInt maxFindChar = 4;
        TChar findchar = KFullWidthSpace;
        TInt findindex;
        for (findindex=0; findindex < maxFindChar; findindex++)
            {
            switch(findindex)
                {
                case 0: findchar = (' ');  break;   // space
                case 1: findchar = KFullWidthSpace; break;   // full space
                case 2: findchar = ('-');  break;   // minus
                case 3: findchar = ('\t'); break;   // tab
                }
            const TInt findpos = itemptr.LocateF(findchar);
            if (findpos != KErrNotFound)
                {
                itemptr.Set(itemptr.Mid(findpos+1));
                break;
                }
            }
        if (findindex >= maxFindChar)
            {
            match = EFalse;
            break;
            }
        if (itemptr.Length() == 0)
            {
            match = EFalse;
            break;
            }
        }
    return match;
    }

// -----------------------------------------------------------------------------
// CFindUtilJapanese::CnvKatakana
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CFindUtilJapanese::CnvKatakana(TDes& aDes)
    {
    TInt len = aDes.Length();
    for (TInt i(0); i < len; i++)
        {
        TUint16& ch = aDes[i];
        if (ch >= KLitStartHiragana && ch <= KLitEndHiragana)
            {
            ch += (KLitStartKatakana - KLitStartHiragana);
            }
        }
    }

// -----------------------------------------------------------------------------
// CFindUtilJapanese::Match
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//

TBool CFindUtilJapanese::Match(const TDesC& aContactsField, const TDesC& aWord)
    {
    if (!aContactsField.Length())
        {
        return EFalse;
        }

    TBuf<KMaxWordLength> searchText(aWord);
    TBuf<KMaxWordLength> itemString(aContactsField);

    searchText.Append(KDesWildCard);
    CnvKatakana(searchText);
    CnvKatakana(itemString);

    if (itemString.MatchC(searchText) != KErrNotFound)
        {
        return ETrue;
        }

    return EFalse;
    }

// -----------------------------------------------------------------------------
// CFindUtilJapanese::MatchRefineL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CFindUtilJapanese::MatchRefineL( const TDesC& aItemString, const TDesC &aSearchText)
    {
    if ( aItemString.Length() == 0 )
        {
        return EFalse;
        }

    if ( aSearchText.Length() == 0 )
        {
        return ETrue;
        }

    return IsMatch(aItemString, aSearchText);
    }

// -----------------------------------------------------------------------------
// CFindUtilJapanese::IsWordValidForMatching
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CFindUtilJapanese::IsWordValidForMatching(const TDesC& /*aWord*/)
    {
    return ETrue;
    }


// -----------------------------------------------------------------------------
// CFindUtilJapanese::MatchAdaptiveRefineL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//  
TBool CFindUtilJapanese::MatchAdaptiveRefineL( const TDesC& /*aItemString*/, 
	                                           const TDesC& /*aSearchText*/,
	                                           HBufC*& /*aNextChars*/ )
	{	
  	return EFalse;	
	}
	
// ---------------------------------------------------------
// Match arithmetic for accurate search, special conversion 
// for aItemString is implemented with MFindStringConverter
// before the final match
// ---------------------------------------------------------
//
TBool CFindUtilJapanese::MatchRefineL( const TDesC& /*aItemString*/, const TDesC& /*aSearchText*/, 
                                       TMatchPolicy /*aPolicy*/, MFindStringConverter* /*aConverter*/)
    {
    return EFalse;
    }	

// ========================== OTHER EXPORTED FUNCTIONS =========================

// -----------------------------------------------------------------------------
// FindUtilFactoryFunctionL
// Factory function at first ordinal
// Returns: MFindUtil: It returns MFindUtil I/F.
// -----------------------------------------------------------------------------
//
EXPORT_C MFindUtil* FindUtilFactoryFunctionL()
    {
    return new( ELeave ) CFindUtilJapanese();
    }

//  End of File