using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Linq.Expressions;
using System.Windows.Data;

namespace Developpez.Dotnet.Windows.Collections
{
    ///<summary>
    /// Fournit des méthodes d'extension pour la mise en forme d'une ICollectionView
    ///</summary>
    public static class CollectionViewShaper
    {
        ///<summary>
        /// Renvoie un objet permettant de configurer la mise en forme pour la collection spécifiée.
        ///</summary>
        ///<param name="source">Collection pour laquelle on veut configurer la mise en forme</param>
        ///<typeparam name="TSource">Type des éléments de la collection</typeparam>
        ///<returns>Un objet permettant de configurer la mise en forme pour la collection.</returns>
        /// <remarks>La mise en forme sera appliquée à la vue par défaut de la collection, obtenue
        /// avec CollectionViewSource.GetDefaultView</remarks>
        public static CollectionViewShaper<TSource> ShapeView<TSource>(this IEnumerable<TSource> source)
        {
            var view = CollectionViewSource.GetDefaultView(source);
            return new CollectionViewShaper<TSource>(view);
        }

        /// <summary>
        /// Renvoie un objet permettant de configurer la mise en forme pour la ICollectionView spécifiée.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la collection</typeparam>
        /// <param name="view">ICollectionView pour laquelle on veut configurer la mise en forme</param>
        /// <returns>Un objet permettant de configurer la mise en forme pour la ICollectionView spécifiée.</returns>
        public static CollectionViewShaper<TSource> Shape<TSource>(this ICollectionView view)
        {
            return new CollectionViewShaper<TSource>(view);
        }
    }

    /// <summary>
    /// Permet de configurer la mise en forme d'une ICollectionView à l'aide de Linq
    /// </summary>
    /// <typeparam name="TSource">Type des éléments de la collection</typeparam>
    public class CollectionViewShaper<TSource>
    {
        private readonly ICollectionView _view;
        private Predicate<object> _filter;
        private readonly List<SortDescription> _sortDescriptions = new List<SortDescription>();
        private readonly List<GroupDescription> _groupDescriptions = new List<GroupDescription>();

        /// <summary>
        /// Initialise une nouvelle instance de CollectionViewShaper&lt;TSource&gt;
        /// </summary>
        /// <param name="view">La ICollectionView à mettre en forme</param>
        public CollectionViewShaper(ICollectionView view)
        {
            if (view == null)
                throw new ArgumentNullException("view");
            _view = view;
            _filter = view.Filter;
            _sortDescriptions = view.SortDescriptions.ToList();
            _groupDescriptions = view.GroupDescriptions.ToList();
        }

        /// <summary>
        /// Applique la mise en forme spécifiée à la ICollectionView.
        /// </summary>
        public void Apply()
        {
            using (_view.DeferRefresh())
            {
                _view.Filter = _filter;
                _view.SortDescriptions.Clear();
                foreach (var s in _sortDescriptions)
                {
                    _view.SortDescriptions.Add(s);
                }
                _view.GroupDescriptions.Clear();
                foreach (var g in _groupDescriptions)
                {
                    _view.GroupDescriptions.Add(g);
                }
            }
        }

        /// <summary>
        /// Réinitialise les groupements de la ICollectionView
        /// </summary>
        /// <returns>L'objet CollectionViewShaper&lt;TSource&gt;</returns>
        public CollectionViewShaper<TSource> ClearGrouping()
        {
            _groupDescriptions.Clear();
            return this;
        }

        /// <summary>
        /// Réinitialise les tris de la ICollectionView
        /// </summary>
        /// <returns>L'objet CollectionViewShaper&lt;TSource&gt;</returns>
        public CollectionViewShaper<TSource> ClearSort()
        {
            _sortDescriptions.Clear();
            return this;
        }

        /// <summary>
        /// Réinitialise le filtre de la ICollectionView
        /// </summary>
        /// <returns>L'objet CollectionViewShaper&lt;TSource&gt;</returns>
        public CollectionViewShaper<TSource> ClearFilter()
        {
            _filter = null;
            return this;
        }

        /// <summary>
        /// Réinitialise toute la mise en forme de la ICollectionView (tri, groupement et filtre)
        /// </summary>
        /// <returns>L'objet CollectionViewShaper&lt;TSource&gt;</returns>
        public CollectionViewShaper<TSource> ClearAll()
        {
            _filter = null;
            _sortDescriptions.Clear();
            _groupDescriptions.Clear();
            return this;
        }

        /// <summary>
        /// Spécifie le filtre à appliquer aux éléments de la ICollectionView.
        /// </summary>
        /// <param name="predicate">Prédicat que les éléments doivent vérifier pour apparaître dans les résultats</param>
        /// <returns>L'objet CollectionViewShaper&lt;TSource&gt;</returns>
        public CollectionViewShaper<TSource> Where(Func<TSource, bool> predicate)
        {
            _filter = o => predicate((TSource)o);
            return this;
        }

