using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Test
{
    public class TaskOperator
    {
        private static List<TaskOperatorModel> _taskList = new List<TaskOperatorModel>();
        private static ReaderWriterLockSlim listLock = new ReaderWriterLockSlim();

        /// <summary>
        /// 创建一个循环线程任务
        /// </summary>
        public static bool CreateTaskOne(string taskName, Action action, TaskCreationOptions taskCreationOptions = TaskCreationOptions.None, int milliseconds = 10)
        {
            if (_taskList.Exists(a => a.TaskName == taskName))
            {
                Trace.Assert(false, "Task任务中已存在该名称的任务！");
                return false;
            };

            var taskOperator = new TaskOperatorModel(taskName);
            var task = new Task(async () =>
            {
                while (true)
                {
                    if (taskOperator.Token.IsCancellationRequested)
                    {
                        listLock.EnterWriteLock();
                        _taskList.Remove(taskOperator);
                        listLock.ExitWriteLock();
                        taskOperator.Dispose();
                        taskOperator = null;
                        return;
                    }
                    taskOperator.ResetEvent.WaitOne();

                    /*
                    *
                    * 执行的任务主体
                    *
                    */
                    action();
                    await Task.Delay(milliseconds);
                }
            }, taskCreationOptions);
            task.Start();
            listLock.EnterWriteLock();
            _taskList.Add(taskOperator);
            listLock.ExitWriteLock();
            return true;
        }

        /// <summary>
        /// 暂停一个循环任务
        /// </summary>
        /// <param name="taskName"></param>
        public static void ResetTaskOne(string taskName)
        {
            listLock.EnterReadLock();
            var model = _taskList.FirstOrDefault(a => a.TaskName == taskName);

            if (model == null)
            {
                throw new Exception("Task任务中不存在该名称的任务！");
            }
            listLock.ExitReadLock();
            model.ResetEvent.Reset();
        }

        /// <summary>
        /// 继续一个循环任务
        /// </summary>
        /// <param name="taskName"></param>
        public static void SetTaskOne(string taskName)
        {
            listLock.EnterReadLock();
            var model = _taskList.FirstOrDefault(a => a.TaskName == taskName);
            if (model == null)
            {
                throw new Exception("Task任务中不存在该名称的任务！");
            }
            listLock.ExitReadLock();
            model.ResetEvent.Set();
        }

        /// <summary>
        /// 关闭一个循环线程任务
        /// </summary>
        public static void CloseTaskOne(string taskName, int milliseconds = 10)
        {
            Task.Factory.StartNew(() =>
            {
                Task.Delay(milliseconds);
                listLock.EnterReadLock();
                var model = _taskList.FirstOrDefault(a => a.TaskName == taskName);
                if (model == null)
                {
                    return;
                }
                listLock.ExitReadLock();
                model.TokenSource.Cancel();
            });
        }

        private class TaskOperatorModel : IDisposable
        {
            public TaskOperatorModel(string taskName)
            {
                TaskName = taskName;
                Token = TokenSource.Token;
            }

            /// <summary>
            /// 任务名称
            /// </summary>
            public string TaskName { get; set; }

            public CancellationTokenSource TokenSource { get; set; } = new CancellationTokenSource();

            public CancellationToken Token { get; set; }
            public ManualResetEvent ResetEvent { get; set; } = new ManualResetEvent(true);

            #region IDisposable Support
            private bool disposedValue = false; // 要检测冗余调用

            protected virtual void Dispose(bool disposing)
            {
                if (!disposedValue)
                {
                    if (disposing)
                    {
                        // TODO: 释放托管状态(托管对象)。
                    }

                    // TODO: 释放未托管的资源(未托管的对象)并在以下内容中替代终结器。
                    // TODO: 将大型字段设置为 null。
                    TokenSource.Dispose();
                    ResetEvent.Close();
                    ResetEvent.Dispose();
                    TokenSource = null;
                    ResetEvent = null;

                    disposedValue = true;
                }
            }

            // TODO: 仅当以上 Dispose(bool disposing) 拥有用于释放未托管资源的代码时才替代终结器。
            // ~TaskOperatorModel() {
            //   // 请勿更改此代码。将清理代码放入以上 Dispose(bool disposing) 中。
            //   Dispose(false);
            // }

            // 添加此代码以正确实现可处置模式。
            public void Dispose()
            {
                // 请勿更改此代码。将清理代码放入以上 Dispose(bool disposing) 中。
                Dispose(true);
                // TODO: 如果在以上内容中替代了终结器，则取消注释以下行。
                // GC.SuppressFinalize(this);
            }
            #endregion

        }
    }


}