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();

                }

            }

        }

    }

}