using System;
using System.Collections;
using System.Collections.Generic;

namespace Developpez.Dotnet.Collections
{
    /// <summary>
    /// Représente une liste fortement typée d'objets accessibles par index. Fournit des méthodes de recherche, de tri et de manipulation de listes.<br/>
    /// Cette classe est thread-safe
    /// </summary>
    /// <typeparam name="T">Type des éléments de la liste</typeparam>
    public class SyncList<T> : IList<T>, ICollection
    {
        #region Internals

        readonly object _syncRoot = new object();

        /// <summary>
        /// Objet de synchronisation
        /// </summary>
        public virtual object SyncRoot
        {
            get { return _syncRoot; }
        }

        private readonly List<T> _internalList;

        /// <summary>
        /// Liste utilisée en interne pour stocker les valeurs
        /// </summary>
        protected virtual List<T> InternalList
        {
            get { return _internalList; }
        }

        #endregion

        /// <summary>
        /// Initialise une nouvelle instance de la classe <see cref="SyncList{T}"/>
        /// </summary>
        public SyncList()
        {
            _internalList = new List<T>();
        }

        /// <summary>
        /// Initialise une nouvelle instance de la classe <see cref="SyncList{T}"/> qui contient des éléments copiés à partir de la collection spécifiée et qui possède une capacité suffisante pour accepter le nombre d'éléments copiés.
        /// </summary>
        /// <param name="collection">Collection dont les éléments sont copiés dans la nouvelle liste. </param>
        public SyncList(IEnumerable<T> collection)
        {
            _internalList = new List<T>(collection);
        }

        /// <summary>
        /// Initialise une nouvelle instance de la classe <see cref="SyncList{T}"/> qui est vide et a la capacité initiale spécifiée.
        /// </summary>
        /// <param name="capacity">Capacité initiale de la liste</param>
        public SyncList(int capacity)
        {
            _internalList = new List<T>(capacity);
        }

        #region IList<T> Membres

        /// <summary>
        /// Renvoi l'index d'un élément présent dans la liste, ou -1 s'il n'a pas été trouvé
        /// </summary>
        /// <param name="item">Element à rechercher</param>
        /// <returns>Index de l'élément s'il a été trouvé, ou -1 sinon</returns>
        public virtual int IndexOf(T item)
        {
            lock (SyncRoot)
            {
                return InternalList.IndexOf(item);
            }
        }

        /// <summary>
        /// Insère un élément à la position indiquée
        /// </summary>
        /// <param name="index">Position à laquelle insérer un élément</param>
        /// <param name="item">Elément à insérer</param>
        public virtual void Insert(int index, T item)
        {
            lock (SyncRoot)
            {
                InternalList.Insert(index, item);
            }
        }

        /// <summary>
        /// Retire l'élément présent à l'indice de base zéro index de la liste
        /// </summary>
        /// <param name="index">indice de l'élément à retirer de la liste</param>
        public virtual void RemoveAt(int index)
        {
            lock (SyncRoot)
            {
                InternalList.RemoveAt(index);
            }
        }

        /// <summary>
        /// Obtient ou définit l'élément à l'indice de base zéro index
        /// </summary>
        /// <param name="index">indice de l'élément</param>
        /// <returns>élément à l'indice de base zéro index</returns>
        public virtual T this[int index]
        {
            get
            {
                lock (SyncRoot)
                {
                    return InternalList[index];
                }
            }
            set
            {
                lock (SyncRoot)
                {
                    InternalList[index] = value;
                }
            }
        }

        #endregion

        #region ICollection<T> Membres

        /// <summary>
        /// Ajoute un objet à la fin de <see cref="SyncList{T}"/>
        /// </summary>
        /// <param name="item">Element à rajouter</param>
        public virtual void Add(T item)
        {
            lock (SyncRoot)
            {
                InternalList.Add(item);
            }
        }

        /// <summary>
        /// Supprime tous les éléments de <see cref="SyncList{T}"/>
        /// </summary>
        public virtual void Clear()
        {
            lock (SyncRoot)
            {
                InternalList.Clear();
            }
        }

        /// <summary>
        /// Détermine si un élément est dans <see cref="SyncList{T}"/>
        /// </summary>
        /// <param name="item">Objet à trouver dans <see cref="SyncList{T}"/>. La valeur peut être une référence null (Nothing en Visual Basic) pour les types référence. </param>
        /// <returns>true si item existe dans <see cref="SyncList{T}"/> ; sinon, false</returns>
        public virtual bool Contains(T item)
        {
            lock (SyncRoot)
            {
                return InternalList.Contains(item);
            }
        }

        /// <summary>
        /// Copie l'ensemble du <see cref="SyncList{T}"/> vers un tableau compatible unidimensionnel, en commençant à l'index spécifié du tableau cible.
        /// </summary>
        /// <param name="array">Array unidimensionnel qui constitue la destination des éléments copiés à partir de <see cref="SyncList{T}"/>. Array doit avoir une indexation de base zéro. </param>
        /// <param name="arrayIndex">Index de base zéro dans array au niveau duquel commencer la copie. </param>
        public virtual void CopyTo(T[] array, int arrayIndex)
        {
            lock (SyncRoot)
            {
                InternalList.CopyTo(array, arrayIndex);
            }
        }

