using System.Collections.Generic;
using System.Threading;
using Bro.Common.FSM;
using System.Diagnostics;

namespace Bro.Common.Procedure
{
    /// <summary>
    /// 流程状态
    /// </summary>
    public enum ProcStat
    {
        PSInit = 0,         // 初始化
        PSOpen,             // 打开
        PSRunning,          // 运行
        PSReset,            // 重置,
        PSReseting,         // 重置中
        PSPause,            // 暂停
        PSClose,            // 关闭
        PSFnit              // 销毁
    }

    /// <summary>
    /// 处理流程基类
    /// 
    /// 说明：
    ///     工站，工位类都可继承此类
    /// 定义如下动作
    /// 1. 初始化/销毁
    /// 2. 打开/关闭
    /// 3. 读写
    /// 4. 设置选项
    /// 5. 事件订阅/取消
    /// </summary>
    public abstract class ProcedureBase
    {
        #region 代理定义
        // 状态变化事件
        public delegate void StatChange(ProcedureBase procedure, ProcStat srcStat, ProcStat dstStat);

        #endregion

        #region 常量

        // 线程默认等待时间（单位：毫秒）
        protected const int         DFT_WAIT_INTERVAL = 200;

        #endregion

        #region 事件代理

        // 流程状态变化
        public StatChange StatChangeEvent;

        #endregion

        #region 属性
        // 流程描述
        public string               Desp { get; set; }
        // 流程状态
        public ProcStat             Stat{ get { return curStat; } }

        #endregion

        #region 成员变量

        // 流程状态机
        protected SimpleFSM         procFSM         = new SimpleFSM();
        // 流程状态
        protected ProcStat          curStat         = ProcStat.PSInit;
        // 生产工序同步事件
        protected AutoResetEvent    waitEvent       = new AutoResetEvent(false);
        // 输入队列
        private Queue<IODataBase>   requestQueue    = new Queue<IODataBase>();
        // 输入处理者
        private List<object>        requestHandlers = new List<object>();

        #endregion

        #region 结构体

        public ProcedureBase()
        {
            this.Desp = this.GetType().Name;

            // 设置默认的状态处理者
            AddRequestHandler(this);

            RegistProcFSM();
        }

        public ProcedureBase(SimpleFSM fsm)
        {
            this.Desp    = this.GetType().Name;
            this.procFSM = fsm;

            // 设置默认的状态处理者
            AddRequestHandler(this);

            RegistProcFSM();
        }

        #endregion

        #region 外部接口

        /// <summary>
        /// 暂停流程
        /// </summary>
        public virtual void Pause()
        {
            Trace.TraceInformation("{0} Pause", Desp);

            var req = new ProcStatChangeReq();
            req.TargetStat = ProcStat.PSPause;

            AddRequest(req);

        }

        /// <summary>
        /// 重置流程
        /// </summary>
        public virtual void Reset()
        {
            Trace.TraceInformation("{0} Reset", Desp);

            var req = new ProcStatChangeReq();
            req.TargetStat = ProcStat.PSReset;

            AddRequest(req);
        }

        /// <summary>
        /// 请求处理
        /// </summary>
        /// <param name="input"></param>
        public void AddRequest(IODataBase req)
        {
            if (null == req)
            {
                return;
            }

            lock (requestQueue)
            {
                // 设置输入处理者
                req.Handlers = this.requestHandlers;

                requestQueue.Enqueue(req);
            }
        }

        #endregion

        #region 基础流程状态机

        /// <summary>
        /// 注册基本状态处理
        /// </summary>
        protected virtual bool RegistProcFSM()
        {
            int iRet = 0;

            if ( null == procFSM )
            {
                return false;
            }

            iRet += procFSM.Regist((int)ProcStat.PSInit,            DoInit)     ? 0 : 1;
            iRet += procFSM.Regist((int)ProcStat.PSOpen,            DoOpen)     ? 0 : 1;
            iRet += procFSM.Regist((int)ProcStat.PSClose,           DoClose)    ? 0 : 1;
            iRet += procFSM.Regist((int)ProcStat.PSRunning,         DoRunning)  ? 0 : 1;
            iRet += procFSM.Regist((int)ProcStat.PSReset,           DoReset)    ? 0 : 1;
            iRet += procFSM.Regist((int)ProcStat.PSReseting,        DoReseting) ? 0 : 1;
            iRet += procFSM.Regist((int)ProcStat.PSPause,           DoPause)    ? 0 : 1;
            iRet += procFSM.Regist((int)ProcStat.PSFnit,            DoFnit)     ? 0 : 1;
            
            // 设置初始状态
            SetState(ProcStat.PSInit);

            return (iRet == 0);
        }

        /// <summary>
        /// 初始化
        /// </summary>
       public virtual void DoInit()
        {
            Trace.TraceInformation("{0} DoInit", Desp);

            ClearIOData();

            SetState(ProcStat.PSOpen);
        }

        /// <summary>
        /// 销毁
        /// </summary>
        public virtual void DoFnit()
        {
            Trace.TraceInformation("{0} DoFnit", Desp);
        }

        /// <summary>
        /// 开始
        /// </summary>
        public virtual void DoOpen()
        {
            Trace.TraceInformation("{0} DoOpen", Desp);

            SetState(ProcStat.PSRunning);
        }

        /// <summary>
        /// 停止
        /// </summary>
        public virtual void DoClose()
        {
            Trace.TraceInformation("{0} DoClose", this.GetType().Name);

            SetState(ProcStat.PSFnit);
        }

