using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading;

using System.Diagnostics;

namespace Manager.Common

{

    public enum EngineResult

    {

        Success,

        FaildAndSuspend,

        FaildWithoutSuspend

    }

    //消息传递引擎

    public class RelayEngine<T>

    {

        private Thread _RelayThread;

        private AutoResetEvent _ItemArriveEvent = new AutoResetEvent(false);

        private ManualResetEvent _ResumeEvent = new ManualResetEvent(true);

        private WaitHandle[] _WaitHandles;

        private bool _Stop = false;

        private LinkedList<T> _Buffer = new LinkedList<T>();

        private Func<T, bool> _RelayFunc;

        private Func<T, EngineResult> _RelayFunc2;

        private Action<Exception> _HandleException;

        public bool IsSuspend = true;

        public RelayEngine(Func<T, bool> relayFunc, Action<Exception> handleException, Func<T, EngineResult> relayFunc2 = null)

        {

            this._WaitHandles = new WaitHandle[] { this._ItemArriveEvent, this._ResumeEvent };

            this._RelayFunc = relayFunc;

            this._RelayFunc2 = relayFunc2;

            this._HandleException = handleException;

            this._RelayThread = new Thread(this.Run) { IsBackground = true };

            this._RelayThread.Start();

            this.IsSuspend = false;

        }

        public void AddItem(T item)

        {

            lock (this)

            {

                this._Buffer.AddLast(item);

            }

            this._ItemArriveEvent.Set();

        }

        public void Suspend()

        {

            this.IsSuspend = true;

            this._ResumeEvent.Reset();

        }

        public void Resume()

        {

            this.IsSuspend = false;

            this._ResumeEvent.Set();

        }

        public void Stop()

        {

            this.IsSuspend = true; //线程挂起

            this._Stop = true;    //线程停止

            this._ItemArriveEvent.Set();

            this._ResumeEvent.Set();

        }

        private void Run()

        {

            try

            {

                while (true)

                {

                    if (this._Buffer.Count == )

                    {

                        WaitHandle.WaitAll(this._WaitHandles);

                    }

                    else

                    {

                        this._ResumeEvent.WaitOne(); //队列没有消息阻塞线程，知道收到信号

                    }

                    if (this._Stop) break;

                    if (this._Buffer.Count > )

                    {

                        T item = this._Buffer.First.Value; //先进先出

                        EngineResult result;

                        if (this._RelayFunc2 == null)

                        {

                            result = this._RelayFunc(item) ? EngineResult.Success : EngineResult.FaildAndSuspend;

                        }

                        else

                        {

                            result = this._RelayFunc2(item);

                        }

                        if (result == EngineResult.Success)

                        {

                            lock (this)

                            {

                                this._Buffer.RemoveFirst();

                            }

                        }

                        else

                        {

                            if (result == EngineResult.FaildAndSuspend) this.Suspend();

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                this._HandleException(ex);

            }

        }

    }

}