        /// <summary>
        /// Renvoi le nombre d'éléments actuellement présents dans la liste
        /// </summary>
        public virtual int Count
        {
            get
            {
                lock (SyncRoot)
                {
                    return InternalList.Count;
                }
            }
        }

        /// <summary>
        /// Indique si la liste est en lecture seule
        /// </summary>
        public virtual bool IsReadOnly
        {
            get { return false; }
        }

        /// <summary>
        /// Supprime la première occurrence d'un objet spécifique de <see cref="SyncList{T}"/>.
        /// </summary>
        /// <param name="item">Objet à supprimer de <see cref="SyncList{T}"/>. La valeur peut être une référence null (Nothing en Visual Basic) pour les types référence. </param>
        /// <returns>true si la suppression de item est réussie ; sinon, false. Cette méthode retourne également false si item est introuvable dans <see cref="SyncList{T}"/>. </returns>
        public virtual bool Remove(T item)
        {
            lock (SyncRoot)
            {
                return InternalList.Remove(item);
            }
        }

        #endregion

        #region IEnumerable<T> Membres

        /// <summary>
        /// Retourne un énumérateur qui parcourt <see cref="SyncList{T}"/>.
        /// </summary>
        /// <returns><see cref="SynchronizedEnumerator"/> pour <see cref="SyncList{T}"/>. </returns>
        public virtual IEnumerator<T> GetEnumerator()
        {
            IEnumerator<T> enumerator;
            lock(SyncRoot)
            {
                enumerator = InternalList.GetEnumerator();
            }

            return new SynchronizedEnumerator(this, enumerator);
        }

        /// <summary>
        /// Enumerateur thread-safe pour <see cref="SyncList{T}"/>
        /// </summary>
        public class SynchronizedEnumerator : IEnumerator<T>
        {
            /// <summary>
            /// Liste utilisée en interne pour récupérer les valeurs
            /// </summary>
            private readonly SyncList<T> _ownedList;

            /// <summary>
            /// Enumérateur non thread safe de la liste parente
            /// </summary>
            private readonly IEnumerator<T> _enumerator;

            /// <summary>
            /// Initialise une nouvelle instance de l'énumérateur
            /// </summary>
            /// <param name="ownedList">Liste à utiliser pour l'énumération</param>
            /// <param name="enumerator">Enumérateur utilisé pour l'opération</param>
            public SynchronizedEnumerator(SyncList<T> ownedList, IEnumerator<T> enumerator)
            {
                this._ownedList = ownedList;
                this._enumerator = enumerator;
            }

            #region IEnumerator<T> Membres

            /// <summary>
            /// Obtient l'élément actuel dans la collection.
            /// </summary>
            public T Current
            {
                get
                {
                    lock (_ownedList.SyncRoot)
                    {
                        return _enumerator.Current;
                    }
                }
            }

            #endregion

            #region IDisposable Membres
            /// <summary>
            /// Libère toutes les ressources utilisées par cet objet
            /// </summary>
            public void Dispose()
            {
                _enumerator.Dispose();
            }

            #endregion

            #region IEnumerator Membres

            /// <summary>
            /// Obtient l'élément actuel dans la collection.
            /// </summary>
            object IEnumerator.Current
            {
                get { return ((IEnumerator<T>)this).Current; }
            }

            /// <summary>
            /// Avance l'énumérateur à l'élément suivant de la collection.
            /// </summary>
            /// <returns>true si l'énumérateur a pu avancer jusqu'à l'élément suivant ; false si l'énumérateur a dépassé la fin de la collection.</returns>
            public bool MoveNext()
            {
                lock (_ownedList.SyncRoot)
                {
                    return _enumerator.MoveNext();
                }
            }

            /// <summary>
            /// Rétablit l'énumérateur à sa position initiale, qui précède le premier élément de la collection.
            /// </summary>
            public void Reset()
            {
                lock (_ownedList.SyncRoot)
                {
                    _enumerator.Reset();
                }
            }

            #endregion
        }

        #endregion

        #region IEnumerable Membres

        /// <summary>
        /// Retourne un énumérateur qui parcourt <see cref="SyncList{T}"/>.
        /// </summary>
        /// <returns><see cref="SynchronizedEnumerator"/> pour <see cref="SyncList{T}"/>. </returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IList<T>)this).GetEnumerator();
        }

        #endregion

        #region ICollection Membres

        /// <summary>
        /// Copie les éléments de ICollection dans Array, en commençant à un index particulier de Array.
        /// </summary>
        /// <param name="array">Array unidimensionnel qui constitue la destination des éléments copiés à partir de ICollection. Array doit avoir une indexation de base zéro.</param>
        /// <param name="index">Index de base zéro dans array au niveau duquel commencer la copie.</param>
        public virtual void CopyTo(Array array, int index)
        {
            T[] lst;
            lock (SyncRoot)
            {
                lst = InternalList.ToArray();
            }
            lst.CopyTo(array, index);
        }

        /// <summary>
        /// Indique si la liste est synchronisée
        /// </summary>
        public virtual bool IsSynchronized
        {
            get { return true; }
        }

        #endregion
    }
}