/*

* 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 in memory sort row set implementation.

*

*/

#include "MsgStoreInMemorySortRowSet.h"

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

// CLASS: CIntegerRow

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

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

// FUNCTION: Construct

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

CIntegerRow::CIntegerRow( TMsgStoreId aMessageId, TInt64 aDate, TInt32 aValue ) 

: iMessageId( aMessageId ), iDate( aDate ), iValue( aValue )

    {

    }

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

// FUNCTION: ~CIntegerRow()

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

CIntegerRow::~CIntegerRow()

    {

    }

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

// FUNCTION: DateAsc

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

TInt CIntegerRow::DateAsc(const CIntegerRow& aFirst, const CIntegerRow& aSecond )

	{

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

    return rc;

    }

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

// FUNCTION: DateDesc

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

TInt CIntegerRow::DateDesc(const CIntegerRow& aFirst, const CIntegerRow& aSecond )

    {

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

    return rc;

    }

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

// FUNCTION: ValueAscDateAsc

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

TInt CIntegerRow::ValueAscDateAsc(const CIntegerRow& aFirst, const CIntegerRow& aSecond )

    {

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

    if ( rc == 0 )

        {

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

        }

    return rc;

    }

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

// FUNCTION: ValueAscDateDesc

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

TInt CIntegerRow::ValueAscDateDesc(const CIntegerRow& aFirst, const CIntegerRow& aSecond )

    {

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

    if ( rc == 0 )

        {

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

        }

    return rc;

    }

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

// FUNCTION: ValueDescDateAsc

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

TInt CIntegerRow::ValueDescDateAsc(const CIntegerRow& aFirst, const CIntegerRow& aSecond )

    {

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

    if ( rc == 0 )

        {

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

        }

    return rc;

    }

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

// FUNCTION: ValueDescDateDesc

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

TInt CIntegerRow::ValueDescDateDesc(const CIntegerRow& aFirst, const CIntegerRow& aSecond )

    {

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

    if ( rc == 0 )

        {

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

        }

    return rc;

    }

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

// FUNCTION: IdAsc

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

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

    {

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

    }

CIntegerSortGroup::CIntegerSortGroup( TInt64 aValue )

  : iValue(aValue), iCount(1)

    {

    }

CIntegerSortGroup::~CIntegerSortGroup()

    {

    }

TInt CIntegerSortGroup::ValueAscAndUpdateCount( const CIntegerSortGroup& aFirst, const CIntegerSortGroup& aSecond )

    {

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

    if ( rc == 0 )

        {

        ++aSecond.iCount;

        }

    return rc;

    }

TInt CIntegerSortGroup::ValueDescAndUpdateCount( const CIntegerSortGroup& aFirst, const CIntegerSortGroup& aSecond )

    {

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

    if ( rc == 0 )

        {

        ++aSecond.iCount;

        }

    return rc;

    }

TInt CIntegerSortGroup::ValueAsc( const CIntegerSortGroup& aFirst, const CIntegerSortGroup& aSecond )

    {

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

    return rc;

    }

TInt CIntegerSortGroup::ValueDesc( const CIntegerSortGroup& aFirst, const CIntegerSortGroup& aSecond )

    {

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

    return rc;

    }

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

// CLASS: CMsgStoreSortResultRowSet

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

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

// FUNCTION: NewL

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

CMsgStoreInMemorySortRowSet* CMsgStoreInMemorySortRowSet::NewL( const TMsgStoreSortCriteria& aSortCriteria, CContainerStoreSortingTable& aSortingTable )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// FUNCTION: CMsgStoreInMemorySortRowSet

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

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

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

  iSortCriteria( aSortCriteria ),

  iSortingTable( aSortingTable )

    {

    __LOG_CONSTRUCT( "msg", "CMsgStoreInMemorySortRowSet" )

    __LOG_CLOSE_BETWEEN_WRITES

    }

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

// FUNCTION: ConstructL

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

