using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using CyberX8_RT.Modules;
using CyberX8_RT.Modules.Reservoir;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.IOCore;
using MECF.Framework.Common.ToolLayout;
using MECF.Framework.Common.TwinCat;
using System.Collections.Generic;
using System.Reflection;

namespace CyberX8_RT.Devices.Reservoir
{
    public class TotalReservoirDevice : BaseDevice, IDevice
    {
        #region 常量 
        private const string DIREPLEN_FLOW = "DiReplenFlow";

        private const string COUNTER_VALUE = "CounterValue";
        private const string COUNTER_START = "Start";
        private const string COUNTER_STOP = "Stop";
        private const string COUNTER_RESET = "Reset";

        private const string EVAPORATOR_LEVEL = "EvaporatorLevel";
        private const string HIGH_LEVEL = "HighLevel";
        private const string STRATUS = "Stratus";
        #endregion
        #region 内部变量
        /// <summary>
        /// Di Replen Flow
        /// </summary>
        private CounterFlowData _diReplenFlow = new CounterFlowData();
        /// <summary>
        /// High Level
        /// </summary>
        private bool _highLevel;
        /// <summary>
        /// Evaporator Level
        /// </summary>
        private bool _evaporatorLevel;
        /// <summary>
        /// Counter字典
        /// </summary>
        private Dictionary<string, CounterFlowData> _nameCounterFlowData = new Dictionary<string, CounterFlowData>();
        /// <summary>
        /// 定时器
        /// </summary>
        private PeriodicJob _period;
        /// <summary>
        /// DiReplen Warning Dictionary
        /// </summary>      
        private Dictionary<string, bool> _diReplenWarnDic = new Dictionary<string, bool>() {
            {"Reservoir1", false},
            {"Reservoir2", false},
            {"Reservoir3", false},
            {"Reservoir4", false},
        };
        #endregion
        #region 属性
        /// <summary>
        /// Di Replen Flow
        /// </summary>
        private CounterFlowData DiReplenFlow { get { return _diReplenFlow; } }
        /// <summary>
        /// High Level
        /// </summary>
        public bool HighLevel { get { return _highLevel; } }
        /// <summary>
        /// Evaporator Level
        /// </summary>
        public bool EvaporatorLevel { get { return _evaporatorLevel; } }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="moduleName"></param>
        /// <param name="name"></param>
        public TotalReservoirDevice() : base("Reservoir", "Reservoir", "Reservoir", "Reservoir")
        {
            _period = new PeriodicJob(500, OnTimer, "Reservoir.OnTimer", true, true);
        }
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        public bool Initialize()
        {
            InitializeParameter();
            SubscribeValueAction();
            InitializeOperation();
            return true;
        }
        /// <summary>
        /// 加载参数
        /// </summary>
        private void InitializeParameter()
        {

        }
        /// <summary>
        /// 初始化操作
        /// </summary>
        private void InitializeOperation()
        {
        }
        /// <summary>
        /// 订阅变量数值发生变化
        /// </summary>
        private void SubscribeValueAction()
        {
            BeckhoffCounterSubscribeUpdateVariable(DIREPLEN_FLOW, DiReplenFlow);
            BeckhoffIoSubscribeUpdateVariable(EVAPORATOR_LEVEL);
            BeckhoffIoSubscribeUpdateVariable(HIGH_LEVEL);
        }


        /// <summary>
        /// 订阅Counter变量
        /// </summary>
        /// <param name="variable"></param>
        private void BeckhoffCounterSubscribeUpdateVariable(string variable, CounterFlowData counterFlowData)
        {
            _nameCounterFlowData[$"{Module}.{variable}"] = counterFlowData;
            BeckhoffCounterManager.Instance.SubscribeModuleVariable($"{Module}.{variable}", COUNTER_VALUE, UpdateCounterVariableValue);
            BeckhoffCounterManager.Instance.SubscribeModuleVariable($"{Module}.{variable}", COUNTER_START, UpdateCounterVariableValue);
            BeckhoffCounterManager.Instance.SubscribeModuleVariable($"{Module}.{variable}", COUNTER_STOP, UpdateCounterVariableValue);
            BeckhoffCounterManager.Instance.SubscribeModuleVariable($"{Module}.{variable}", COUNTER_RESET, UpdateCounterVariableValue);
        }

        /// <summary>
        /// 订阅IO变量
        /// </summary>
        /// <param name="variable"></param>
        private void BeckhoffIoSubscribeUpdateVariable(string variable)
        {
            IOModuleManager.Instance.SubscribeModuleVariable(Module, variable, UpdateIOVariableValue);
        }

        /// <summary>
        /// 更新变量数值
        /// </summary>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        private void UpdateIOVariableValue(string variable, object value)
        {
            if (variable == HIGH_LEVEL)
            {
                _highLevel = (bool)value;
            }
            else if (variable == EVAPORATOR_LEVEL)
            {
                _evaporatorLevel = (bool)value;
            }
        }
        /// <summary>
        /// 更新变量数值
        /// </summary>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        private void UpdateCounterVariableValue(string variable, object value)
        {
            string[] strAry = variable.Split('.');
            string lastVariable = strAry[strAry.Length - 1];
            PropertyInfo property = null;
            string key = variable.Replace($".{lastVariable}", "");
            if (_nameCounterFlowData.ContainsKey(key))
            {
                CounterFlowData counterFlowData = _nameCounterFlowData[key];
                property = counterFlowData.GetType().GetProperty(lastVariable);
                if (property != null)
                {
                    property.SetValue(counterFlowData, value);
                }
            }
        }
        /// <summary>
        /// 定时器
        /// </summary>
        /// <returns></returns>
        private bool OnTimer()
        {
            List<string> reservoirs = ReservoirItemManager.Instance.InstalledModules;
            foreach (string module in reservoirs)
            {
                ReservoirItem reservoirItem = ReservoirItemManager.Instance.GetReservoirItem(module);
                ReservoirEntity reservoirEntity = Singleton<RouteManager>.Instance.GetModule<ReservoirEntity>(module);
                if (reservoirEntity != null && !reservoirEntity.IsError)
                {
                    if (reservoirItem.SubType == STRATUS)
                    {
                        StandardHotReservoirDevice reservoirDevice = DEVICE.GetDevice<StandardHotReservoirDevice>(module);
                        if (!reservoirEntity.IsInitialized || reservoirDevice.DiReplenMaxTimeOut
                            || reservoirDevice.IsDireplenOn || reservoirDevice.IsDiReplenInFault)
                        {
                            continue;
                        }
                        if (reservoirDevice.NeedAutoDireplen)
                        {
                            if (!CheckFacilityDiReplenOn(reservoirDevice.TotalDIReplenOn, module))
                            {
                                continue;
                            }
                            reservoirDevice.AutoDireplen();
                        }
                    }
                }
                else
                {
                    continue;
                }
            }
            return true;
        }
        private bool CheckFacilityDiReplenOn(bool diReplenOn, string module)
        {
            if (!diReplenOn)
            {
                if (!_diReplenWarnDic[module])
                {
                    _diReplenWarnDic[module] = true;
                    LOG.WriteLog(eEvent.WARN_RESERVOIR, module, $"SystemFacility DIReplen is off, {module} can't do auto DIReplen");
                }
                return false;
            }
            else
            {
                _diReplenWarnDic[module] = false;
                return true;
            }
        }
        public void Monitor()
        {
        }

        public void Reset()
        {
        }

        public void Terminate()
        {
            _period.Stop(false);
        }
    }
}