using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq.Expressions;
using Developpez.Dotnet.Linq;

namespace Developpez.Dotnet.ComponentModel
{
    /// <summary>
    /// Fournit des méthodes d'extension pour travailler avec les objets implémentant <c>INotifyPropertyChanged</c>.
    /// </summary>
    public static class NotifyPropertyChangedExtensions
    {
        #region Property changed

        /// <summary>
        /// Ajoute un handler à l'évènement PropertyChanged pour la propriété spécifiée.
        /// </summary>
        /// <param name="target">Objet à surveiller</param>
        /// <param name="propertyName">Nom de la propriété à surveiller</param>
        /// <param name="handler">Handler à exécuter quand la valeur de la propriété change</param>
        /// <returns>Un objet IDisposable à supprimer pour se désabonner de l'évènement</returns>
        public static IDisposable OnPropertyChanged(this INotifyPropertyChanged target, string propertyName, PropertyChangedEventHandler handler)
        {
            return new DisposablePropertyChangedHandler(target, propertyName, handler);
        }

        /// <summary>
        /// Ajoute un handler à l'évènement PropertyChanged pour la propriété spécifiée.
        /// </summary>
        /// <typeparam name="T">Type de la propriété à surveiller</typeparam>
        /// <param name="target">Objet à surveiller</param>
        /// <param name="propertySelector">Expression représentant l'accès à la propriété à surveiller</param>
        /// <param name="handler">Handler à exécuter quand la valeur de la propriété change</param>
        /// <returns>Un objet IDisposable à supprimer pour se désabonner de l'évènement</returns>
        public static IDisposable OnPropertyChanged<T>(this INotifyPropertyChanged target, Expression<Func<T>> propertySelector, PropertyChangedEventHandler handler)
        {
            string propertyName = LinqHelper.GetPropertyName(propertySelector);
            return target.OnPropertyChanged(propertyName, handler);
        }

        private class DisposablePropertyChangedHandler : IDisposable
        {
            private INotifyPropertyChanged _target;
            private string _propertyName;
            private PropertyChangedEventHandler _handler;

            public DisposablePropertyChangedHandler(INotifyPropertyChanged target, string propertyName, PropertyChangedEventHandler handler)
            {
                _target = target;
                _propertyName = propertyName;
                _handler = handler;
                _target.PropertyChanged += target_PropertyChanged;
            }

            void target_PropertyChanged(object sender, PropertyChangedEventArgs e)
            {
                if (e.PropertyName == _propertyName ||
                    e.PropertyName.IsNullOrEmpty()) // null ou vide signifie que toutes les propriétés ont changé
                {
                    _handler(sender, e);
                }
            }

            #region IDisposable Members

            public void Dispose()
            {
                _target.PropertyChanged -= target_PropertyChanged;
                _target = null;
                _propertyName = null;
                _handler = null;
            }

            #endregion
        }

        #endregion

        #region Property dependencies

        /// <summary>
        /// Commence un bloc de définition des dépendences d'une propriété
        /// </summary>
        /// <param name="target">Objet pour lequel on définit les dépendences d'une propriété</param>
        /// <param name="propertyName">Nom de la propriété pour laquelle on définit les dépendences</param>
        /// <returns>Un objet <c>PropertyDependencyManager</c> qui gère les dépendences de la propriété</returns>
        /// <remarks>Un objet <c>PropertyDependencyManager</c> permet de gérer les dépendences entre différentes propriétés
        /// de façon à déclencher automatiquement l'évènement <c>PropertyChanged</c> pour les propriétés concernées</remarks>
        public static PropertyDependencyManager SetDependenciesFor(this INotifyPropertyChanged target, string propertyName)
        {
            return new PropertyDependencyManager(target, propertyName);
        }

        /// <summary>
        /// Commence un bloc de définition des dépendences d'une propriété
        /// </summary>
        /// <typeparam name="T">Type de la propriété à gérer</typeparam>
        /// <param name="target">Objet pour lequel on définit les dépendences d'une propriété</param>
        /// <param name="propertySelector">Expression représentant l'accès à la propriété pour laquelle on définit les dépendences</param>
        /// <returns>Un objet <c>PropertyDependencyManager</c> qui gère les dépendences de la propriété</returns>
        /// <remarks>Un objet <c>PropertyDependencyManager</c> permet de gérer les dépendences entre différentes propriétés
        /// de façon à déclencher automatiquement l'évènement <c>PropertyChanged</c> pour les propriétés concernées</remarks>
        public static PropertyDependencyManager SetDependenciesFor<T>(this INotifyPropertyChanged target, Expression<Func<T>> propertySelector)
        {
            return target.SetDependenciesFor(LinqHelper.GetPropertyName(propertySelector));
        }

