/*

* Copyright (c) 2002 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: 

*      MPbkFindPrimitives implementation for Japanese Phonebook.

*

*/

// INCLUDE FILES

#include "CPbkJapaneseFindPrimitives.h"

#include <MPbkContactNameFormat.h>

#include <MPbkFieldData.h>

#include <PbkViewContactFieldDataAdapter.h>

#include <PbkEngUtils.h>

//#define PBK_ENABLE_DEBUG_PRINT

#include <PbkDebug.h>

namespace {

const TInt KMinTextBufSize = 32;

// ================= LOCAL FUNCTIONS =======================

/** 

 * Normalizes text by converting all sequences of space characters to a 

 * single space.

 *

 * @param aBuffer   buffer where the normalized text will be stored. The buffer

 *                  will be reallocated if necessary.

 * @param aText     the text to be normalized.

 * @return normalized text.

 */

const TDesC& NormalizeL(HBufC*& aBuffer, const TDesC& aText)

    {

    const TInt textLength = aText.Length();

    aBuffer = PbkEngUtils::AllocL(aBuffer, Max(textLength,KMinTextBufSize));

    TPtr bufPtr(aBuffer->Des());

    bufPtr.Zero();

    TBool uncommittedSpace = EFalse;

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

        {

        TChar ch(aText[i]);

        if (ch.IsSpace())

            {

            uncommittedSpace = ETrue;

            }

        else

            {

            if (uncommittedSpace)

                {

                bufPtr.Append(' ');

                uncommittedSpace = EFalse;

                }

            bufPtr.Append(ch);

            }

        }

    // copy final trailing space

    if (uncommittedSpace)

        {

        bufPtr.Append(' ');

        }

    return (*aBuffer);

    }

}

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

inline CPbkJapaneseFindPrimitives::CPbkJapaneseFindPrimitives(MPbkContactNameFormat& aNameFormatter) :

    iNameFormatter(aNameFormatter)

    {

    }

CPbkJapaneseFindPrimitives* CPbkJapaneseFindPrimitives::NewL(MPbkContactNameFormat& aNameFormatter)

    {

    CPbkJapaneseFindPrimitives* self = new(ELeave) CPbkJapaneseFindPrimitives(aNameFormatter);

    return self;

    }

CPbkJapaneseFindPrimitives::~CPbkJapaneseFindPrimitives()

    {

    delete iFindText;

    delete iFieldText;

    delete iInitialFindText;

    iViewSortOrder.Close();

    }

inline TBool CPbkJapaneseFindPrimitives::IsWordSeparator(TChar aCh)

    {

    return aCh.IsSpace();

    }

void CPbkJapaneseFindPrimitives::SetContactViewSortOrderL

        (const RContactViewSortOrder& aSortOrder)

    {

    iViewSortOrder.CopyL(aSortOrder);

    }

/**

 * Stores the initial find text.

 *

 * @see InitialFindText

 * @see MatchesInitialFindText

 */

inline void CPbkJapaneseFindPrimitives::StoreInitialFindTextL

        (const TDesC& aInitialFindText)

    {

    iInitialFindText = PbkEngUtils::CopyL

        (iInitialFindText, aInitialFindText, aInitialFindText.Length()+1);

    TPtr ptr(iInitialFindText->Des());

    ptr.Append('*');

    }

/**

 * Returns the initial find text passed to StoreInitialFindTextL.

 *

 * @see StoreInitialFindTextL

 * @see MatchesInitialFindText

 */

inline TPtrC CPbkJapaneseFindPrimitives::InitialFindText() const

    {

    TPtrC result;

    if (iInitialFindText)

        {

        // Strip trailing '*' appended for matching in StoreInitialFindTextL

        return iInitialFindText->Left(iInitialFindText->Length()-1);

        }

    return result;

    }

/**

 * Matches (Using TDesC::MatchC) the initial find text against aText. Returns

 * ETrue if aText matches the initial find text.

 *

 * @see StoreInitialFindTextL

 * @see InitialFindText

 */

inline TBool CPbkJapaneseFindPrimitives::DoMatchesInitialFindText

        (const TDesC& aText) const

    {

    if (iInitialFindText)

        {

        return (aText.MatchC(*iInitialFindText) != KErrNotFound);

        }

    return EFalse;

    }

/**

 * Does a prefix matching of aFindText to aContactData.

 *

 * @param aContactData  contact data to match against. Matching is done in

 *                      field order.

 * @param aFindText     normalized (see NormalizeL) find text.

 */

