using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Threading;

namespace Developpez.Dotnet.Windows.Collections
{
    /// <summary>
    /// Représente une collection de données dynamiques qui fournit des notifications lorsque des éléments sont ajoutés,
    /// supprimés ou lorsque la liste entière est actualisée. Les évènements sont toujours levés sur le thread qui a créé
    /// la collection, de façon à permettre le binding sur la collection même lorsqu'elle est modifiée de façon asynchrone.
    /// </summary>
    /// <typeparam name="T">Le type des éléments de la collection</typeparam>
    public class AsyncObservableCollection<T> : ObservableCollection<T>
    {
        private SynchronizationContext _synchronizationContext = SynchronizationContext.Current;

        /// <summary>
        /// Initialise une nouvelle instance de la classe AsyncObservableCollection&lt;T&gt;.
        /// </summary>
        public AsyncObservableCollection()
        {
        }

        /// <summary>
        /// Initialise une nouvelle instance de la classe AsyncObservableCollection&lt;T&gt; qui contient des éléments copiés depuis la collection spécifiée. 
        /// </summary>
        /// <param name="list">Collection à partir de laquelle les éléments sont copiés. </param>
        public AsyncObservableCollection(IEnumerable<T> list)
            : base(list)
        {
        }

        /// <summary>
        /// Déclenche l'événement CollectionChanged avec les arguments fournis. Si cette méthode est appelée à partir du thread qui a créé la collection,
        /// les gestionnaires abonnés à l'évènement sont appelés directement. Sinon, ils sont invoqués sur le thread qui a créé la collection.
        /// </summary>
        /// <param name="e">Arguments de l'événement déclenché.</param>
        protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
        {
            if (SynchronizationContext.Current == _synchronizationContext)
            {
                // On déclenche l'évènement CollectionChanged sur le thread courant
                base.OnCollectionChanged(e);
            }
            else
            {
                // On déclenche l'évènement CollectionChanged sur le thread qui a créé la collection
                _synchronizationContext.Send(RaiseCollectionChanged, e);
            }
        }

        private void RaiseCollectionChanged(object param)
        {
            base.OnCollectionChanged((NotifyCollectionChangedEventArgs)param);
        }

        /// <summary>
        /// Déclenche l'événement PropertyChanged avec les arguments fournis. Si cette méthode est appelée à partir du thread qui a créé la collection,
        /// les gestionnaires abonnés à l'évènement sont appelés directement. Sinon, ils sont invoqués sur le thread qui a créé la collection.
        /// </summary>
        /// <param name="e">Arguments de l'événement déclenché.</param>
        protected override void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            if (SynchronizationContext.Current == _synchronizationContext)
            {
                // On déclenche l'évènement PropertyChanged sur le thread courant
                base.OnPropertyChanged(e);
            }
            else
            {
                // On déclenche l'évènement PropertyChanged sur le thread qui a créé la collection
                _synchronizationContext.Send(RaisePropertyChanged, e);
            }
        }

        private void RaisePropertyChanged(object param)
        {
            base.OnPropertyChanged((PropertyChangedEventArgs)param);
        }
    }
}