        /// <summary>
        /// Gère les dépendences entre différentes propriétés d'une classe, de façon à déclencher automatiquement
        /// l'évènement <c>PropertyChanged</c> pour les propriétés concernées.
        /// </summary>
        public class PropertyDependencyManager
        {
            internal PropertyDependencyManager(INotifyPropertyChanged target, string propertyName)
            {
                _watchedProperties = new List<string>();
                _affectedProperties = new List<string>();
                this.Target = target;
                this.PropertyName = propertyName;
            }

            internal INotifyPropertyChanged Target { get; private set; }
            internal string PropertyName { get; private set; }

            private List<string> _watchedProperties;
            private List<string> _affectedProperties;

            /// <summary>
            /// Permet d'indiquer que la propriété gérée dépend de la propriété spécifiée.
            /// Si cette propriété change, l'évènement <c>PropertyChanged</c> sera
            /// également déclenché pour la propriété gérée.
            /// </summary>
            /// <param name="propertyName">Nom de la propriété dont dépend la propriété gérée</param>
            /// <returns>L'objet <c>PropertyDependencyManager</c> courant</returns>
            public PropertyDependencyManager DependsOn(string propertyName)
            {
                _watchedProperties.Add(propertyName);
                return this;
            }

            /// <summary>
            /// Permet d'indiquer que la propriété gérée par cet objet dépend de la propriété spécifiée.
            /// Si cette propriété change, l'évènement <c>PropertyChanged</c> sera
            /// également déclenché pour la propriété gérée.
            /// </summary>
            /// <typeparam name="T">Type de la propriété dont dépend la propriété gérée</typeparam>
            /// <param name="propertySelector">Expression représentant l'accès à la propriété dont dépend la propriété gérée</param>
            /// <returns>L'objet <c>PropertyDependencyManager</c> courant</returns>
            public PropertyDependencyManager DependsOn<T>(Expression<Func<T>> propertySelector)
            {
                return DependsOn(LinqHelper.GetPropertyName(propertySelector));
            }

            /// <summary>
            /// Permet d'indiquer que la propriété spécifiée dépend de la propriété gérée par cet objet.
            /// Si la propriété gérée change, l'évènement <c>PropertyChanged</c> sera
            /// également déclenché pour la propriété spécifiée.
            /// </summary>
            /// <param name="propertyName">Nom de la propriété qui dépend de la propriété gérée</param>
            /// <returns>L'objet <c>PropertyDependencyManager</c> courant</returns>
            public PropertyDependencyManager Affects(string propertyName)
            {
                _affectedProperties.Add(propertyName);
                return this;
            }

            /// <summary>
            /// Permet d'indiquer que la propriété spécifiée dépend de la propriété gérée par cet objet.
            /// Si la propriété gérée change, l'évènement <c>PropertyChanged</c> sera
            /// également déclenché pour la propriété spécifiée.
            /// </summary>
            /// <typeparam name="T">Type de la propriété affectée par la propriété gérée</typeparam>
            /// <param name="propertySelector">Expression représentant l'accès à la propriété qui dépend de la propriété gérée</param>
            /// <returns>L'objet <c>PropertyDependencyManager</c> courant</returns>
            public PropertyDependencyManager Affects<T>(Expression<Func<T>> propertySelector)
            {
                return Affects(LinqHelper.GetPropertyName(propertySelector));
            }

            /// <summary>
            /// Permet d'indiquer l'action à effectuer pour déchencher l'évènement.
            /// </summary>
            /// <param name="raiseEventAction">Action à effectuer pour déclencher l'évènement.</param>
            public void Raise(Action<string> raiseEventAction)
            {
                this.Target.PropertyChanged +=
                    (sender, e) =>
                    {
                        if (e.PropertyName.In(_watchedProperties))
                        {
                            raiseEventAction(this.PropertyName);
                        }
                        if (e.PropertyName == this.PropertyName)
                        {
                            foreach (var prop in _affectedProperties)
                            {
                                raiseEventAction(prop);
                            }
                        }
                    };
            }
        }

        #endregion
    }
}