using Bro.Common.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Bro.Common.Helper;
using System.Reflection;
using Newtonsoft.Json;
using System.Threading;
using System.Diagnostics;
using System.Dynamic;
using System.Linq.Expressions;
//using BroCComn.PubSub;
using static Bro.Common.Helper.EnumHelper;
using System.ComponentModel;

namespace Bro.Common.Base
{
    //public delegate void DeviceStateChangedDelegate(EnumHelper.DeviceState initialState);
    public abstract class DeviceBase : IDevice, IDisposable
    {
        #region Event
        [JsonIgnore]
        public Action<IDevice, Exception> OnDeviceException { get; set; }
        [JsonIgnore]
        public Action<DateTime, IDevice, string> OnLog { get; set; }
        [JsonIgnore]
        public Action<EnumHelper.DeviceState> OnDeviceStateChanged { get; set; }
        #endregion


        int RetryTime = 3;
        /// <summary>
        /// 和设备暂停状态关联的信号量
        /// </summary>
        private ManualResetEvent pauseHandle = new ManualResetEvent(true);

        Timer stateChangedTimer;

        internal bool stateChangedFlag = false;

        private EnumHelper.DeviceState _currentStateToBe = EnumHelper.DeviceState.DSUninit;
        /// <summary>
        /// 当前设备状态
        /// </summary>
        [JsonIgnore]
        internal EnumHelper.DeviceState CurrentStateToBe
        {
            get
            {
                return _currentStateToBe;
            }
            set
            {
                if (value != _currentStateToBe)
                {
                    var initialState = _currentStateToBe;
                    _currentStateToBe = value;

                    if (_currentStateToBe != EnumHelper.DeviceState.DSExcept)
                    {
                        OnStateChanged(initialState);
                    }
                    else
                    {
                        stateChangedTimer.Change(Timeout.Infinite, Timeout.Infinite);
                    }
                }
            }
        }

        private EnumHelper.DeviceState initialState = EnumHelper.DeviceState.DSUninit;
        private EnumHelper.DeviceState _currentState = EnumHelper.DeviceState.DSUninit;
        public EnumHelper.DeviceState CurrentState
        {
            get
            {
                return _currentState;
            }
            set
            {
                _currentState = value;

                if (value != EnumHelper.DeviceState.TBD)
                {
                    OnDeviceStateChanged?.Invoke(initialState);
                    OnDeviceStateChangedWithDeviceInfo?.Invoke(this, _currentState);
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("CurrentState"));
                }
                else
                {
                    initialState = _currentState;
                }
            }
        }

        /// <summary>
        /// 设备状态 编辑时或者运行时
        /// </summary>
        public EnumHelper.DeviceMode DeviceMode { get; set; } = EnumHelper.DeviceMode.Edit;

        /// <summary>
        /// 设备标识符 从数据库获取
        /// </summary>
        public string Id { get; set; }

        /// <summary>
        /// 设备名称 从数据库获取
        /// </summary>
        public string Name { get; set; }

        private IInitialConfig initialConfig = null;
        /// <summary>
        /// 设备初始化配置 从数据库获取
        /// </summary>
        public virtual IInitialConfig InitialConfig
        {
            get => initialConfig;
            set
            {
                initialConfig = value;
                this.Id = initialConfig.ID;
                this.Name = initialConfig.Name;
            }
        }

        #region IPorcessId
        /// <summary>
        /// 设备当前执行工序编号
        /// </summary>
        [JsonIgnore]
        public string ProcessId { get; set; }

        /// <summary>
        /// 设备当前执行工序名称
        /// </summary>
        [JsonIgnore]
        public string ProcessName { get; set; }
        #endregion

        [JsonIgnore]
        public Dictionary<DeviceOutputMethodAttribute, MethodInfo> OutputMethods { get; set; } = new Dictionary<DeviceOutputMethodAttribute, MethodInfo>();
        #region 延迟加载方法字典方式 现转移到构造函数中实现
        //{
        //    get
        //    {
        //        if (outputMethods == null)
        //        {
        //            this.GetType().GetMethods().ToList().ForEach(m =>
        //            {
        //                var attr = m.GetCustomAttribute<DeviceOutputMethodAttribute>();
        //                if (attr != null)
        //                {
        //                    outputMethods[attr.MethodName] = m;
        //                }
        //            });
        //        }

        //        return outputMethods;
        //    }
        //    set
        //    {
        //        outputMethods = value;
        //    }
        //}
        #endregion

        [JsonIgnore]
        public Dictionary<DeviceInputMethodAttribute, MethodInfo> InputMethods { get; set; } = new Dictionary<DeviceInputMethodAttribute, MethodInfo>();



        //public event DeviceStateChangedDelegate OnDeviceStateChanged;

