/*

* 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: Supports initial search feature. 

*

*/

// INCLUDES

#include "CPcsAlgorithm2Utils.h"

#include "CPsData.h"

#include "CPsQuery.h"

#include "CPcsDefs.h"

#include "CPcsCache.h"

#include <collate.h>

// CONSTANTS

_LIT(KSpace, ' ');

// Search contacts in a group URI template

_LIT(KGroupIdUri, "cntdb://c:contacts.gdb?id=");

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

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

// CPcsAlgorithm2Utils::FormCompleteSearchResultsL()

// Merges all the respective data store result sets to single set in sorted order.

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

void CPcsAlgorithm2Utils::FormCompleteSearchResultsL(RPointerArray<CPSDATA_R_PTR_ARRAY>& aSearchResultsArr,

                                                     RPointerArray<CPsData>& aSearchResults)

    {

    TInt maxIndex = 0;

    TInt maxValue = aSearchResultsArr[maxIndex]->Count();

    TLinearOrder<CPsData> rule(CPcsAlgorithm2Utils::CompareDataBySortOrder);

    // Find the largest array in aSearchResultsArr

    const TInt searchResultsArrCount = aSearchResultsArr.Count(); 

    for (TInt i = 1; i < searchResultsArrCount; i++)

        {

        if (aSearchResultsArr[i]->Count() > maxValue)

            {

            maxIndex = i;

            maxValue = aSearchResultsArr[i]->Count();

            }

        }

    // Assign the largets array to searchresults 

    const TInt cnt = aSearchResultsArr[maxIndex]->Count();

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

        {

        aSearchResults.Append((*(aSearchResultsArr[maxIndex]))[i]);

        }

    // Merge the remaining result arrays to the largest array in sequential order

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

        {

        // Check if we are not copying again the largest array

        if ((i != maxIndex) && ((aSearchResultsArr[i])->Count() != 0))

            {

            TInt numElements = (aSearchResultsArr[i])->Count();

            for (TInt j = 0; j < numElements; j++)

                {

                aSearchResults.InsertInOrderAllowRepeatsL((*(aSearchResultsArr[i]))[j], rule);

                }

            }

        }

    }

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

// CPcsAlgorithm2Utils::MyCompareC()

// Lang specific MyCompareC

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

TInt CPcsAlgorithm2Utils::MyCompareC(const TDesC& aLeft, const TDesC& aRight)

    {

    // Get the current language

    TLanguage lang = User::Language();

    // Get the standard method

    TCollationMethod meth = *Mem::CollationMethodByIndex(0);

    meth.iFlags |= TCollationMethod::EIgnoreNone;

    meth.iFlags |= TCollationMethod::EFoldCase;

    if (lang == ELangHindi || lang == ELangMarathi)

        {

        meth.iFlags |= TCollationMethod::EIgnoreCombining;

        }

    // Collation level 3 is used

    TInt comparison(aLeft.CompareC(aRight, 3, &meth));

    return comparison;

    }

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

// CPcsAlgorithm2Utils::CompareDataBySortOrder()

// TLinearOrder rule for comparison of data objects

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

TInt CPcsAlgorithm2Utils::CompareDataBySortOrder(const CPsData& aObject1,

                                                 const CPsData& aObject2)

    {

    _LIT(KSpace, " ");

    // Fetch the cache list stored in TLS to recover the sort order

    typedef RPointerArray<CPcsCache> PTR;

    PTR* pcsCache = static_cast<PTR*> (Dll::Tls());

    // Data1

    TBuf<255> data1(KNullDesC);

    TInt uriId1 = aObject1.UriId();

    CPcsCache* cache = (*pcsCache)[uriId1];

    RArray<TInt> indexOrder;

    // Get the index order based on sort order from the cache

    cache->GetIndexOrder(indexOrder);

    // Append sort order elements first

    const TInt indexOrderCount1 = indexOrder.Count();

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

        {

        TInt index = indexOrder[i];

        if (index < aObject1.DataElementCount() && aObject1.Data(index))

            {

            // Trim the unnecessary white spaces/special chars before we compare

            TBuf<255> str(KNullDesC);

            str = aObject1.Data(index)->Des();

            CPcsAlgorithm2Utils::MyTrim(str);

            data1 += str;

            data1 += KSpace;

            }

        }

    /* --- NOT SURE IF THIS BEHAVIOR IS REQUIRED ---

     // Append remaining elements in order

     for ( int i = 0; i < aObject1.DataElementCount(); i++ )

     {

     if ( indexOrder.Find(i) == KErrNone && aObject1.Data(i) )

     {

     data1 += aObject1.Data(i)->Des();

     data1 += KSpace;

     }	     

     }

     */

    // Data2

    TBuf<255> data2(KNullDesC);

    TInt uriId2 = aObject2.UriId();

    cache = (*pcsCache)[uriId2];

    indexOrder.Reset();

    // Get the index order based on sort order from the cache

    cache->GetIndexOrder(indexOrder);

    const TInt indexOrderCount2 = indexOrder.Count();

    // Append sort order elements first

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

        {

        TInt index = indexOrder[i];

        if (index < aObject2.DataElementCount() && aObject2.Data(index))

            {

            // Trim the unnecessary white spaces/special chars before we compare

            TBuf<255> str(KNullDesC);

            str = aObject2.Data(index)->Des();

            CPcsAlgorithm2Utils::MyTrim(str);

            data2 += str;

            data2 += KSpace;

            }

        }

    /* --- NOT SURE IF THIS BEHAVIOR IS REQUIRED ---

     // Append remaining elements in order

     for ( int i = 0; i < aObject2.DataElementCount(); i++ )

     {

     if ( indexOrder.Find(i) == KErrNone && aObject2.Data(i) )

     {

     data2 += aObject2.Data(i)->Des();

     data2 += KSpace;

     }	     

     }

     */

    indexOrder.Reset();

    data1.TrimAll();

    data2.TrimAll();

    return (CPcsAlgorithm2Utils::MyCompareC(data1, data2));

    }

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

