/*

* Copyright (c) 2006 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:   Message store sort result row set implementation.

*

*/

#include "MsgStoreStringSortResultRowSet.h"

/**

 * Number of rows to keep in memory.  

 * If the cursor moves out of the window, the window slides half of the window size,

 * and the sliding will casue the entire table to be re-evaluated.

 */    

const TInt KMaxWindowSize = 3000;    

//const TInt KSlidingSize   = KMaxWindowSize / 2;

const TInt KMaxCollationLevel = 1;

// ======================

// CLASS: CStringRow

// ======================

// ==========================================================================

// FUNCTION: NewL

// ==========================================================================

CStringRow* CStringRow::NewL( TMsgStoreId aMessageId, TInt64 aDate, const TDesC& aString )

    {

    CStringRow* self = new(ELeave) CStringRow( aMessageId, aDate );

    CleanupStack::PushL( self );

    self->ConstructL( aString );

    CleanupStack::Pop( self );

    return self;

    }

// ==========================================================================

// FUNCTION: Construct

// ==========================================================================

CStringRow::CStringRow( TMsgStoreId aMessageId, TInt64 aDate ) 

: iMessageId( aMessageId ), iDate( aDate )

    {

    }

// ==========================================================================

// FUNCTION: ConstructL

// ==========================================================================

void CStringRow::ConstructL( const TDesC& aString )

    {

    iString = aString.AllocL();

    }

// ==========================================================================

// FUNCTION: ~CStringRow()

// ==========================================================================

CStringRow::~CStringRow()

    {

    delete iString;

    }

// ==========================================================================

// FUNCTION: StringAscDateAsc

// ==========================================================================

TInt CStringRow::StringAscDateAsc(const CStringRow& aFirst, const CStringRow& aSecond )

    {

    TInt rc = aFirst.iString->CompareC( aSecond.iString->Des(), KMaxCollationLevel, NULL );

    if ( rc == 0 )

        {

        //update the group ID

        aFirst.iGroupId = aSecond.iGroupId;

        rc = ( aFirst.iDate > aSecond.iDate ? 1 : ( aFirst.iDate == aSecond.iDate ? 0 : -1 ) );

        }

    return rc;

    }

// ==========================================================================

// FUNCTION: StringAscDateDesc

// ==========================================================================

TInt CStringRow::StringAscDateDesc(const CStringRow& aFirst, const CStringRow& aSecond )

    {

    TInt rc = aFirst.iString->CompareC( aSecond.iString->Des(), KMaxCollationLevel, NULL );

    if ( rc == 0 )

        {

        //update the group ID

        aFirst.iGroupId = aSecond.iGroupId;

        rc = ( aSecond.iDate > aFirst.iDate ? 1 : ( aSecond.iDate == aFirst.iDate ? 0 : -1 ) );

        }

    return rc;

    }

// ==========================================================================

// FUNCTION: StringDescDateAsc

// ==========================================================================

TInt CStringRow::StringDescDateAsc(const CStringRow& aFirst, const CStringRow& aSecond )

    {

    TInt rc = aSecond.iString->CompareC( aFirst.iString->Des(), KMaxCollationLevel, NULL );

    if ( rc == 0 )

        {

        //update the group ID

        aFirst.iGroupId = aSecond.iGroupId;

        rc = ( aFirst.iDate > aSecond.iDate ? 1 : ( aFirst.iDate == aSecond.iDate ? 0 : - 1) );

        }

    return rc;

    }

// ==========================================================================

// FUNCTION: StringDescDateDesc

// ==========================================================================

TInt CStringRow::StringDescDateDesc(const CStringRow& aFirst, const CStringRow& aSecond )

    {

    TInt rc = aSecond.iString->CompareC( aFirst.iString->Des(), KMaxCollationLevel, NULL );

    if ( rc == 0 )

        {

        //update the group ID

        aFirst.iGroupId = aSecond.iGroupId;

        rc = ( aSecond.iDate > aFirst.iDate ? 1 : ( aSecond.iDate == aFirst.iDate ? 0 : -1) ) ;

        }

    return rc;

    }

// ==========================================================================

// FUNCTION: StartWithDesc

// ==========================================================================