        public DeviceBase()
        {
            //预先获取所有设备输出方法
            this.GetType().GetMethods().ToList().ForEach(m =>
            {
                var attrOut = m.GetCustomAttribute<DeviceOutputMethodAttribute>();
                if (attrOut != null)
                {
                    OutputMethods[attrOut] = m;
                }

                var attrIn = m.GetCustomAttribute<DeviceInputMethodAttribute>();
                if (attrIn != null)
                {
                    InputMethods[attrIn] = m;
                }
            });


            stateChangedTimer = new Timer(new TimerCallback(CheckDeviceOpTimeOut), null, Timeout.Infinite, Timeout.Infinite);

            //StateMachine.OnUserLogin = OnCurrentUserLogin;
        }

        protected abstract void Init();

        protected abstract void Pause();

        protected abstract void Resume();

        protected abstract void Start();

        protected abstract void Stop();

        public virtual void Dispose()
        {

        }

        object OpLock = new Object(); //操作锁，一个设备，一次只能做一个动作

        public event DeviceStateChangedDelegate OnDeviceStateChangedWithDeviceInfo;
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// 设备Run之前工序进入Running状态，设备Run完成之后工序进入Done状态
        /// 发生异常时，设备和工序都进入异常状态
        /// 考虑使用AOP切面实现前后状态变化
        /// </summary>
        /// <param name="config"></param>
        /// <returns></returns>
        [DeviceExceptionAspect]
        [DeviceRunAspect]
        public virtual IOperationConfig SetAndRun(IOperationConfig config)
        {
            //try
            //{
            //lock (OpLock)
            //{
            //if (string.IsNullOrWhiteSpace(config.ProcessId))
            //{
            //    DeviceMode = EnumHelper.DeviceMode.Edit;
            //}
            //else
            //{
            //    DeviceMode = EnumHelper.DeviceMode.Run;

            //    ProcessId = config.ProcessId;
            //    ProcessName = config.ProcessName;
            //}

            //pauseHandle.WaitOne();
            //if (config.DeviceConfig != null)
            //{
            //    DeviceSet(config.DeviceConfig);
            //}

            //bool inputFlag = false;
            //do
            //{
            //    pauseHandle.WaitOne();
            //    inputFlag = DeviceInput(config);
            //} while (!inputFlag);

            //if (CurrentState != EnumHelper.DeviceState.DSOpen)
            //{
            //    return null;
            //}

            pauseHandle.WaitOne();

            if (config.IsEnabled)
            {
                DeviceRun(config);
            }
            pauseHandle.WaitOne();
            IOperationConfig output = DeviceOutput(config);

            //config.InputConfig?.Dispose();

            return output;
            //}
            //catch (Exception ex)
            //{
            //    return null;            
            //}
            //}
        }

        /// <summary>
        /// 根据设备配置信息配置设备参数
        /// </summary>
        /// <param name="config"></param>
        protected abstract void DeviceSet(IDeviceConfig config);

        protected virtual bool DeviceInput(IOperationConfig config)
        {
            ////如果需要设备输入配置判断
            //if (config.InputConfig != null && config.InputConfig.IsInputNeed)
            //{
            //    //config.InputConfig.BoundFlag = true;
            //    //等待输入配置信号量
            //    //config.InputConfig.InputHanlderDict[config.ProcessId]?.WaitOne();
            //    //while (config.InputConfig.InputFlagDict[config.ProcessId] == false && CurrentState == EnumHelper.DeviceState.DSOpen)
            //    //{
            //    //    Thread.Sleep(10);
            //    //}

            //    //config.InputConfig.InputFlagDict[config.ProcessId] = false;

            //    config.InputConfig.InputHandle.WaitOne();
            //    //Debug.WriteLine(DateTime.Now.ToString("mm:ss.fff") + "\t输入完成，编号：" + config.InputConfig.ProcessId);

            //    if (CurrentState != EnumHelper.DeviceState.DSOpen)
            //    {
            //        return true;
            //    }

            //    //config.InputConfig.InputHanlderDict[config.ProcessId].Reset();

            //    if (!string.IsNullOrWhiteSpace(config.InputConfig.InputMethodName))
            //    {
            //        var attr = InputMethods.Keys.FirstOrDefault(u => u.MethodName == config.InputConfig.InputMethodName);
            //        if (attr != null)
            //        {
            //            return Convert.ToBoolean(InputMethods[attr].Invoke(this, new object[] { config }));
            //        }
            //        else
            //        {
            //            //throw new UserException(string.Format("未能获取{0}的方法信息！", config.InputConfig.InputMethodName), EnumHelper.LogType.Exception_Fatal);
            //            throw new Exception(string.Format("未能获取{0}的方法信息！", config.InputConfig.InputMethodName));
            //        }
            //    }
            //}

            return true;
        }

        /// <summary>
        /// 设备运行
        /// </summary>
        /// <param name="config"></param>
        protected abstract void DeviceRun(IOperationConfig config);

