using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.Routine;
using CyberX8_Core;
using CyberX8_RT.Devices.Reservoir;
using MECF.Framework.Common.Beckhoff.ModuleIO;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.IOCore;
using MECF.Framework.Common.Persistent.Reservoirs;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.TwinCat;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows;

namespace CyberX8_RT.Devices.Dose
{
    public class CrossDoseResetRoutine : RoutineBase, IRoutine
    {
        private enum ResetStep
        {
            Reset_True,
            Reset_Wait,
            Reset_False,
            End
        }
        private enum POSStatus
        {
            Busy,
            InTarget,
            Warning,
            Error
        }
        #region 内部变量
        /// <summary>
        /// 模块名称
        /// </summary>
        private string _moduleName;
        /// <summary>
        /// 超时时间
        /// </summary>
        private int _timeOut = 2000;
        /// <summary>
        /// CompactMembranReservoirDevice 
        /// </summary>
        private CompactMembranReservoirDevice _cmReservoirDevice;
        /// <summary>
        /// ReservoirsPersistentValue
        /// </summary>
        private ReservoirsPersistentValue _persistentValue;
        #endregion

        #region 属性
        public RState CurrentState { get { return Runner.Status; } }
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public CrossDoseResetRoutine(string module) : base(module)
        {
            _moduleName = module;
        }

        /// <summary>
        /// Monitor
        /// </summary>
        /// <returns></returns>
        public RState Monitor()
        {
            Runner.Run(ResetStep.Reset_True, SetTrue, _delay_1ms)
                .Wait(ResetStep.Reset_Wait, WaitCompleteEndStatus, _timeOut)
                .Run(ResetStep.Reset_False, SetFalse, _delay_1ms)
                .End(ResetStep.End, ClearData, _delay_1ms);
            return Runner.Status;
        }
        #region Operation
        /// <summary>
        /// Reset置1
        /// </summary>
        /// <returns></returns>
        private bool SetTrue()
        {
            //Reset = 1
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{_moduleName}.TransferPumpReset");
            bool result = IOModuleManager.Instance.WriteIoValue(ioName, true);
            if (!result)
            {
                return false;
            }
            return true;
        }
        /// <summary>
        /// Wait Reset Done End
        /// </summary>
        /// <returns></returns>
        private bool WaitCompleteEndStatus()
        {
            ushort status = (ushort)_cmReservoirDevice.ReservoirData.TransferPumpPOSStatus;
            if (!CheckPOSStatus(status, POSStatus.Error))
            {
                return true;
            }
            return false;
        }       
        /// <summary>
        /// Reset置0
        /// </summary>
        /// <returns></returns>
        private bool SetFalse()
        {
            //Reset = 0
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{_moduleName}.TransferPumpReset");
            bool result = IOModuleManager.Instance.WriteIoValue(ioName, false);
            if (!result)
            {
                return false;
            }
            _cmReservoirDevice.InitializeCrossDose(true);
            return true;
        }
        /// <summary>
        /// 清除数据
        /// </summary>
        /// <returns></returns>
        private bool ClearData()
        {
            _persistentValue.AutoCrossDoseStartTime = DateTime.MinValue;
            _persistentValue.AutoCrossDoseStartAmpHour = 0;
            _cmReservoirDevice.ReservoirData.RemainingCrossDoseVolume = 0;
            ReservoirsPersistentManager.Instance.UpdatePersistentValue(_moduleName);
            return true;
        }
        #endregion
        /// <summary>
        /// Start
        /// </summary>
        /// <param name="objs"></param>
        /// <returns></returns>
        public RState Start(params object[] objs)
        {
            _cmReservoirDevice = DEVICE.GetDevice<CompactMembranReservoirDevice>($"{_moduleName}");
            if (_cmReservoirDevice == null)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, _moduleName, "Compact Membran Reservoir Device is not exist");
                return RState.Failed;
            }
            _persistentValue = ReservoirsPersistentManager.Instance.GetReservoirsPersistentValue(_moduleName);
            if (_persistentValue == null)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, _moduleName, "Reservoir Persistent Value Object is not exist");
                return RState.Failed;
            }
            return Runner.Start(Module, "Reset Cross Dose");
        }
        /// <summary>
        /// Abort
        /// </summary>
        public void Abort()
        {
            Runner.Stop($"Stop Reset");
        }
        /// <summary>
        /// POS状态判断
        /// </summary>
        /// <param name="status"></param>
        /// <param name="statusName"></param>
        /// <returns></returns>
        private bool CheckPOSStatus(ushort status, POSStatus statusName)
        {
            bool result = false;
            switch (statusName)
            {
                case POSStatus.Busy:
                    byte bit0 = (byte)(status & 0b0001);
                    result = (bit0 == 1) ? true : false;
                    break;
                case POSStatus.InTarget:
                    byte bit1 = (byte)((status & 0b0010) >> 1);
                    result = (bit1 == 1) ? true : false;
                    break;
                case POSStatus.Warning:
                    byte bit2 = (byte)((status & 0b0100) >> 2);
                    result = (bit2 == 1) ? true : false;
                    break;
                case POSStatus.Error:
                    byte bit3 = (byte)((status & 0b1000) >> 3);
                    result = (bit3 == 1) ? true : false;
                    break;
                default:
                    break;
            }
            return result;
        }
    } 
}