/*

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

*

*/

using System;

using System.Collections.Generic;

namespace SymbianUtils.Collections

{

    public class SymbianSortedListByValue<TKey, TValue> where TValue : class

    {

        #region Constructors

        public SymbianSortedListByValue( IComparer<TValue> aComparer )

            : this( 10, aComparer )

        {

        }

        public SymbianSortedListByValue( int aGranularity, IComparer<TValue> aComparer )

        {

            iList = new List<KeyValuePair<TValue, TKey>>( aGranularity );

            iComparer = new SymbianSortedListByValueComparer( aComparer );

        }

        public SymbianSortedListByValue( SymbianSortedListByValue<TKey, TValue> aCollection )

        {

            int count = aCollection.Count;

            //

            iList = new List<KeyValuePair<TValue, TKey>>( count + 1 );

            iComparer = new SymbianSortedListByValue<TKey, TValue>.SymbianSortedListByValueComparer( aCollection.iComparer.Comparer );

            //

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

            {

                KeyValuePair<TValue, TKey> entry = aCollection.iList[ i ];

                Add( entry.Value, entry.Key );

            }

        }

        #endregion

        #region API

        public bool Contains( TKey aKey )

        {

            return iDictionary.ContainsKey( aKey );

        }

        public void Add( TKey aKey, TValue aValue )

        {

            if ( aKey == null )

            {

                throw new ArgumentNullException( "aKey cannot be null" );

            }

            // Add item to dictionary if required

            if ( !iDictionary.ContainsKey( aKey ) )

            {

                iDictionary.Add( aKey, aValue );

            }

            // Search for item in the list. If it's already present then

            // this will return the index. Otherwise, it will return a negative

            // number.

            // If this index is greater than or equal to the size of the array, 

            // there are no elements larger than value in the array. 

            //

            // Otherwise, it is the index of the first element that is larger than value.

            KeyValuePair<TValue, TKey> entry = new KeyValuePair<TValue, TKey>( aValue, aKey );

            int index = iList.BinarySearch( entry, iComparer );

            if ( index < 0 )

            {

                index = ~index;

            }

            iList.Insert( index, entry );

        }

        public void Remove( Predicate<TValue> aValue )

        {

            Predicate<KeyValuePair<TValue, TKey>> matchPredicate = delegate( KeyValuePair<TValue, TKey> aItem )

            {

                bool remove = aValue.Invoke( aItem.Key );

                return remove;

            };

            RemoveAll( matchPredicate );

        }

        public void Remove( TValue aValue )

        {

            Predicate<KeyValuePair<TValue, TKey>> matchPredicate = delegate( KeyValuePair<TValue, TKey> aItem )

            {

                return ( aValue == aItem.Key );

            };

            RemoveAll( matchPredicate );

        }

        public void Remove( TKey aKey )

        {

            TValue v = null;

            if ( iDictionary.TryGetValue( aKey, out v ) )

            {

                iDictionary.Remove( aKey );

                Remove( v );

            }

        }

        public void Clear()

        {

            iList.Clear();

            iDictionary.Clear();

        }

        public void RemoveRange( int aStartIndex, int aCount )

        {

            List<KeyValuePair<TValue, TKey>> items = iList.GetRange( aStartIndex, aCount );

            RemoveAll( items );

        }

        public void Sort( IComparer<TValue> aComparer )

        {

            SymbianSortedListByValueComparer comparer = new SymbianSortedListByValueComparer( aComparer );

            iList.Sort( comparer );

            iComparer = comparer;

        }

        #endregion

        #region Properties

        public int Count

        {

            get { return iList.Count; }

        }

        public TValue this[ int aIndex ]

        {

            get

            { 

                KeyValuePair< TValue, TKey> ret = iList[ aIndex ];

                return ret.Key;

            }

        }

        public TValue this[ TKey aKey ]

        {

            get

            {

                TValue ret = null;

                bool found = iDictionary.TryGetValue( aKey, out ret );

                return ret;

            }

        }

        #endregion

        #region Internal methods

        private void RemoveAll( Predicate<KeyValuePair<TValue, TKey>> aPredicate )

        {

            List<KeyValuePair<TValue, TKey>> items = iList.FindAll( aPredicate );

            RemoveAll( items );

        }

        private void RemoveAll( List<KeyValuePair<TValue, TKey>> aItems )

        {

            foreach ( KeyValuePair<TValue, TKey> item in aItems )

            {

                // Remove from dictionary

                TKey key = item.Value;

                if ( iDictionary.ContainsKey( key ) )

                {

                    iDictionary.Remove( key );

                }

                // Remove from list

                TValue value = item.Key;

                iList.Remove( item );

            }

        }

        #endregion

        #region Internal classes

        private class SymbianSortedListByValueComparer : IComparer< KeyValuePair<TValue, TKey> >

        {

            #region Constructors

            public SymbianSortedListByValueComparer( IComparer<TValue> aComparer )

            {

                iComparer = aComparer;

            }

            #endregion

            #region Properties

            public IComparer<TValue> Comparer

            {

                get { return iComparer; }

            }

            #endregion

            #region From IComparer<KeyValuePair<TValue,TKey>>

            public int Compare( KeyValuePair<TValue, TKey> aLeft, KeyValuePair<TValue, TKey> aRight )

            {

                int ret = iComparer.Compare( aLeft.Key, aRight.Key );

                return ret;

            }

            #endregion

            #region Data members

            private readonly IComparer<TValue> iComparer;

            #endregion

        }

        #endregion

        #region Data members

        private List< KeyValuePair<TValue, TKey> > iList = null;

        private Dictionary<TKey, TValue> iDictionary = new Dictionary<TKey, TValue>();

        private SymbianSortedListByValueComparer iComparer = null;

        #endregion

    }

}