/*
* 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:    Class that reconstructs a list from notifications
*
*/




//  CLASS HEADER
#include "glxlistreconstruction.h"

//  EXTERNAL INCLUDES
#include <digia/eunit/eunitmacros.h>
#include <digia/eunit/eunitdecorators.h>
#include <mpxcollectionpath.h>
    
//  INTERNAL INCLUDES

// -----------------------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------------------
//
void CGlxListReconstructionBase::ConstructL( TInt aReservationCount )
    {
    iNotifications.ReserveL( aReservationCount );
    iReconstructedList.ReserveL( aReservationCount );
    iFocusIndex = -1;
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CGlxListReconstructionBase::~CGlxListReconstructionBase()
    {
    iNotifications.Close();
    iReconstructedList.Close();
    iSelectedItemIndices.Close();
    }
    
// -----------------------------------------------------------------------------
// Clear notifications array
// -----------------------------------------------------------------------------
//
void CGlxListReconstructionBase::ClearNotifications()
    {
    iNotifications.Reset();
    }

// -----------------------------------------------------------------------------
// Handle items being added
// -----------------------------------------------------------------------------
//
void CGlxListReconstructionBase::HandleItemsAdded( TInt aAddedAtIndex, TInt aCount ) 
    {
    TNotification::TData notification[] = { TNotification::EAdd, aAddedAtIndex, aCount };
    // If fails, not big enough reservation
    EUNIT_ASSERT( KErrNone == iNotifications.Append( *notification )  ); 
    
    // reconstruct the list
    for ( TInt i = 0; i < aCount; i++ )
        {
        // If fails, not big enough reservation
        EUNIT_ASSERT( KErrNone == iReconstructedList.Insert( 
            OriginalItem( aAddedAtIndex ), aAddedAtIndex ) );
        }
    
    // Move focus
    if ( KErrNotFound == iFocusIndex )
        {
        iFocusIndex = 0;
        }
    else if ( iFocusIndex >= aAddedAtIndex )
        {
        iFocusIndex += aCount;
        }
    
    // Move selection        
    for ( TInt i = 0; i < iSelectedItemIndices.Count(); i++ )
        {
        if ( iSelectedItemIndices[ i ] >= aAddedAtIndex )
            {
            iSelectedItemIndices[ i ] += aCount;
            }
        }
    
    // Make sure the original and reconstruction match
    EUNIT_ASSERT( ReconstructionEquals() );
    }
    
// -----------------------------------------------------------------------------
// Handle items being removed
// -----------------------------------------------------------------------------
//
void CGlxListReconstructionBase::HandleItemsRemoved( TInt aRemovedFromIndex, TInt aCount ) 
    {
    TNotification::TData notification[] = { TNotification::ERemove, aRemovedFromIndex, aCount };
    // If fails, not big enough reservation
    EUNIT_ASSERT( KErrNone == iNotifications.Append( *notification ) ); 
    // reconstruct the list
    for ( TInt i = 0; i < aCount; i++ )
        {
        iReconstructedList.Remove( aRemovedFromIndex );
        }

    // Move focus
    if ( iFocusIndex >= aRemovedFromIndex + aCount )
        {
        iFocusIndex -= aCount;
        }
    else if ( iFocusIndex >= aRemovedFromIndex )
        {
        // Focused item was removed
        iFocusIndex = aRemovedFromIndex - 1;
        if ( iFocusIndex < 0 )
            {
            iFocusIndex = 0;
            }
        }
    if ( !iReconstructedList.Count() )
        {
        iFocusIndex = KErrNotFound;
        }
    
    // Move/remove selection        
    TInt i = 0;
    while ( i < iSelectedItemIndices.Count() )
        {
        if ( iSelectedItemIndices[ i ] >= aRemovedFromIndex + aCount )
            {
            iSelectedItemIndices[ i ] -= aCount;
            }
        else if ( iSelectedItemIndices[ i ] >= aRemovedFromIndex )
            {
            iSelectedItemIndices.Remove( i );
            continue;
            }
        i++;
        }

    // Make sure the original and reconstruction match
    EUNIT_ASSERT( ReconstructionEquals() );
    }
    
// -----------------------------------------------------------------------------
// Handle focus changed
// -----------------------------------------------------------------------------
//
void CGlxListReconstructionBase::HandleFocusChanged( NGlxListDefs::TFocusChangeType aType, 
            TInt aNewIndex, TInt aOldIndex )
    {
    TNotification::TData notification[] = { TNotification::EFocus, aOldIndex, static_cast< TInt >( aType ) };
    // If fails, not big enough reservation
    EUNIT_ASSERT( iNotifications.Append( *notification ) == KErrNone ); 

    iFocusIndex = aNewIndex;

    // Make sure the original and reconstruction match
    EUNIT_ASSERT( ReconstructionEquals() );
    }
        
// -----------------------------------------------------------------------------
// Handle items selected
// -----------------------------------------------------------------------------
//
void CGlxListReconstructionBase::HandleItemSelected( TInt aIndex, TBool aSelected )
    {
    TNotification::TData notification[] = { TNotification::ESelection, aIndex, aSelected };
    // If fails, not big enough reservation
    EUNIT_ASSERT( iNotifications.Append( *notification ) == KErrNone ); 

    // Should not get a notification that causes no change
    if ( aSelected )
        {
        EUNIT_ASSERT( KErrNotFound == iSelectedItemIndices.Find( aIndex ) );
        iSelectedItemIndices.Append( aIndex );
        }
    else
        {
        TInt index = iSelectedItemIndices.Find( aIndex );
        EUNIT_ASSERT( KErrNotFound != index );
        iSelectedItemIndices.Remove( index );
        }

    EUNIT_ASSERT( ReconstructionEquals() );
    }
    
// -----------------------------------------------------------------------------
// Test if notifications match
// -----------------------------------------------------------------------------
//
TBool CGlxListReconstructionBase::NotificationListEquals( const TNotification::TData* aNotificationList )
    {
    ASSERT( aNotificationList );
    
    TBool fail = EFalse;
    // Iterator through notifications list
    TBool markerFound = EFalse;
    TInt i = 0;
    while ( ETrue )
        {
        if ( i == iNotifications.Count() )
            {
            if ( KEndMarker == aNotificationList[ i ] )
                {
                markerFound = ETrue;
                }
            break;
            }
        // Notifications must match
        const TNotification& notification = iNotifications[ i ]; 
        fail |= ( notification != aNotificationList[ i ] );
        i++;
        }
    // Must have reached the end of iNotifications
    fail |= ( i != iNotifications.Count() ); 
    // Must have found a marker
    fail |= !markerFound;
    
    return !fail;
    }