using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.Util;
using MECF.Framework.Common.Beckhoff.ModuleIO;
using MECF.Framework.Common.CommonData.Prewet;
using MECF.Framework.Common.CommonData.Vpw;
using MECF.Framework.Common.IOCore;
using MECF.Framework.Common.Persistent.SRD;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace PunkHPX8_RT.Devices.VpwCell
{
    public class VpwCellDevice : BaseDevice, IDevice
    {
        #region 常量 
        private const string COMMON_DATA = "CommonData";
        private const string DIW_FLOW = "DiwFlow";
        private const string VACUUM_PRESSURE = "VacuumPressure";
        private const string FLOW_DRIP = "FlowDrip";
        private const string FLOW_SMALL = "FlowSmall";
        private const string FLOW_LARGE = "FlowLarge";
        private const string VACUUM_VALVE = "VacuumValve";
        private const string VENT_VALVE = "VentValve";
        private const string DIW_DRAIN = "DiwDrain";
        #endregion

        #region 内部变量
        /// <summary>
        /// 变量是否初始化字典
        /// </summary>
        private Dictionary<string, bool> _variableInitializeDic = new Dictionary<string, bool>();
        /// <summary>
        /// 数据
        /// </summary>
        private VpwCellCommonData _commonData;
        #endregion

        #region 属性
        /// <summary>
        /// 数据
        /// </summary>
        public VpwCellCommonData CommonData { get { return _commonData; } }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="moduleName"></param>
        public VpwCellDevice(string moduleName) : base(moduleName, moduleName, moduleName, moduleName)
        {

        }

        #region 初始化
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        public bool Initialize()
        {
            InitializeParameter();
            InitializeRoutine();
            SubscribeData();
            SubscribeValueAction();
            InitializeOperation();
            return true;
        }
        /// <summary>
        /// 初始化参数
        /// </summary>
        private void InitializeParameter()
        {
        }
        /// <summary>
        /// 初始化Routine
        /// </summary>
        private void InitializeRoutine()
        {

        }
        /// <summary>
        /// 订阅
        /// </summary>
        private void SubscribeData()
        {
            DATA.Subscribe($"{Module}.{COMMON_DATA}", () => CommonData, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 订阅数据
        /// </summary>
        private void SubscribeValueAction()
        {
            IoSubscribeUpdateVariable(DIW_FLOW);
            IoSubscribeUpdateVariable(DIW_DRAIN);
            IoSubscribeUpdateVariable(VACUUM_PRESSURE);
            IoSubscribeUpdateVariable(VACUUM_VALVE);
            IoSubscribeUpdateVariable(VENT_VALVE);
            IoSubscribeUpdateVariable(FLOW_DRIP);
            IoSubscribeUpdateVariable(FLOW_LARGE);
            IoSubscribeUpdateVariable(FLOW_SMALL);
        }
        /// <summary>
        /// 初始化变量
        /// </summary>
        /// <param name="variable"></param>
        private void IoSubscribeUpdateVariable(string variable)
        {
            _variableInitializeDic[variable] = false;
            IOModuleManager.Instance.SubscribeModuleVariable(Module, variable, UpdateVariableValue);
        }

        /// <summary>
        /// 更新变量数值
        /// </summary>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        private void UpdateVariableValue(string variable, object value)
        {
            PropertyInfo property = _commonData.GetType().GetProperty(variable);
            if (property != null)
            {
                property.SetValue(_commonData, value);
            }
            if (_variableInitializeDic.ContainsKey(variable) && !_variableInitializeDic[variable])
            {
                _variableInitializeDic[variable] = true;
            }
        }
        /// <summary>
        /// 初始化OP
        /// </summary>
        private void InitializeOperation()
        {
            OP.Subscribe($"{Module}.FlowDripOn", (cmd,para)=> { return FlowDripOn(); });
            OP.Subscribe($"{Module}.FlowDripOff", (cmd, para) => { return FlowDripOff(); });
            OP.Subscribe($"{Module}.FlowSmallOn", (cmd, para) => { return FlowSmallOn(); });
            OP.Subscribe($"{Module}.FlowSmallOff", (cmd, para) => { return FlowSmallOff(); });
            OP.Subscribe($"{Module}.FlowLargeOn", (cmd, para) => { return FlowLargeOn(); });
            OP.Subscribe($"{Module}.FlowLargeOff", (cmd, para) => { return FlowLargeOff(); });
            OP.Subscribe($"{Module}.VentValveOn", (cmd, para) => { return VentValveOn(); });
            OP.Subscribe($"{Module}.VentValveOff", (cmd, para) => { return VentValveOff(); });
            OP.Subscribe($"{Module}.DrainValveOn", (cmd, para) => { return DrainValveOn(); });
            OP.Subscribe($"{Module}.DrainValveOff", (cmd, para) => { return DrainValveOff(); });
            OP.Subscribe($"{Module}.VacuumValveOn", (cmd, para) => { return VacuumValveOn(); });
            OP.Subscribe($"{Module}.VacuumValveOff", (cmd, para) => { return VacuumValveOff(); });

        }
        #endregion

        #region Action


        #region Flow
        /// <summary>
        /// Flow Drip on
        /// </summary>
        /// <returns></returns>
        public bool FlowDripOn()
        {
            return WriteVariableValue(FLOW_DRIP, true);
        }
        /// <summary>
        /// Flow Drip Off
        /// </summary>
        /// <returns></returns>
        public bool FlowDripOff()
        {
            return WriteVariableValue(FLOW_DRIP, false);
        }
        /// <summary>
        /// Flow Small On
        /// </summary>
        /// <returns></returns>
        public bool FlowSmallOn()
        {
            return WriteVariableValue(FLOW_SMALL, true);
        }
        /// <summary>
        /// Flow Small Off
        /// </summary>
        /// <returns></returns>
        public bool FlowSmallOff()
        {
            return WriteVariableValue(FLOW_SMALL, false);
        }
        /// <summary>
        /// Flow Large On
        /// </summary>
        /// <returns></returns>
        public bool FlowLargeOn()
        {
            return WriteVariableValue(FLOW_LARGE, true);
        }
        /// <summary>
        /// Flow Large Off
        /// </summary>
        /// <returns></returns>
        public bool FlowLargeOff()
        {
            return WriteVariableValue(FLOW_LARGE, false);
        }
        #endregion

        /// <summary>
        /// Vent Valve On
        /// </summary>
        /// <returns></returns>
        private bool VentValveOn()
        {
            return WriteVariableValue(VENT_VALVE, true);
        }
        /// <summary>
        /// Vent Valve Off
        /// </summary>
        /// <returns></returns>
        private bool VentValveOff()
        {
            return WriteVariableValue(VENT_VALVE, false);
        }
        /// <summary>
        /// Vent Valve On
        /// </summary>
        /// <returns></returns>
        private bool DrainValveOn()
        {
            return WriteVariableValue(DIW_DRAIN, true);
        }
        /// <summary>
        /// Vent Valve Off
        /// </summary>
        /// <returns></returns>
        private bool DrainValveOff()
        {
            return WriteVariableValue(DIW_DRAIN, false);
        }
        /// <summary>
        /// Vacuum valve on
        /// </summary>
        /// <returns></returns>
        private bool VacuumValveOn()
        {
            return WriteVariableValue(VACUUM_VALVE, true);
        }
        /// <summary>
        /// Vacuum valve off
        /// </summary>
        /// <returns></returns>
        private bool VacuumValveOff()
        {
            return WriteVariableValue(VACUUM_VALVE, false);
        }

        /// <summary>
        /// 写变量
        /// </summary>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        private bool WriteVariableValue(string variable, object value)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{variable}");
            return IOModuleManager.Instance.WriteIoValue(ioName, value);
        }



        #endregion

        /// <summary>
        /// 监控
        /// </summary>
        public void Monitor()
        {
        }

        public void Reset()
        {
        }

        public void Terminate()
        {
        }
    }
}