TInt CStringRow::StartWithDesc(const CStringRow& aFirst, const CStringRow& aSecond )

    {

    TInt rc = aSecond.iString->FindC( aFirst.iString->Ptr(), aFirst.iString->Length(), KMaxCollationLevel );

    if ( rc != 0 )

        {

        rc = aSecond.iString->CompareC( aFirst.iString->Des(), KMaxCollationLevel, NULL );

        }

    return rc;

    }

// ==========================================================================

// FUNCTION: StartWithAsc

// ==========================================================================

TInt CStringRow::StartWithAsc(const CStringRow& aFirst, const CStringRow& aSecond )

    {

    TInt rc = aSecond.iString->FindC( aFirst.iString->Ptr(), aFirst.iString->Length(), KMaxCollationLevel );

    if ( rc != 0 )

        {

        rc = aFirst.iString->CompareC( aSecond.iString->Des(), KMaxCollationLevel, NULL );

        }

    return rc;

    }

// ==========================================================================

// FUNCTION: IdAsc

// ==========================================================================

TInt CStringRow::MessageIdAsc( const CStringRow& aFirst, const CStringRow& aSecond )

    {

    return aFirst.iMessageId < aSecond.iMessageId ? -1 : ( aFirst.iMessageId == aSecond.iMessageId ) ? 0 : 1;

    }

// ==========================================================================

// FUNCTION: IdAsc

// ==========================================================================

void CStringRow::ResetL( TMsgStoreId aMessageId, TInt64 aDate, const TDesC& aString )

    {

    iMessageId = aMessageId;

    iDate = aDate;

    if ( iString->Size() < aString.Size() )

        {

        iString = iString->ReAllocL( aString.Size() );

        }

    iString->Des().Copy( aString );

    }

// ==================================

// CLASS: CMsgStoreSortResultRowSet

// ==================================

// ==========================================================================

// FUNCTION: NewL

// ==========================================================================

