using System;
using System.Threading;

namespace Threads
{
    /// <summary>
    /// Аргументы для события "Старт потока"
    /// </summary>
    public sealed class StartArgs : EventArgs
    {
        #region .ctor

        public StartArgs(bool wasStarted)
        {
            WasStopped = wasStarted;
        }

        #endregion

        /// <summary>
        /// Состояние потока до вызова метода Start()
        /// </summary>
        public bool WasStopped { get; private set; }
    }

    /// <summary>
    /// Аргументы для события "Останов потока"
    /// </summary>
    public sealed class StopArgs : EventArgs
    {
        #region .ctor

        public StopArgs(bool wasStarted, bool exitByTimeout)
        {
            WasStarted = wasStarted;
            IsExitByTimeout = exitByTimeout;
        }

        #endregion

        /// <summary>
        /// Состояние потока до вызова метода Stop()
        /// </summary>
        public bool WasStarted { get; private set; }

        /// <summary>
        /// Флаг прерывания потока исполнения по таймауту
        /// </summary>
        public bool IsExitByTimeout { get; private set; }
    }

    /// <summary>
    /// Шаблон для выполнения метода в отдельном потоке с дополнительным функционалом управления и мониторинга
    /// </summary>
    /// <remarks>Потомки должны быть сериализуемыми</remarks>
    public abstract class ThreadWorkerTemplate : DisposableTemplate
    {
        #region Private

        private int _threadFlag;
        private readonly Thread _thread;

        /// <summary>
        /// Обработчик потока
        /// </summary>
        private void ThreadHandler()
        {
            // Здесь реализуем пользовательскую задержку, вместо Thread.Sleep(), так как она позволит отреагировать на команду завершения работы
            DateTime lastExecuted = DateTime.MinValue;
            Func<bool> isAllowed =
                () =>
                {
                    DateTime now = DateTime.Now;
                    bool result = IsNothingDelay() || IsDelaySpended(now, lastExecuted);

                    if (result)
                        lastExecuted = now;

                    // Допустим и 0, то тогда в диспетчере будет показываться 100% загрузка. При этом приложение будет отзываться
                    // Значение 1 задает на самом деле интервал 10-15, то есть менее минимального квантификатора задержки быть не может
                    if (IterationTimespan != -1)
                        Thread.Sleep(1);

                    return result;
                };

            // в цикле осуществляется вызов бизнес-функции 
            while (Interlocked.CompareExchange(ref _threadFlag, 0, 0) == 1)
            {
                if (isAllowed())
                    WorkFunction();
            }
        }

        /// <summary>
        /// Проверка, прошел ли минимальный интервал времени между итерациями
        /// </summary>
        /// <param name="now"></param>
        /// <param name="lastExecuted"></param>
        /// <returns></returns>
        /// <remarks>задержка не менее заданного интервала времени</remarks>
        private bool IsDelaySpended(DateTime now, DateTime lastExecuted)
        {
            return (now > lastExecuted) // учет коррекции времени ntp-сервисом
                   &&
                   (now - lastExecuted).TotalMilliseconds > IterationTimespan;
        }

        /// <summary>
        /// Проверка на наличие задержки
        /// </summary>
        /// <remarks>-1 означает отсутствие какой-либо задержки</remarks>
        private bool IsNothingDelay()
        {
            return IterationTimespan == -1;
        }

        #endregion

        #region .ctor/dispose/finalize

        protected ThreadWorkerTemplate(int timeout) : this(timeout, new TimeSpan(0, 0, 0, 10)) { }

        protected ThreadWorkerTemplate(int timeout, TimeSpan joinTimeout, ApartmentState apartmentState = ApartmentState.Unknown)
        {
            IterationTimespan = timeout;
            JoinTimeout = joinTimeout;

            _threadFlag = 0;
            _thread = new Thread(ThreadHandler);
            _thread.SetApartmentState(apartmentState);
        }

        #endregion

        #region Invocators

        private void InvokeOnStart(StartArgs e)
        {
            EventHandler<StartArgs> handler = OnStart;
            if (handler != null) handler(this, e);
        }

        private void InvokeOnStop(StopArgs e)
        {
            EventHandler<StopArgs> handler = OnStop;
            if (handler != null) handler(this, e);
        }

        #endregion

        #region Events

        /// <summary>
        /// Событие, возникающее при старте обработки метода
        /// </summary>
        public event EventHandler<StartArgs> OnStart;

        /// <summary>
        /// Событие, возникающее при останове обработки метода
        /// </summary>
        public event EventHandler<StopArgs> OnStop;

        #endregion

        #region Management

        /// <summary>
        /// Старт запуска метода в отдельном потоке
        /// </summary>
        public void Start()
        {
            bool oldState = !IsStarted;

            // стартуем с одновременным измененем флага
            if (Interlocked.CompareExchange(ref _threadFlag, 1, 0) == 0)
                _thread.Start();

            InvokeOnStart(new StartArgs(oldState));
        }

        /// <summary>
        /// Останов обработки метода в отдельном потоке
        /// </summary>
        public void Stop()
        {
            bool oldState = IsStarted;
            bool exitByTimeout = false;

            // стопаем с одновременным измененем флага
            if (Interlocked.CompareExchange(ref _threadFlag, 0, 1) == 1)
                exitByTimeout = !_thread.Join(JoinTimeout);

            InvokeOnStop(new StopArgs(oldState, exitByTimeout));
        }

        #endregion

        #region For overrite

        /// <summary>
        /// Метод, который должен исполняться в отдельном потоке.
        /// </summary>
        protected abstract void WorkFunction();

        #endregion

        #region Properties

        /// <summary>
        /// Флаг, показывающий текущее состояние ThreadWorker (запущен или нет)
        /// </summary>
        public bool IsStarted
        {
            get { return Interlocked.CompareExchange(ref _threadFlag, 0, 0) == 1; }
        }

        /// <summary>
        /// Интервал времени, после которого прекращается номмальное завершение потока испольнения метода <see cref="WorkFunction"/>
        /// </summary>
        public TimeSpan JoinTimeout { get; private set; }

        /// <summary>
        /// Минимальный интервал времени между вызовами метода <see cref="WorkFunction"/>
        /// </summary>
        public int IterationTimespan { get; private set; }

        #endregion
    }
}