        /// <summary>
        /// 重置
        /// </summary>
        public virtual void DoReset()
        {
            Trace.TraceInformation("{0} DoReset", this.GetType().Name);

            SetState(ProcStat.PSReseting);
        }

        /// <summary>
        /// 重置中
        /// </summary>
        public virtual void DoReseting()
        {
            Trace.TraceInformation("{0} DoReseting", this.GetType().Name);

            SetState(ProcStat.PSRunning);
        }

        /// <summary>
        /// 暂停
        /// </summary>
        public virtual void DoPause()
        {
            // 等待
            waitEvent.WaitOne(DFT_WAIT_INTERVAL);
        }

        /// <summary>
        /// 就绪
        /// </summary>
        public virtual void DoRunning()
        {
            // TODO:流程就绪，主处理

        }

        #endregion

        #region 请求处理

        /// <summary>
        /// 状态转变请求
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        protected bool HandleRequest(ProcStatChangeReq req)
        {
            Trace.TraceInformation("{0} HandleRequest cur stat:{1} target:{2}", 
                                    Desp, GetStatDesp(Stat), GetStatDesp(req.TargetStat));

            if ( req.TargetStat == Stat )
            {
                Trace.TraceWarning("{0} HandleRequest fail, already in {1}", Desp, GetStatDesp(req.TargetStat));
                return true;
            }

            if ( ProcStat.PSRunning != this.Stat )
            {
                Trace.TraceWarning("{0} not running, can't turn to {1}", Desp, GetStatDesp(req.TargetStat));
                return true;
            }

            SetState(req.TargetStat);

            return true;
        }

        #endregion

        #region 其他方法

        /// <summary>
        /// 运行
        /// </summary>
        public virtual void Run()
        {
            procFSM.Run();

            Routine();
        }

        /// <summary>
        /// 流程每次运行的例程
        /// </summary>
        protected virtual void Routine()
        {
            // 处理请求
            HandleRequests();
        }

        /// <summary>
        /// 设置状态
        /// </summary>
        /// <param name="stat"></param>
        protected internal void SetState(ProcStat stat)
        {
            var srcStat = GetStatDesp(curStat);
            var dstStat = GetStatDesp(stat);
            var tempStat = curStat;

            curStat = stat;

            if (null == procFSM)
            {
                return;
            }

            Trace.TraceInformation("{0} stat [{1}]-->[{2}]", Desp, srcStat, dstStat);

            procFSM.SetStat((int)stat);

            // 通知流程状态变化
            if (null != StatChangeEvent)
            {
                StatChangeEvent(this, tempStat, stat);
            }
        }

        /// <summary>
        /// 设置输入处理者
        /// </summary>
        /// <param name="handler"></param>
        public void AddRequestHandler(object handler)
        {
            requestHandlers.Add(handler);
        }

        /// <summary>
        /// 处理输入
        /// </summary>
        protected void HandleRequests()
        {
            var req = NextReq();
            if ( null == req )
            {
                return;
            }

            Trace.TraceInformation("[{0}] HandleRequest {1} ", Desp, req.GetType().Name);

            // 输入处理派遣
            req.Dispatch();
        }

        /// <summary>
        /// 获取下个输入
        /// </summary>
        /// <returns></returns>
        protected IODataBase NextReq()
        {
            return NextData(requestQueue);
        }

        /// <summary>
        /// 添加数据
        /// </summary>
        /// <param name="data"></param>
        /// <param name="dataQueue"></param>
        protected void AddQueue(IODataBase data, Queue<IODataBase> dataQueue)
        {
            if ( null == data || null == dataQueue )
            {
                return;
            }

            lock(dataQueue)
            {
                dataQueue.Enqueue(data);
            }
        }
        
        /// <summary>
        /// 获取下个数据
        /// </summary>
        /// <param name="dataQueue"></param>
        /// <returns></returns>
        protected IODataBase NextData(Queue<IODataBase> dataQueue)
        {
            IODataBase ioData = null;

            lock(dataQueue)
            {
                if ( dataQueue.Count > 0 )
                {
                    ioData = dataQueue.Dequeue();
                }
            }

            return ioData;
        }

        /// <summary>
        /// 情空输入数据
        /// </summary>
        protected void ClearIOData()
        {
            lock(requestQueue)
            {
                requestQueue.Clear();
            }
        }

        /// <summary>
        /// 获取状态描述
        /// </summary>
        /// <param name="procStat"></param>
        /// <returns></returns>
        private string GetStatDesp(ProcStat procStat)
        {
            var desp = "";

            switch (procStat)
            { 
                case ProcStat.PSInit:
                    desp = "PSInit";
                    break;
                case ProcStat.PSFnit:
                    desp = "PSFnit";
                    break;
                case ProcStat.PSOpen:
                    desp = "PSOpen";
                    break;
                case ProcStat.PSClose:
                    desp = "PSClose";
                    break;
                case ProcStat.PSRunning:
                    desp = "PSRunning";
                    break;
                case ProcStat.PSPause:
                    desp = "PSPause";
                    break;
                case ProcStat.PSReset:
                    desp = "PSReset";
                    break;
                case ProcStat.PSReseting:
                    desp = "PSReseting";
                    break;
                default:
                    desp = "Unknow";
                    break;
            }

            return desp;
        }

        #endregion
    }

}