using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;

namespace Developpez.Dotnet.Collections
{
    /// <summary>
    /// Représente une liste supportant les scénarios de liaison de données
    /// ainsi que le tri
    /// </summary>
    /// <typeparam name="T">Type des éléments de la liste</typeparam>
    public class SortableBindingList<T> : BindingList<T>
    {
        #region Static sort implementation

        private static readonly Dictionary<PropertyDescriptor, Comparison<T>> _comparisons;

        static SortableBindingList()
        {
            _comparisons = new Dictionary<PropertyDescriptor, Comparison<T>>();
        }

        private static Comparison<T> GetComparison(PropertyDescriptor prop, ListSortDirection direction)
        {
            Comparison<T> comparison;
            lock (_comparisons)
            {
                if (!_comparisons.TryGetValue(prop, out comparison))
                {
                    comparison = CreateComparison(prop);
                    _comparisons[prop] = comparison;
                }
            }
            if (direction == ListSortDirection.Descending)
                comparison = comparison.Reverse();
            return comparison;
        }

        private static Comparison<T> CreateComparison(PropertyDescriptor prop)
        {
            var a = Expression.Parameter(typeof (T), "a");
            var b = Expression.Parameter(typeof(T), "b");

            var comparerType = typeof (Comparer<>).MakeGenericType(prop.PropertyType);
            var comparerProperty = comparerType.GetProperty("Default");
            var compareMethod = comparerType.GetMethod("Compare");

            var comparer = Expression.Property(null, comparerProperty);

            var body =
                Expression.Call(
                    comparer,
                    compareMethod,
                    Expression.Property(a, prop.Name),
                    Expression.Property(b, prop.Name));
            var lambda = Expression.Lambda<Comparison<T>>(body, a, b);
            return lambda.Compile();
        }

        #endregion

        #region Private data

        private bool _isSorted;
        private PropertyDescriptor _sortProperty;
        private ListSortDirection _sortDirection;
        private List<T> _unsortedList;

        #endregion

        #region Constructors

        /// <summary>
        /// Initialise une nouvelle instance de <see cref="SortableBindingList{T}"/>.
        /// </summary>
        public SortableBindingList()
        {

        }

        /// <summary>
        /// Initialise une nouvelle instance de <see cref="SortableBindingList{T}"/> avec la liste spécifiée.
        /// </summary>
        /// <param name="list">La liste d'éléments à contenir dans la <see cref="SortableBindingList{T}"/></param>
        public SortableBindingList(IList<T> list)
            : base(list)
        {
        }

        #endregion

        #region BindingList<T> overrides

        /// <summary>
        /// Obtient une valeur indiquant si la liste supporte le tri.
        /// </summary>
        protected override bool SupportsSortingCore
        {
            get
            {
                return true;
            }
        }
        
        /// <summary>
        /// Trie les éléments de la liste selon la propriété et la direction spécifiées
        /// </summary>
        /// <param name="prop">La propriété selon laquelle trier la liste</param>
        /// <param name="direction">La direction selon laquelle trier la liste</param>
        protected override void ApplySortCore(PropertyDescriptor prop, ListSortDirection direction)
        {
            Debug.Print("ApplySortCore({0}, {1})", prop.Name, direction);
            bool raiseEvents = RaiseListChangedEvents;
            try
            {
                RaiseListChangedEvents = false;
                var tmpList = Items.ToList();
                Comparison<T> comparison = GetComparison(prop, direction);
                tmpList.Sort(comparison);

                if (_unsortedList == null)
                    _unsortedList = Items.ToList();

                Items.Clear();
                foreach (var item in tmpList)
                {
                    Items.Add(item);
                }
                _isSorted = true;
                _sortProperty = prop;
                _sortDirection = direction;
            }
            finally
            {
                RaiseListChangedEvents = raiseEvents;
            }
            OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
        }

        /// <summary>
        /// Obtient une valeur indiquant si la liste est triée
        /// </summary>
        protected override bool IsSortedCore
        {
            get { return _isSorted; }
        }

        /// <summary>
        /// Retire le tri appliqué avec ApplySortCore.
        /// </summary>
        protected override void RemoveSortCore()
        {
            Debug.Print("RemoveSortCore()");
            bool raiseEvents = RaiseListChangedEvents;
            try
            {
                RaiseListChangedEvents = false;
                if (_unsortedList != null)
                {
                    Items.Clear();
                    foreach (var item in _unsortedList)
                    {
                        Items.Add(item);
                    }
                }
                _isSorted = false;
                _sortProperty = null;
                _unsortedList = null;
            }
            finally
            {
                RaiseListChangedEvents = raiseEvents;
            }
            OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
        }

        /// <summary>
        /// Obtient la direction du tri si la liste est triée
        /// </summary>
        protected override ListSortDirection SortDirectionCore
        {
            get { return _sortDirection; }
        }

        /// <summary>
        /// Obtient la propriété selon laquelle la liste est triée
        /// </summary>
        protected override PropertyDescriptor SortPropertyCore
        {
            get { return _sortProperty; }
        }

        /// <summary>
        /// Insère l'élément spécifié dans la liste à la position spécifiée
        /// </summary>
        /// <param name="index">Position à laquelle insérer l'élément</param>
        /// <param name="item">Élément à insérer</param>
        protected override void InsertItem(int index, T item)
        {
            Debug.Print("InsertItem({0}, {1})", index, item);
            base.InsertItem(index, item);
            if (_unsortedList != null)
            {
                _unsortedList.Add(item);
            }
        }

        /// <summary>
        /// Retire de la liste l'élément qui se trouve à la position spécifiée
        /// </summary>
        /// <param name="index">Position de l'élément à retirer</param>
        protected override void RemoveItem(int index)
        {
            Debug.Print("RemoveItem({0})", index);
            T item = this[index];
            base.RemoveItem(index);
            if (_unsortedList != null)
            {
                _unsortedList.Remove(item);
            }
        }

        /// <summary>
        /// Remplace l'élément à la position spécifiée par l'élément spécifié
        /// </summary>
        /// <param name="index">Position de l'élément à remplacer</param>
        /// <param name="item">Nouvel élément à placer à cette position</param>
        protected override void SetItem(int index, T item)
        {
            Debug.Print("SetItem({0}, {1})", index, item);
            T oldItem = this[index];
            base.SetItem(index, item);
            if (_unsortedList != null)
            {
                int idx = _unsortedList.IndexOf(oldItem);
                if (idx >= 0)
                    _unsortedList[idx] = item;
            }
        }

        /// <summary>
        /// Retire tous les éléments de la liste
        /// </summary>
        protected override void ClearItems()
        {
            Debug.Print("ClearItems()");
            base.ClearItems();
            if (_unsortedList != null)
                _unsortedList.Clear();
        }

        #endregion

    }
}