CMsgStoreStringSortResultRowSet* CMsgStoreStringSortResultRowSet::NewL( 

        const TMsgStoreSortCriteria& aSortCriteria, 

        CContainerStoreSortingTable& aSortingTable )

    {

    CMsgStoreStringSortResultRowSet* self = new(ELeave) CMsgStoreStringSortResultRowSet( aSortCriteria, aSortingTable );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ==========================================================================

// FUNCTION: CMsgStoreStringSortResultRowSet

// ==========================================================================

CMsgStoreStringSortResultRowSet::CMsgStoreStringSortResultRowSet( const TMsgStoreSortCriteria& aSortCriteria, CContainerStoreSortingTable& aSortingTable )

: CMsgStoreSortResultRowSet( aSortCriteria, 0, 0, 0, 0, 0, 0, 0 ), 

  iSortCriteria( aSortCriteria ),

  iSortingTable( aSortingTable )

    {

    __LOG_CONSTRUCT( "msg", "CMsgStoreStringSortResultRowSet" )

    __LOG_CLOSE_BETWEEN_WRITES

    }

// ==========================================================================

// FUNCTION: ConstructL

// ==========================================================================

void CMsgStoreStringSortResultRowSet::ConstructL()

    {

    __LOG_ENTER("ConstructL")

    //since calculating the group count is really expensive, we only do it in the first run run

    iIsFirstRun = ETrue;

    InitState();

    iStartWithRow = NULL;

    if ( iSortCriteria.iSortOrder == EMsgStoreSortDescending )

        {

        if ( iSortCriteria.iSecondarySortOrder == EMsgStoreSortDescending )

            {

            iSortMethod = &CStringRow::StringDescDateDesc;

            }

        else

            {

            iSortMethod = &CStringRow::StringDescDateAsc;

            }

        iStartWithMethod = &CStringRow::StartWithDesc;

        }

    else

        {

        if ( iSortCriteria.iSecondarySortOrder == EMsgStoreSortDescending )

            {

            iSortMethod = &CStringRow::StringAscDateDesc;

            }

        else

            {

            iSortMethod = &CStringRow::StringAscDateAsc;

            }

        iStartWithMethod = &CStringRow::StartWithAsc;

        }

    __LOG_EXIT

    }

// ==========================================================================

// FUNCTION: Destructor

// ==========================================================================

CMsgStoreStringSortResultRowSet::~CMsgStoreStringSortResultRowSet()

    {

    iSortedIdArray.ResetAndDestroy();

    iSortedResultArray.Reset();

    iDbView.Close();

    delete iStartWithRow;

    __LOG_DESTRUCT

    }

// ==========================================================================

// FUNCTION: ToTopL

// ==========================================================================

void CMsgStoreStringSortResultRowSet::ToTopL()

    {

    __LOG_ENTER("ToTopL")

    //position the cursor to BEFORE the first element

    iCursorInWindow = -1;

    if ( CanSlideBackward() )

        {

        SlideToTopL();

        }

    __LOG_EXIT

    }

// ==========================================================================

// FUNCTION: ToEndL

// ==========================================================================

void CMsgStoreStringSortResultRowSet::ToEndL()

    {

    __LOG_ENTER("ToTopL")

    //position the cursor to AFTER the last element

    if ( CanSlideForward() )

        {

        SlideToEndL();   //slide to the end

        }

    iCursorInWindow = iSortedResultArray.Count();

    __LOG_EXIT

    }

// ==========================================================================

// FUNCTION: HasMorePreviousL

// ==========================================================================

TBool CMsgStoreStringSortResultRowSet::HasMorePreviousL()

    {

    __LOG_ENTER("HasMorePrevious")

    return ( iCursorInWindow > 0 || CanSlideBackward() );

    }

// ==========================================================================

// FUNCTION: HasMoreNextL

// ==========================================================================

TBool CMsgStoreStringSortResultRowSet::HasMoreNextL()

    {

    __LOG_ENTER("HasMoreNext")

    return ( iCursorInWindow < iSortedResultArray.Count() - 1 || CanSlideForward() ) ;

    }

// ==========================================================================

// FUNCTION: NextL

// ==========================================================================

TMsgStoreId CMsgStoreStringSortResultRowSet::NextL()

    {

    __LOG_ENTER_SUPPRESS("NextL")

    TMsgStoreId id = KContainerInvalidId;

    ++iCursorInWindow;

    if ( iCursorInWindow < iSortedResultArray.Count() && iCursorInWindow >= 0 )

        {

        id = iSortedResultArray[ iCursorInWindow ]->MessageId();

        }

    else

        {

        iCursorInWindow--;

        if ( CanSlideForward() )

            {

            SlideL();  

            id = NextL();

            }

        else

            {

            //leave the iCursorInWindow at the end

            User::Leave( KErrOverflow );

            }

        }

    __LOG_WRITE_FORMAT1_DEBUG3("msgId=%x", id)

    return id;

    }

// ==========================================================================

// FUNCTION: PreviousL

// ==========================================================================

TMsgStoreId CMsgStoreStringSortResultRowSet::PreviousL()

    {

    __LOG_ENTER_SUPPRESS("PreviousL")

    TMsgStoreId id = KContainerInvalidId;

    --iCursorInWindow;

    if ( iCursorInWindow < iSortedResultArray.Count() && iCursorInWindow >= 0 )

        {

        id = iSortedResultArray[ iCursorInWindow ]->MessageId();

        }

    else

        {

        iCursorInWindow++;

        if ( CanSlideBackward() )

            {

            SlideL();

            id = PreviousL();

            }

        else

            {

            //leave the iCursorInWindow at the end

            User::Leave( KErrUnderflow );

            }

        }

    return id;

    }

// ==========================================================================

// FUNCTION: GotoL

// ==========================================================================

void CMsgStoreStringSortResultRowSet::GotoL( TContainerId aMessageId )

    {

    __LOG_ENTER_SUPPRESS("GotoL")

    __LOG_WRITE_FORMAT1_DEBUG3( "msgId=%x", aMessageId )

    CStringRow* tmpRow = CStringRow::NewL( aMessageId, 0, KNullDesC );

    CleanupStack::PushL( tmpRow );

    TInt rc = iSortedIdArray.FindInOrder( tmpRow, &CStringRow::MessageIdAsc );

    if ( rc < 0 )

        {

        SlideToL( aMessageId );

        //find again

        rc = iSortedIdArray.FindInOrder( tmpRow, &CStringRow::MessageIdAsc );

        }

    if ( rc < 0 )

    	{

    	User::Leave( rc );

    	}

    if ( rc < iSortedIdArray.Count() )

        {

    iCursorInWindow = iSortedResultArray.FindInOrder( iSortedIdArray[rc], iSortMethod );

        }

    else

        {

        User::Leave( KErrCorrupt );

        }

    CleanupStack::PopAndDestroy( tmpRow );

    }

// ==========================================================================

// FUNCTION: GotoL

// ==========================================================================

void CMsgStoreStringSortResultRowSet::GotoL( const TDesC& aStartWith, TMsgStoreIteratorDirection aDirection )

    {

    __LOG_ENTER_SUPPRESS("GoToL")

    CStringRow* tmpRow = CStringRow::NewL( 0, 0, aStartWith );

    CleanupStack::PushL( tmpRow );

    TInt rc, index;

    TStartWithFindResult matchResult = EMatchFound;

    rc = iSortedResultArray.SpecificFindInOrder( tmpRow, index, iStartWithMethod, EArrayFindMode_First );

    if ( rc == KErrNotFound )

        {

        if ( index >= iSortedIdArray.Count() )

            {

            //no elements in the array are bigger than the search string

            //check if we can slide down or not

            if ( CanSlideForward() )

                {

                SlideToL( aStartWith );

                rc = iSortedResultArray.SpecificFindInOrder( tmpRow, index, iStartWithMethod, EArrayFindMode_First );

                }

            if ( rc == KErrNotFound && index >= iSortedIdArray.Count() )

                {

                //no elements in the array are bigger than the search string

                //DO NOT LEAVE, set to the end of iterator so that no rows are returnnd

                matchResult = ESearchStringTooBig;

                }

            }

        else if ( index == 0 )

            {

            //no elements in the array are smaller than the search string

            //check if we can slide

            if ( CanSlideBackward() )

                {

                SlideToL( aStartWith );

                rc = iSortedResultArray.SpecificFindInOrder( tmpRow, index, iStartWithMethod, EArrayFindMode_First );

                }

            if ( rc == KErrNotFound && index == 0 )

                {

                //no elements in the array are smaller than the search string

                //DO NOT LEAVE, set to the begining of iterator

                matchResult = ESearchStringTooSmall;

                }

            }

        }

    else if ( rc < 0 )

        {

        User::Leave( rc );

        }

    switch( matchResult )

        {

        case EMatchFound:

            if ( aDirection == EMsgStoreIteratorForward )

                {

                iCursorInWindow = index - 1;   //move back one row so that the current row can be included

                }

            else

                {

                iCursorInWindow = index + 1;   //move forward one row so that the current row can be included

                }

            break;

        case ESearchStringTooBig:

            ToEndL();

            break;

        case ESearchStringTooSmall:

            ToTopL();

            break;

        }

    CleanupStack::PopAndDestroy( tmpRow );

    }

// ==========================================================================

// FUNCTION: SkipCurrentGroupL - for UI "group" support

// ==========================================================================

TBool CMsgStoreStringSortResultRowSet::SkipCurrentGroupL( TMsgStoreIteratorDirection aDirection, TUint& /*aItemsInGroup*/ )

    {

    __LOG_ENTER_SUPPRESS("SkipCurrentGroupL")

    if ( aDirection == EMsgStoreIteratorForward )

        {

        if ( !HasMorePreviousL() )

            {

            //at top of the cursor, return right away because there is NO "current group"

            //so the next (first) in result set will be the "next group"

            return ETrue;

            }

        }

    else

        {

        if ( !HasMoreNextL() )

            {

            //at bottom of the cursor, return right away because there is NO "current group" 

            //so the previous (last) in result set will be the "next group"

            return ETrue;

            }

        }

    CStringRow* curRow = iSortedResultArray[iCursorInWindow];

    __LOG_WRITE_FORMAT2_DEBUG3("Current msg: id=%X gooupId=%d", curRow->MessageId(), curRow->GroupId() )

    TBool found = EFalse;

    while ( !found )

        {

        if ( aDirection == EMsgStoreIteratorForward )

            {

            if ( iCursorInWindow == iSortedResultArray.Count() - 1 && CanSlideForward() )

                {

                SlideL();

                }

            iCursorInWindow++;

            }

        else

            {

            if ( iCursorInWindow == 0 && CanSlideBackward() )

                {

                SlideL();