        /// <summary>
        /// 具体的输出方法返回IOperationConfig，必须包括ProcessId和ResultOutput
        /// </summary>
        /// <param name="config"></param>
        /// <returns></returns>
        protected virtual IOperationConfig DeviceOutput(IOperationConfig config)
        {
            //if (string.IsNullOrWhiteSpace(config.OutputMethodName))
            //{
            return null;
            //}
            //else
            //{
            //    #region 实时获取输出方法 考虑到效率问题，将方法字典转移到构造函数中实现
            //    //var methodInfo = this.GetType().GetMethods().FirstOrDefault(m =>
            //    //  {
            //    //      var attr = m.GetCustomAttribute<DeviceOutputMethodAttribute>();

            //    //      return attr != null && attr.MethodName == config.OutputMethodName;
            //    //  });

            //    //if (methodInfo == null)
            //    //{
            //    //    throw new UserException(string.Format("未能获取{0}的方法信息！", config.OutputMethodName));
            //    //}
            //    //else
            //    //{
            //    //    return (methodInfo.Invoke(this, new object[] { config })) as IOperationConfig;
            //    //}
            //    #endregion

            //    var attr = OutputMethods.Keys.FirstOrDefault(u => u.MethodName == config.OutputMethodName);
            //    if (attr != null)
            //    {
            //        return (OutputMethods[attr].Invoke(this, new object[] { config })) as IOperationConfig;
            //    }
            //    else
            //    {
            //        //throw new UserException(string.Format("未能获取{0}的方法信息！", config.OutputMethodName), EnumHelper.LogType.Exception_Fatal);
            //        throw new Exception(string.Format("未能获取{0}的方法信息！", config.OutputMethodName));
            //    }
            //}
        }

        [DeviceExceptionAspect]
        public void StateChange(EnumHelper.DeviceState stateToBe)
        {
            if (CurrentState == stateToBe)
            {
                return;
            }

            if (!stateToBe.CheckPreStateValid((int)CurrentStateToBe))
            {
                string currentStateStr = CurrentStateToBe.GetEnumDescription();
                string stateToBeStr = stateToBe.GetEnumDescription();
                throw new ProcessException($"{InitialConfig.Name}设备的当前状态为{currentStateStr}，无法切换至{stateToBeStr}", null);
            }

            CurrentState = EnumHelper.DeviceState.TBD;
            CurrentStateToBe = stateToBe;
        }

        [DeviceStateChangedAspect]
        [DeviceExceptionAspect]
        private void OnStateChanged(EnumHelper.DeviceState initialState)
        {
            try
            {
                if (CurrentStateToBe != EnumHelper.DeviceState.DSExcept)
                {
                }
                else
                {
                    if (CurrentState == EnumHelper.DeviceState.DSExcept)
                    {
                        return;
                    }
                    else
                    {
                        throw new ProcessException($"{InitialConfig.Name}设备操作超时", null);
                    }
                }

                if (RetryTime >= 0)
                {
                    if (initialState == CurrentStateToBe)
                    {
                        CurrentState = CurrentStateToBe;
                        return;
                    }

                    #region 状态切换操作
                    switch (CurrentStateToBe)
                    {
                        case EnumHelper.DeviceState.DSInit:
                            if (initialState == EnumHelper.DeviceState.DSOpen)
                            {
                                return;
                            }
                            else
                            {
                                Init();
                            }
                            break;
                        case EnumHelper.DeviceState.DSOpen:
                            if (initialState == EnumHelper.DeviceState.DSInit)
                            {
                                Start();
                            }
                            else if (initialState == EnumHelper.DeviceState.DSPause)
                            {
                                Resume();
                                pauseHandle.Set();
                            }
                            break;
                        case EnumHelper.DeviceState.DSPause:
                            pauseHandle.Reset();
                            Pause();
                            break;
                        case EnumHelper.DeviceState.DSClose:
                            if (initialState != DeviceState.DSUninit)
                            {
                                Stop();
                            }
                            break;
                        default:
                            break;
                    }

                    RetryTime = 3;
                    CurrentState = CurrentStateToBe;
                    #endregion
                }

                stateChangedTimer.Change(Timeout.Infinite, Timeout.Infinite);
            }
            catch (Exception ex)
            {
                RetryTime--;
                if (RetryTime > 0)
                {
                    OnStateChanged(initialState);
                }
                else
                {

                    if (this.CurrentState != EnumHelper.DeviceState.DSExcept)
                    {
                        //this.CurrentState = EnumHelper.DeviceState.DSExcept;
                        //this.CurrentStateToBe = EnumHelper.DeviceState.DSExcept;

                        throw new ProcessException($"设备{InitialConfig.Name}的{CurrentStateToBe.GetEnumDescription()}操作重复3次失败", ex);
                    }
                }
            }
        }

        [DeviceExceptionAspect]
        private void CheckDeviceOpTimeOut(object state)
        {
            stateChangedTimer?.Change(Timeout.Infinite, Timeout.Infinite);

            if (CurrentState != EnumHelper.DeviceState.DSExcept)
            {
                StateChange(EnumHelper.DeviceState.DSExcept);
            }
        }

        #region 用户信息
        [JsonIgnore]
        public string CurrentUserId { get; set; }

        private void OnCurrentUserLogin(string obj)
        {
            CurrentUserId = obj;
        }
        #endregion
    }
}