void CMsgStoreInMemorySortRowSet::ConstructL()

    {

    __LOG_ENTER("ConstructL")

    InitState();

    if ( iSortCriteria.iSortBy == EMsgStoreSortByReceivedDate )

    	{

	    if ( iSortCriteria.iSortOrder == EMsgStoreSortDescending )

	    	{

            iSortMethod = &CIntegerRow::DateDesc;

	    	}

	    else

	    	{

            iSortMethod = &CIntegerRow::DateAsc;

	    	}   

	    //initial the UTC offset

	    TLocale locale;

	    iUtcOffsetInSeconds = locale.UniversalTimeOffset();   

    	}

    else

    	{

	    if ( iSortCriteria.iSortOrder == EMsgStoreSortDescending )

	        {

	        if ( iSortCriteria.iSecondarySortOrder == EMsgStoreSortDescending )

	            {

	            iSortMethod = &CIntegerRow::ValueDescDateDesc;

	            }

	        else

	            {

	            iSortMethod = &CIntegerRow::ValueDescDateAsc;

	            }

	        }

	    else

	        {

	        if ( iSortCriteria.iSecondarySortOrder == EMsgStoreSortDescending )

	            {

	            iSortMethod = &CIntegerRow::ValueAscDateDesc;

	            }

	        else

	            {

	            iSortMethod = &CIntegerRow::ValueAscDateAsc;

	            }

	        }

    	}

    __LOG_EXIT

    }

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

// FUNCTION: Destructor

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

CMsgStoreInMemorySortRowSet::~CMsgStoreInMemorySortRowSet()

    {

    iSortedIdArray.ResetAndDestroy();

    iSortedResultArray.Reset();

    iDbView.Close();

    iGroupNameArray.ResetAndDestroy();

    __LOG_DESTRUCT

    }

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

// FUNCTION: ToTopL

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

void CMsgStoreInMemorySortRowSet::ToTopL()

    {

    __LOG_ENTER("ToTopL")

    //position the cursor to BEFORE the first element

    iCursorInWindow = -1;

    __LOG_EXIT

    }

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

// FUNCTION: ToEndL

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

void CMsgStoreInMemorySortRowSet::ToEndL()

    {

    __LOG_ENTER("ToEndL")

    //position the cursor to AFTER the last element

    iCursorInWindow = iSortedResultArray.Count();

    __LOG_EXIT

    }

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

// FUNCTION: HasMorePreviousL

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

TBool CMsgStoreInMemorySortRowSet::HasMorePreviousL()

    {

    return iCursorInWindow > 0;

    }

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

// FUNCTION: HasMoreNextL

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

TBool CMsgStoreInMemorySortRowSet::HasMoreNextL()

    {

    return iCursorInWindow < iSortedResultArray.Count() - 1;

    }

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

// FUNCTION: NextL

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

TMsgStoreId CMsgStoreInMemorySortRowSet::NextL()

    {

    TMsgStoreId id = KContainerInvalidId;

    ++iCursorInWindow;

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

        {

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

        }

    else

        {

        //leave the iCursorInWindow at the end

        User::Leave( KErrOverflow );

        }

    return id;

    }

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

// FUNCTION: PreviousL

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

TMsgStoreId CMsgStoreInMemorySortRowSet::PreviousL()

    {

    TMsgStoreId id = KContainerInvalidId;

    --iCursorInWindow;

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

        {

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

        }

    else

        {

        //leave the iCursorInWindow at the end

        User::Leave( KErrUnderflow );

        }

    return id;

    }

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

// FUNCTION: GotoL

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

void CMsgStoreInMemorySortRowSet::GotoL( TContainerId aMessageId )

    {

    __LOG_ENTER_SUPPRESS("GotoL")

    __LOG_WRITE_FORMAT1_DEBUG3( "msgId=%x", aMessageId )

    CIntegerRow* tmpRow = new(ELeave) CIntegerRow( aMessageId, 0, 0 );

    CleanupStack::PushL( tmpRow );

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

    if ( rc < 0 )

        {

        User::Leave( KErrNotFound );

        }

    if ( rc < iSortedIdArray.Count() )

        {

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

        }

    else

        {

        User::Leave( KErrCorrupt );

        }

    CleanupStack::PopAndDestroy( tmpRow );

    }

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

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

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