// CPcsAlgorithm2Utils::CompareExact()

// 

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

TBool CPcsAlgorithm2Utils::CompareExact(const TDesC& aFirst, const TDesC& aSecond)

    {

    return aFirst == aSecond;

    }

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

// CPcsAlgorithm2Utils::CompareLength()

// 

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

TInt CPcsAlgorithm2Utils::CompareLength(const CPsQuery& aFirst, const CPsQuery& aSecond)

    {

    CPsQuery& first = const_cast<CPsQuery&> (aFirst);

    CPsQuery& second = const_cast<CPsQuery&> (aSecond);

    return (first.Count() - second.Count());

    }

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

// CPcsAlgorithm2Utils::MyTrim()

// Trim off all white spaces and special characters

// This behavior is required to mimic the current phonebook sort sequence

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

void CPcsAlgorithm2Utils::MyTrim(TDes& aString)

    {

    for (TInt i = aString.Length(); --i >= 0;)

        {

        TChar c = (TChar) aString[i];

        if (!c.IsAlphaDigit())

            {

            aString.Replace(i, 1, KSpace);

            }

        }

    aString.TrimAll();

    }

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

// CPcsAlgorithm2Utils::IsGroupUri()

// Check if the input URI is of contact search in a group template form

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

TBool CPcsAlgorithm2Utils::IsGroupUri(TDesC& aURI)

    {

    TBuf<255> uri(aURI);

    uri.LowerCase();

    TInt index = uri.FindF(KGroupIdUri);

    if (index == KErrNotFound)

        {

        return EFalse;

        }

    return ETrue;

    }

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

// CPcsAlgorithm1Helper::FilterDataFieldsL()

// Constructs a bit pattern using the required/supported data fields

// For example, 6, 4 and 27 are supported fields <-- 00000111

//              6 and 4 are required fields      <-- 00000011

// Bit pattern returned is 00000011.

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

TUint8 CPcsAlgorithm2Utils::FilterDataFieldsL(const RArray<TInt>& aRequiredDataFields,

                                              const RArray<TInt>& aSupportedDataFields)

{

    TUint8 filteredMatch = 0x0;

   const TInt supportedDataFieldsCount = aSupportedDataFields.Count();

   const TInt requiredDataFieldsCount = aRequiredDataFields.Count(); 

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

    {

        for ( TInt j = 0; j < requiredDataFieldsCount; j++ )

        {

            if ( aSupportedDataFields[i] == aRequiredDataFields[j] )

            {

                TUint8 val = 1 << i;

                filteredMatch |= val;

            }

        }

    }

    return filteredMatch;

}

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

// CPcsAlgorithm2Utils::AppendMatchToSeqL

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

void CPcsAlgorithm2Utils::AppendMatchToSeqL( 

        RPointerArray<TDesC>& aMatchSeq, const TDesC& aMatch )

    {

    HBufC* seq = aMatch.AllocLC();

    seq->Des().UpperCase();

    TIdentityRelation<TDesC> rule(CompareExact);

    if ( aMatchSeq.Find(seq, rule) == KErrNotFound )

        {

        aMatchSeq.AppendL(seq);

        CleanupStack::Pop( seq );

        }

    else 

        {

        CleanupStack::PopAndDestroy( seq );

        }

    }

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

// CPcsAlgorithm2Utils::MatchesOverlap

// Check if two match location items have overlapping indices.

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

TBool CPcsAlgorithm2Utils::MatchesOverlap( const TPsMatchLocation& aFirst, 

                                           const TPsMatchLocation& aSecond )

    {

    TBool overlap = EFalse;

    if ( aFirst.index == aSecond.index )

        {

        overlap = ETrue;

        }

    else

        {

        // give arguments alias names where first begins before the second

        TInt firstPos( aFirst.index );

        TInt firstLen( aFirst.length );

        TInt secondPos( aSecond.index );

        if ( firstPos > secondPos )

            {

            firstPos = aSecond.index;

            firstLen = aSecond.length;

            secondPos = aFirst.index;

            }

        // there is an overlap if the end of the first comes after

        // beginning of the second

        if ( firstPos + firstLen > secondPos )

            {

            overlap = ETrue;

            }

        }

    return overlap;

    }

// End of File