using System;
using System.Collections.Concurrent;
using System.Threading;

namespace Base
{
    public class WaitQueue<T> : IDisposable where T : class
    {
        /// <summary>
        /// The deal action.
        /// </summary>
        public Action<T> DealAction { get; set; }

        /// <summary>
        /// The inner queue.
        /// </summary>
        private readonly ConcurrentQueue<T> _innerQueue;

        /// <summary>
        /// The deal thread.
        /// </summary>
        private readonly Thread dealThread;

        /// <summary>
        /// The flag for end thread.
        /// </summary>
        private bool endThreadFlag = false;

        /// <summary>
        /// The auto reset event.
        /// </summary>
        private readonly AutoResetEvent autoResetEvent = new AutoResetEvent(true);

        /// <summary>
        /// Initializes a new instance of the WaitQueue`1 class.
        /// </summary>
        public WaitQueue()
        {
            this._innerQueue = new ConcurrentQueue<T>();
            this.dealThread = new Thread(this.DealQueue);
            this.dealThread.Start();
        }

        /// <summary>
        /// Disposes current instance, end the deal thread and inner queue.
        /// </summary>
        public void Dispose()
        {
            this.endThreadFlag = true;
            this._innerQueue.Enqueue(null);
            this.autoResetEvent.Set();
            this.dealThread.Join();
            this.autoResetEvent.Close();
        }

        /// <summary>
        /// Save entity to Queue.
        /// </summary>
        /// <param name="entity">The entity what will be deal.</param>
        public void SaveLog(T entity)
        {
            this._innerQueue.Enqueue(entity);
            this.autoResetEvent.Set();
        }

        /// <summary>
        /// Out Queue.
        /// </summary>
        /// <param name="entity">The init entity.</param>
        /// <returns>The entity what will be deal.</returns>
        private bool Dequeue(out T entity)
        {
            return this._innerQueue.TryDequeue(out entity);
        }

        /// <summary>
        /// Deal entity in Queue.
        /// </summary>
        private void DealQueue()
        {
            while (true)
            {
                T entity;
                if (this.Dequeue(out entity))
                {
                    if (this.endThreadFlag && entity == null)
                    {
                        return;   // Exit the deal thread.
                    }

                    try
                    {
                        if (this.DealAction != null)
                        {
                            this.DealAction(entity);
                        }
                    }
                    catch
                    {
                    }
                }
                else
                {
                    this.autoResetEvent.WaitOne();
                }
            }
        }
    }
}