TBool CMsgStoreInMemorySortRowSet::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;

            }

        }

    CIntegerRow* curRow = iSortedResultArray[iCursorInWindow];

    __LOG_WRITE_FORMAT2_DEBUG3("Current msg: id=%X val=%ld", curRow->MessageId(), &curRow->StringVal() )

    TBool found = EFalse;

    TInt64 dateRangeStart = 0;

    TInt64 dateRangeEnd = 0;

    if ( iSortCriteria.iSortBy == EMsgStoreSortByReceivedDate )

    	{

    	GetDateRangeL( *curRow, aDirection, dateRangeStart, dateRangeEnd );

    	}

    while ( !found )

        {

        if ( aDirection == EMsgStoreIteratorForward )

            {

            iCursorInWindow++;

            }

        else

            {

            iCursorInWindow--;

            }

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

            {

            CIntegerRow* nextRow = iSortedResultArray[iCursorInWindow];

            if ( iSortCriteria.iSortBy == EMsgStoreSortByReceivedDate )

            	{

            	TInt64 time = nextRow->ReceivedTime();

            	if ( time >= dateRangeEnd || time < dateRangeStart )

            		{

	                found = ETrue;

	                __LOG_WRITE_FORMAT2_DEBUG3("Next Group Found: id=%X time=%ld", nextRow->MessageId(), nextRow->ReceivedTime() )

            		}

            	}

            else

            	{

	            if ( nextRow->Value() != curRow->Value() )

	                {

	                found = ETrue;

	                __LOG_WRITE_FORMAT2_DEBUG3("Next Group Found: id=%X val=%d", nextRow->MessageId(), nextRow->Value() )

	                }

            	}

            }

        else

        	{

        	break;  //Not found

        	}

        }

    if ( found )

        {

        if ( aDirection == EMsgStoreIteratorForward )

            {

            iCursorInWindow--;

            }

        else

            {

            iCursorInWindow++;

            }

        }

    return found;

    }

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

// FUNCTION: GroupCountL

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

TInt CMsgStoreInMemorySortRowSet::GroupCountL( RArray<TUint>& aItemsInGroup )

    {

    for ( TInt i = 0 ; i < iGroupNameArray.Count() ; i++ )

        {

        aItemsInGroup.Append( iGroupNameArray[i]->Count() );

        }

    return iGroupNameArray.Count();

    }

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

// FUNCTION: SortedIdsL

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

void CMsgStoreInMemorySortRowSet::SortedIdsL( RArray<TContainerId>& aIdArray )

	{

	aIdArray.Reset();

	TContainerId msgId = 0;

	ToTopL();

	TInt err = KErrNone;

	TBool hasMore = ETrue;

	while ( hasMore )

		{

        TRAP( err, msgId = NextL() );

		if ( err == KErrNone )

			{

			aIdArray.Append( msgId );

			}

		else if ( err == KErrOverflow )

			{

			hasMore = EFalse;

			}

		else

			{

			User::Leave( err );

			}

		}

	}

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

// FUNCTION: IndexOfL

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

TInt CMsgStoreInMemorySortRowSet::IndexOfL( TContainerId aMessageId )

    {

    GotoL( aMessageId );

    return iCursorInWindow;

    }

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

// FUNCTION: UpdateGroupList

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

void CMsgStoreInMemorySortRowSet::UpdateGroupListL( TInt64 aValue )

    {

    CIntegerSortGroup *gn = NULL;

    if ( iSortCriteria.iSortBy == EMsgStoreSortByReceivedDate )

    	{

    	TTime startOfDay;

    	GetStartOfLocalDayL( aValue, startOfDay );

    	gn = new(ELeave) CIntegerSortGroup( startOfDay.Int64() );

    	}

    else

    	{

    	gn = new(ELeave) CIntegerSortGroup( aValue );

    	}

    CleanupStack::PushL( gn );

    TInt rc = KErrNone;

    if ( iSortCriteria.iSortOrder == EMsgStoreSortDescending )

        {

        rc = iGroupNameArray.InsertInOrder( gn, CIntegerSortGroup::ValueDescAndUpdateCount );

        }

    else

        {

        rc = iGroupNameArray.InsertInOrder( gn, CIntegerSortGroup::ValueAscAndUpdateCount );

        }