using System;
using System.Threading;
using Developpez.Dotnet.Properties;

namespace Developpez.Dotnet.Threading
{
    /// <summary>
    /// Utilitaires d'exécutions de méthodes via différents threads
    /// </summary>
    public static class ThreadUtils
    {
        static bool _useThreadPool = true;

        /// <summary>
        /// Indique si par défaut le ThreadPool doit être utilisé à la place
        /// de créer un nouveau thread pour les opérations compatibles
        /// </summary>
        public static bool UseThreadPool
        {
            get {return _useThreadPool;}
            set{_useThreadPool = value;}
        }

        /// <summary>
        /// Exécute le délégué spécifié en arrière plan dans un nouveau thread
        /// </summary>
        /// <param name="method">Délégué à exécuter en arrière plan</param>
        public static void ExecuteBackground(ThreadStart method)
        {
            ExecuteBackground(method, "Thread de travail en arrière plan");
        }

        /// <summary>
        /// Exécute le délégué spécifié en arrière plan dans un nouveau thread
        /// </summary>
        /// <param name="method">Délégué à exécuter en arrière plan</param>
        /// <param name="description">Description du thread crée</param>
        public static void ExecuteBackground(ThreadStart method, string description)
        {
            Thread m_thread = new Thread(method);
            m_thread.Priority = ThreadPriority.BelowNormal;
            m_thread.IsBackground = true;
            m_thread.Name = description;
            m_thread.Start();
        }

        /// <summary>
        /// Exécute une méthode avec un temps maximal d'exécution. Si le temps d'exécution est dépassé
        /// et que le délégué ne s'est toujours pas terminé, le travail est arrêté via Thread.Abort
        /// et une exception TimeoutException est levée
        /// </summary>
        /// <param name="method">Délégué à exécuter</param>
        /// <param name="timeout">Temps maximal d'exécution du délégué</param>
        public static void Execute(ThreadStart method, TimeSpan timeout)
        {
            Execute(method, "Thread de travail asyncrone", timeout);
        }

        /// <summary>
        /// Exécute une méthode avec un temps maximal d'exécution. Si le temps d'exécution est dépassé
        /// et que le délégué ne s'est toujours pas terminé, le travail est arrêté via Thread.Abort
        /// et une exception TimeoutException est levée
        /// </summary>
        /// <param name="method">Délégué à exécuter</param>
        /// <param name="description">Description du thread crée (si un thread est crée)</param>
        /// <param name="timeout">Temps maximal d'exécution du délégué</param>
        public static void Execute(ThreadStart method, string description, TimeSpan timeout)
        {
            if (method == null)
                throw new ArgumentNullException("method");
            if (timeout.TotalMilliseconds < 1)
                throw new ArgumentOutOfRangeException(ExceptionMessages.TimeoutOutOfRange);

            if (timeout.TotalMilliseconds >= int.MaxValue)
            {
                /* temps infini */
                method.Invoke();
                return;
            }

            Thread m_thread = new Thread(method);
            m_thread.Name = description;
            m_thread.Start();
            DateTime begin = DateTime.Now;

            while (true)
            {
                switch (m_thread.ThreadState)
                {
                    case ThreadState.Aborted:
                    case ThreadState.AbortRequested:
                    case ThreadState.Stopped:
                    case ThreadState.StopRequested:
                        {
                            return;
                        }
                    default:
                        {
                            break;
                        }
                }

                if ((DateTime.Now - begin) > timeout)
                {
                    m_thread.Abort();
                    throw new TimeoutException(ExceptionMessages.OperationTimedOut);
                }

                Thread.Sleep(10); /* pour épargner du CPU */
            }
        }
        
        /// <summary>
        /// Exécute un délégué de manière asynchrone
        /// </summary>
        /// <param name="method">Délégué à exécuter</param>
        public static void ExecuteAsync(ThreadStart method)
        {
            ExecuteAsync(method, "Thread de travail asynchrone");
        }

        /// <summary>
        /// Exécute un délégué de manière asynchrone
        /// </summary>
        /// <param name="method">Délégué à exécuter</param>
        /// <param name="description">Si un thread est crée, description de celui ci</param>
        public static void ExecuteAsync(ThreadStart method, string description)
        {
            if (method == null)
                throw new ArgumentNullException("method");

            if (UseThreadPool)
            {
                ThreadPool.QueueUserWorkItem(new WaitCallback(delegate
                {
                    method.Invoke();
                }));
            }
            else
            {
                Thread m_thread = new Thread(method);
                m_thread.Name = description;
                m_thread.Start();
            }
        }

        /// <summary>
        /// Exécute un délégué de manière asynchrone
        /// </summary>
        /// <param name="method">Délégué à exécuter</param>
        /// <param name="onFinish">Evènement à appeler lorsque l'opération est terminée</param>
        /// <remarks>
        /// onFinish peut être null cependant si onFinish est différent de null il est exécuté
        /// sur le thread ayant exécuté le travail, pas sur le thread appelant
        /// </remarks>
        public static void ExecuteAsync(ThreadStart method, EventHandler onFinish)
        {
            ExecuteAsync(method, "Thread de travail asyncrone", onFinish);
        }

        /// <summary>
        /// Exécute un délégué de manière asynchrone
        /// </summary>
        /// <param name="method">Délégué à exécuter</param>
        /// <param name="description">Description du thread crée (si un thread est crée)</param>
        /// <param name="onFinish">Evènement à appeler lorsque l'opération est terminée</param>
        /// <remarks>
        /// onFinish peut être null cependant si onFinish est différent de null il est exécuté
        /// sur le thread ayant exécuté le travail, pas sur le thread appelant
        /// </remarks>
        public static void ExecuteAsync(ThreadStart method, string description, EventHandler onFinish)
        {
            if (method == null)
                throw new ArgumentNullException("method");

            if (onFinish == null)
                ExecuteAsync(method, description);
            else
            {
                ExecuteAsync(new ThreadStart(delegate
                    {
                        method.Invoke();
                        onFinish.Invoke(null, EventArgs.Empty);
                    }), description);
            }
        }
    }
}