inline TBool CPbkJapaneseFindPrimitives::IsMatchL

        (const MPbkFieldDataArray& aContactData, const TDesC& aFindText)

    {

    TPtrC findText(aFindText);

    const TInt fieldCount = aContactData.PbkFieldCount();

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

        {

        const TDesC& fieldText = 

            NormalizeL(iFieldText, aContactData.PbkFieldAt(i).PbkFieldText());

        TInt matchLen = Min(fieldText.Length(), findText.Length());

        if (fieldText.Left(matchLen).MatchC

                (findText.Left(matchLen)) != KErrNotFound)

            {

            // Require space in find text between fields

            if (matchLen < findText.Length())

                {

                if (TChar(findText[matchLen]).IsSpace() && 

                    i < fieldCount-1)   

                    {

                    // Skip space

                    ++matchLen;

                    }

                else

                    {

                    return EFalse;

                    }

                }

            // Consume findText

            findText.Set(findText.Mid(matchLen));

            }

        }

    // Find text must be fully consumed for a match

    return (findText.Length() == 0);

    }

/**

 * Converts aViewContact to MPbkFieldDataArray and calls 

 * IsMatchL(const MPbkFieldDataArray& aContactData, const TDesC& aFindText).

 */

TBool CPbkJapaneseFindPrimitives::IsMatchL

        (const CViewContact& aViewContact, const TDesC& aFindText)

    {

    TBool ret = EFalse;

    // Convert aViewContact to MPbkFieldDataArray

    const TPbkViewContactFieldDataArray contactData

        (aViewContact, iViewSortOrder);

    // Filter contactData to contain only fields used in find

    const MPbkFieldDataArray& titleData = 

        iNameFormatter.FilterContactTitleFields(contactData);

    // Try to match with title fields first

    ret = IsMatchL(titleData, aFindText);

    // Do matching

    if (!ret)

        {

        // If title field find was not succesfull, try with

        // reading fields only

        const MPbkFieldDataArray& findData = 

        iNameFormatter.FilterContactFieldsForFind(contactData);

        ret = IsMatchL(findData, aFindText);

        }

    return ret;

    }

TBool CPbkJapaneseFindPrimitives::IsFindMatchL

        (const CViewContact& aViewContact, const TDesC& aFindText)

    {

    // Normalize aFindText by removing all extra spaces

    const TDesC& findText = NormalizeL(iFindText,aFindText);

    // Do matching

    return IsMatchL(aViewContact,findText);

    }

void CPbkJapaneseFindPrimitives::GetInitialMatchesL

        (CContactViewBase& aView,

        const TDesC& aFindText,

        RPointerArray<CViewContact>& aMatchedContacts)

    {

    // Make first match with CContactViewBase::ContactsMatchingPrefixL

    MDesCArray* findWords = PbkEngUtils::BreakInWordsLC

        (aFindText, IsWordSeparator);

	aView.ContactsMatchingPrefixL(*findWords, aMatchedContacts);

    CleanupStack::PopAndDestroy();  // findWords

    PBK_DEBUG_PRINT(PBK_DEBUG_STRING("CPbkJapaneseFindPrimitives::GetInitialMatchesL(%S): contact model returned %d matches"), 

        &aFindText, aMatchedContacts.Count());

    StoreInitialFindTextL(aFindText);

    // Filter away contacts that do not fullfill this implementation's criteria

    const TDesC& normFindText = NormalizeL(iFindText,aFindText);

    for (TInt i=aMatchedContacts.Count()-1; i >= 0; --i)

        {

        CViewContact* contact = aMatchedContacts[i];

        if (!IsMatchL(*contact,normFindText))

            {

            aMatchedContacts.Remove(i);

            delete contact;

            }

        }

    }

TBool CPbkJapaneseFindPrimitives::MatchesInitialFindTextL(const TDesC& aText)

    {

    // NOTE: This must work the same way as cntmodel's matching! Otherwise

    // we get problems in hungarian or czech matching with double-characters.

    // The main problem case is in CFindState::SetFindTextL(). If you

    // make this work differently from cntmodel's match, make sure

    // it still works with hungarian "gy" or czech "ch" and "agy" etc...

    return DoMatchesInitialFindText(aText);

    }

TBool CPbkJapaneseFindPrimitives::MatchesInitialFindTextL(const CViewContact& aViewContact)

    {

    TPtrC findText(InitialFindText());

    if (findText.Length() > 0)

        {

        return IsMatchL(aViewContact,findText);

        }

    return EFalse;

    }

// End of File