using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Beckhoff.ModuleIO;
using MECF.Framework.Common.CommonData.Reservoir;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Persistent.Reservoirs;
using MECF.Framework.Common.Persistent.Temperature;
using MECF.Framework.Common.TwinCat;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PunkHPX8_RT.Devices.Reservoir
{
    public class DMReservoirDevice : ReservoirDevice
    {
        #region 常量
        private const string AN_PUMP = "ANPump";
        #endregion
        #region 内部变量
        /// <summary>
        /// 默认泵速
        /// </summary>
        private double _anPumpSpeed = 5000;
        #endregion

        #region 属性
        /// <summary>
        /// 检验阳极是否highlevel
        /// </summary>
        public bool IsANHighLevel { get { return _reservoirData.AnTowerHigh; } }
        /// <summary>
        /// 检验阳极是否lowlevel
        /// </summary>
        public bool IsANLowLevel { get { return _reservoirData.AnTowerLow; } }
        #endregion

        #region Trigger
        /// <summary>
        /// low WaterLevel trigger
        /// </summary>
        private R_TRIG _anWaterLevelLowerTrigger = new R_TRIG();
        /// <summary>
        /// low WaterLevel trigger
        /// </summary>
        private R_TRIG _anWaterLevelHighTrigger = new R_TRIG();
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="moduleName"></param>
        public DMReservoirDevice(string moduleName) : base(moduleName)
        {
        }
        /// <summary>
        /// 订阅变量
        /// </summary>
        protected override void SubscribeValueAction()
        {
            base.SubscribeValueAction();
            IoSubscribeUpdateVariable(AN_DI_REPLEN);
            IoSubscribeUpdateVariable(AN_FLOW);
            IoSubscribeUpdateVariable(AN_PUMP_ENABLE);
            IoSubscribeUpdateVariable(AN_PUMP_SPEED);
            IoSubscribeUpdateVariable(DEGAS_ENABLE);
        }
        /// <summary>
        /// 订阅Operation
        /// </summary>
        protected override void InitializeOperation()
        {
            base.InitializeOperation(); 
            OP.Subscribe($"{Module}.ANPumpEnable", AnPumpOnOperation);
            OP.Subscribe($"{Module}.ANPumpSpeed", ANPumpSpeedOperation);
            OP.Subscribe($"{Module}.ANPumpDisable", AnPumpOffOperation);
            OP.Subscribe($"{Module}.ANIsolationOn", (cmd, para) => { return ANIsolationOn(); });
            OP.Subscribe($"{Module}.ANIsolationOff", (cmd, para) => { return ANIsolationOff(); });
        }

        #region AnPump
        /// <summary>
        /// AN Pump调速
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool ANPumpSpeedOperation(string cmd, object[] args)
        {
            double anMaxPumpSpeed = 0;
            if (SC.ContainsItem("Reservoir.ANMaxPumpSpeed"))
            {
                anMaxPumpSpeed = SC.GetValue<double>("Reservoir.ANMaxPumpSpeed");
            }
            if (double.TryParse(args[0].ToString(), out double speed))
            {
                _anPumpSpeed = speed;
                if (_anPumpSpeed > anMaxPumpSpeed)
                {
                    LOG.WriteLog(eEvent.WARN_RESERVOIR, Module, $"AN pump speed:{_anPumpSpeed} is over AN max pump speed {anMaxPumpSpeed}!");
                    return false;
                }
                return AnPumpSpeed(_anPumpSpeed);
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"{args[0]} is nor invalid speed");
                return false;
            }
        }
        /// <summary>
        /// 设置AN泵速
        /// </summary>
        /// <param name="caPumpSpeed"></param>
        /// <returns></returns>
        public bool AnPumpSpeed(double anPumpSpeed)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{AN_PUMP_SPEED}");
            return BeckhoffIOManager.Instance.WriteIoValue(ioName, anPumpSpeed);
        }
        /// <summary>
        /// 阳极Pump On
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public bool AnPumpOnOperation(string cmd, object[] args)
        {
            double caPumpSpeed = SC.GetValue<double>("Reservoir.ANDefaultPumpSpeed");
            bool result = AnPumpSpeed(caPumpSpeed);
            if (result)
            {
                string enableIOName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{AN_PUMP_ENABLE}");
                return BeckhoffIOManager.Instance.WriteIoValue(enableIOName, true);
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 阳极Pump Off
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool AnPumpOffOperation(string cmd, object[] args)
        {
            return AnPumpOff();
        }
        /// <summary>
        /// 关闭阳极Pump
        /// </summary>
        /// <returns></returns>
        public bool AnPumpOff()
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{AN_PUMP_ENABLE}");
            return BeckhoffIOManager.Instance.WriteIoValue(ioName, false);
        }
        /// <summary>
        /// ANIsolationOn
        /// </summary>
        /// <returns></returns>
        public bool ANIsolationOn()
        {
            return WriteVariableValue(AN_ISOLATION, true);
        }
        /// <summary>
        /// ANIsolationOff
        /// </summary>
        /// <returns></returns>
        public bool ANIsolationOff()
        {
            return WriteVariableValue(AN_ISOLATION, false);
        }
        #endregion

        /// <summary>
        /// 水位监控
        /// </summary>
        protected override void WaterLevelMonitor()
        {
            base.WaterLevelMonitor();
            //增加AN tower监控逻辑
            _anWaterLevelLowerTrigger.CLK = _reservoirData.AnTowerLow;
            _anWaterLevelHighTrigger.CLK = _reservoirData.AnTowerHigh;
            if (_anWaterLevelLowerTrigger.Q  && !Recipe.ANDIReplenEnable)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"AN tower low is activate and recipe ANDIReplenEnable is false");
                //若recipe允许补水且res auto ，需要启动阳极自动补水
            }
            if (_anWaterLevelHighTrigger.Q && !Recipe.ANDIReplenEnable)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"AN tower high is activate and recipe ANDIReplenEnable is false");
            }
        }
        /// <summary>
        /// 补水监控
        /// </summary>
        protected override void AutoDireplenMonitor()
        {
            base.AutoDireplenMonitor();
        }

        /// <summary>
        /// 阳极DI Replen On
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool ANDiReplenOnOperation(string cmd, object[] args)
        {
            return ANDiReplenOn();
        }
        /// <summary>
        /// 阳极DI Replen On
        /// </summary>
        /// <param name="showError"></param>
        /// <returns></returns>
        private bool ANDiReplenOn()
        {
            bool preCondition = CheckPreDiReplenCondition();
            if (!preCondition)
            {
                return false;
            }
            if (IsANHighLevel)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"ANHighLevel is activate,Can't do AN_DIReple");
                return false;
            }
            if (IsANLowLevel)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"ANLowLevel is activate,Can't do AN_DIReple");
                return false;
            }
            if (ReservoirData.CaDiReplen)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, "CADiReplen is on");
                return false;
            }
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{AN_DI_REPLEN}");
            return BeckhoffIOManager.Instance.WriteIoValue(ioName, true);
        }

        /// <summary>
        /// 阳极DI Replen Off
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool ANDiReplenOff(string cmd, object[] args)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{AN_DI_REPLEN}");
            bool result = BeckhoffIOManager.Instance.WriteIoValue(ioName, false);
            if (result)
            {
                _persistentValue.IsDiReplenOn = false;
                if (_currentDireplenOperation == DiReplenOperation.ManualANDiReplen || _currentDireplenOperation == DiReplenOperation.AutoANDiReplen)
                {
                    _currentDireplenOperation = DiReplenOperation.None;
                    _persistentValue.LastTotalReplen = _persistentValue.TotalReplen;
                    ReservoirsPersistentManager.Instance.UpdatePersistentValue(Module);
                }
            }
            return result;
        }
        /// <summary>
        /// 手动阳极注水
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private bool ManualANDiReplen(string cmd, object[] args)
        {
            return ManualDiReplen(ANDiReplenOnOperation, DiReplenOperation.ManualANDiReplen, args[0].ToString());
        }


    }
}