using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Developpez.Dotnet.Threading;

namespace Developpez.Dotnet.Collections
{

    public static partial class EnumerableExtensions
    {
        /// <summary>
        /// Obtient une version synchronisée de la liste
        /// </summary>
        /// <typeparam name="T">Type générique de la liste</typeparam>
        /// <param name="list">liste</param>
        /// <returns>liste synchronisée</returns>
        public static IList<T> Synchronized<T>(this IList<T> list)
        {
            return new SyncList<T>(list);
        }

        #region ForEachParallel

        /// <summary>
        /// Exécute la méthode callback de manière parallele sur tous les éléments
        /// de la collection
        /// </summary>
        /// <typeparam name="T">Type de collection</typeparam>
        /// <param name="enumerable">Séquence d'éléments sur laquelle effectuer une action en parallèle</param>
        /// <param name="callback">Méthode à rappeller sur chacun des éléments</param>
        public static void ForEachParallel<T>(this IEnumerable<T> enumerable, ThreadedWorker<T>.CallBackMethod callback)
        {
            enumerable.ForEachParallel(callback, true);
        }

        /// <summary>
        /// Exécute la méthode callback de manière parallele sur tous les éléments
        /// de la collection
        /// </summary>
        /// <typeparam name="T">Type de collection</typeparam>
        /// <param name="enumerable">Séquence d'éléments sur laquelle effectuer une action en parallèle</param>
        /// <param name="callback">Méthode à rappeller sur chacun des éléments</param>
        /// <param name="waitForCompletion">True si l'opération doit être synchrone (attente de la fin de l'opération sur tous les éléments)
        /// ou non (aucune attente, l'exécution se poursuit)</param>
        public static void ForEachParallel<T>(this IEnumerable<T> enumerable, ThreadedWorker<T>.CallBackMethod callback, bool waitForCompletion)
        {
            enumerable.ForEachParallel(callback, waitForCompletion, -1);
        }

        /// <summary>
        /// Exécute la méthode callback de manière parallele sur tous les éléments
        /// de la collection
        /// </summary>
        /// <typeparam name="T">Type de collection</typeparam>
        /// <param name="enumerable">Séquence d'éléments sur laquelle effectuer une action en parallèle</param>
        /// <param name="callback">Méthode à rappeller sur chacun des éléments</param>
        /// <param name="waitForCompletion">True si l'opération doit être synchrone (attente de la fin de l'opération sur tous les éléments)
        /// ou non (aucune attente, l'exécution se poursuit)</param>
        /// <param name="maxWorkerThreads">Nombre maximum de thread de travail dédié à cette tâche. Toute valeure inférieure à 1 est ignorée</param>
        public static void ForEachParallel<T>(this IEnumerable<T> enumerable, ThreadedWorker<T>.CallBackMethod callback, bool waitForCompletion, int maxWorkerThreads)
        {
            callback.CheckArgumentNull("callback");

            using (ThreadedWorker<T> worker = new ThreadedWorker<T>())
            {
                if (maxWorkerThreads > 0)
                    worker.MaxThreadCount = maxWorkerThreads;
                worker.ForEach(enumerable, callback, waitForCompletion);
            }
        }

        /// <summary>
        /// Exécute la méthode callback de manière parallele sur tous les éléments
        /// de la collection
        /// </summary>
        /// <param name="enumerable">Séquence d'éléments sur laquelle effectuer une action en parallèle</param>
        /// <param name="callback">Méthode à rappeller sur chacun des éléments</param>
        public static void ForEachParallel(this IEnumerable enumerable, ThreadedWorker<object>.CallBackMethod callback)
        {
            enumerable.ForEachParallel(callback, true);
        }

        /// <summary>
        /// Exécute la méthode callback de manière parallele sur tous les éléments
        /// de la collection
        /// </summary>
        /// <param name="enumerable">Séquence d'éléments sur laquelle effectuer une action en parallèle</param>
        /// <param name="callback">Méthode à rappeller sur chacun des éléments</param>
        /// <param name="waitForCompletion">True si l'opération doit être synchrone (attente de la fin de l'opération sur tous les éléments)
        /// ou non (aucune attente, l'exécution se poursuit)</param>
        public static void ForEachParallel(this IEnumerable enumerable, ThreadedWorker<object>.CallBackMethod callback, bool waitForCompletion)
        {
            enumerable.ForEachParallel(callback, waitForCompletion, -1);
        }

        /// <summary>
        /// Exécute la méthode callback de manière parallele sur tous les éléments
        /// de la collection
        /// </summary>
        /// <param name="enumerable">Séquence d'éléments sur laquelle effectuer une action en parallèle</param>
        /// <param name="callback">Méthode à rappeller sur chacun des éléments</param>
        /// <param name="waitForCompletion">True si l'opération doit être synchrone (attente de la fin de l'opération sur tous les éléments)
        /// ou non (aucune attente, l'exécution se poursuit)</param>
        /// <param name="maxWorkerThreads">Nombre maximum de thread de travail dédié à cette tâche. Toute valeure inférieure à 1 est ignorée</param>
        public static void ForEachParallel(this IEnumerable enumerable, ThreadedWorker<object>.CallBackMethod callback, bool waitForCompletion, int maxWorkerThreads)
        {
            callback.CheckArgumentNull("callback");

            using (ThreadedWorker<object> worker = new ThreadedWorker<object>())
            {
                if (maxWorkerThreads > 0)
                    worker.MaxThreadCount = maxWorkerThreads;
                worker.ForEach(enumerable.Cast<object>(), callback, waitForCompletion);
            }
        }

        #endregion


    }
}