        /// <summary>
        /// Indique que les éléments de la ICollectionView doivent être triés par ordre croissant selon la propriété spécifiée.
        /// </summary>
        /// <typeparam name="TKey">Type de la clé de tri</typeparam>
        /// <param name="keySelector">Expression qui spécifie la propriété selon laquelle les éléments sont triés.</param>
        /// <returns>L'objet CollectionViewShaper&lt;TSource&gt;</returns>
        /// <remarks>Cette méthode remplace les tris existants. Pour ajouter un tri sans remplacer les tris existants, utiliser
        /// la méthode ThenBy.</remarks>
        public CollectionViewShaper<TSource> OrderBy<TKey>(Expression<Func<TSource, TKey>> keySelector)
        {
            return OrderBy(keySelector, true, ListSortDirection.Ascending);
        }

        /// <summary>
        /// Indique que les éléments de la ICollectionView doivent être triés par ordre décroissant selon la propriété spécifiée.
        /// </summary>
        /// <typeparam name="TKey">Type de la clé de tri</typeparam>
        /// <param name="keySelector">Expression qui spécifie la propriété selon laquelle les éléments sont triés.</param>
        /// <returns>L'objet CollectionViewShaper&lt;TSource&gt;</returns>
        /// <remarks>Cette méthode remplace les tris existants. Pour ajouter un tri sans remplacer les tris existants, utiliser
        /// la méthode ThenByDescending.</remarks>
        public CollectionViewShaper<TSource> OrderByDescending<TKey>(Expression<Func<TSource, TKey>> keySelector)
        {
            return OrderBy(keySelector, true, ListSortDirection.Descending);
        }

        /// <summary>
        /// Indique que les éléments de la ICollectionView doivent être triés par ordre croissant selon la propriété spécifiée.
        /// </summary>
        /// <typeparam name="TKey">Type de la clé de tri</typeparam>
        /// <param name="keySelector">Expression qui spécifie la propriété selon laquelle les éléments sont triés.</param>
        /// <returns>L'objet CollectionViewShaper&lt;TSource&gt;</returns>
        /// <remarks>Cette méthode ne remplace pas les tris existants, mais ajoute un nouveau tri aux tris existants. Pour remplacer
        /// les tris existants, utiliser la méthode OrderBy.</remarks>
        public CollectionViewShaper<TSource> ThenBy<TKey>(Expression<Func<TSource, TKey>> keySelector)
        {
            return OrderBy(keySelector, false, ListSortDirection.Ascending);
        }

        /// <summary>
        /// Indique que les éléments de la ICollectionView doivent être triés par ordre décroissant selon la propriété spécifiée.
        /// </summary>
        /// <typeparam name="TKey">Type de la clé de tri</typeparam>
        /// <param name="keySelector">Expression qui spécifie la propriété selon laquelle les éléments sont triés.</param>
        /// <returns>L'objet CollectionViewShaper&lt;TSource&gt;</returns>
        /// <remarks>Cette méthode ne remplace pas les tris existants, mais ajoute un nouveau tri aux tris existants. Pour remplacer
        /// les tris existants, utiliser la méthode OrderByDescending.</remarks>
        public CollectionViewShaper<TSource> ThenByDescending<TKey>(Expression<Func<TSource, TKey>> keySelector)
        {
            return OrderBy(keySelector, false, ListSortDirection.Descending);
        }

        private CollectionViewShaper<TSource> OrderBy<TKey>(Expression<Func<TSource, TKey>> keySelector, bool clear, ListSortDirection direction)
        {
            string path = GetPropertyPath(keySelector.Body);
            if (clear)
                _sortDescriptions.Clear();
            _sortDescriptions.Add(new SortDescription(path, direction));
            return this;
        }

        /// <summary>
        /// Indique que les éléments de la ICollectionView doivent être groupés selon la propriété spécifiée.
        /// </summary>
        /// <typeparam name="TKey">Type de la clé de groupement</typeparam>
        /// <param name="keySelector">Expression qui spécifie la propriété selon laquelle les éléments sont triés.</param>
        /// <returns>L'objet CollectionViewShaper&lt;TSource&gt;</returns>
        /// <remarks>Cette ajoute un nouveau groupement aux groupements existants. Pour supprimer les groupements, utiliser
        /// la méthode ClearGrouping.</remarks>
        public CollectionViewShaper<TSource> GroupBy<TKey>(Expression<Func<TSource, TKey>> keySelector)
        {
            string path = GetPropertyPath(keySelector.Body);
            _groupDescriptions.Add(new PropertyGroupDescription(path));
            return this;
        }

        private static string GetPropertyPath(Expression expression)
        {
            var names = new Stack<string>();
            var expr = expression;
            while (expr != null && !(expr is ParameterExpression) && !(expr is ConstantExpression))
            {
                var memberExpr = expr as MemberExpression;
                if (memberExpr == null)
                    throw new ArgumentException("The selector body must contain only property or field access expressions");
                names.Push(memberExpr.Member.Name);
                expr = memberExpr.Expression;
            }
            return String.Join(".", names.ToArray());
        }
    }
}