using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.Routine;
using Aitex.Core.UI.Control;
using Aitex.Core.Util;
using MECF.Framework.Common.Beckhoff.ModuleIO;
using MECF.Framework.Common.CommonData.Metal;
using MECF.Framework.Common.Persistent.Reservoirs;
using MECF.Framework.Common.TwinCat;
using CyberX8_Core;
using CyberX8_RT.Devices.LinMot;
using CyberX8_RT.Devices.Prewet;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Diagnostics;
using MECF.Framework.Common.IOCore;
using Aitex.Core.RT.SCCore;
using CyberX8_RT.Devices.PowerSupplier;
using MECF.Framework.Common.ToolLayout;
using SecsGem.Core.ItemModel;


namespace CyberX8_RT.Devices.Metal
{
    public class StandardHotMetalDevice : MetalCellDevice
    {
        private enum MetalOperation
        {
            None,
            CellPumpOn
        }
        #region 常量 
        private const string PERSISTENT_VALUE = "PersistentValue";
        private const string CELL_PUMP = "CellPump";
        private const string CELL_FLOW = "CellFlow";
        private const string WH_CLAMP = "WaferHolderClamp";
        private const string CIRCULATION = "Circulation";
        
        #endregion
        #region 内部变量
        /// <summary>
        /// 设备数据
        /// </summary>
        private StandardHotMetalDeviceData _metalDeviceData = new StandardHotMetalDeviceData();
        /// <summary>
        /// 变量是否初始化字典
        /// </summary>
        private Dictionary<string, bool> _variableInitializeDic = new Dictionary<string, bool>();
        /// <summary>
        /// Pump Routine
        /// </summary>
        private StandardHotMetalCellPumpRoutine _cellPumpRoutine;
        /// <summary>
        /// 当前操作
        /// </summary>
        private MetalOperation _currentOperation;
        /// <summary>
        /// Flow Valve计时
        /// </summary>
        private Stopwatch _flowValveStopWatch = new Stopwatch();
        /// <summary>
        /// 是否有独立的泵
        /// </summary>
        private bool _isSignalPump;
        #endregion

        #region 属性
        /// <summary>
        /// 设备数据
        /// </summary>
        public StandardHotMetalDeviceData MetalDeviceData { get { return _metalDeviceData; } }

        /// <summary>
        /// Flow Valve稳定状态
        /// </summary>
        public bool FlowValveStable { get { return _metalDeviceData.Circulation && _flowValveStopWatch.ElapsedMilliseconds >= 3000; } }
        /// <summary>
        /// 是否有单独的泵
        /// </summary>
        public bool IsSignalPump { get { return _isSignalPump; } }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="moduleName"></param>
        public StandardHotMetalDevice(string moduleName) : base(moduleName)
        {
        }
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        public override bool Initialize()
        {
            base.Initialize();
            InitializeParameter();
            InitializeRoutine();
            SubscribeValueAction();
            SubscribeData();
            return true;
        }


        /// <summary>
        /// 初始化参数
        /// </summary>
        private void InitializeParameter()
        {
            _persistentValue = MetalPersistentManager.Instance.GetMetalPersistentValue(Module);
            if (_persistentValue == null)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, "Persistent Value Object is not exist");
            }
            MetalItem metalItem = MetalItemManager.Instance.GetMetalItem(Module);
            
            if (metalItem != null && metalItem.DepPump) 
            {
                _isSignalPump = true;
            }
        }
        /// <summary>
        /// 初始化Routine
        /// </summary>
        private void InitializeRoutine()
        {
            _cellPumpRoutine = new StandardHotMetalCellPumpRoutine(Module.ToString());
        }
        /// <summary>
        /// 订阅数据
        /// </summary>
        private void SubscribeData()
        {
            DATA.Subscribe($"{Module}.MetalData", () => _metalDeviceData, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.CellPumpEnable", () => _metalDeviceData.CellPump, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.WaferShuttleClamped", () => _metalDeviceData.WaferHolderClamp, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.CellFlow", () => _metalDeviceData.CellFlow, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Circulation", () => _metalDeviceData.Circulation, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsSingalPump", () => _isSignalPump, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            

        }
        /// <summary>
        /// 订阅变量数值发生变化
        /// </summary>
        private void SubscribeValueAction()
        {
            BeckhoffIoSubscribeUpdateVariable(CELL_PUMP);
            BeckhoffIoSubscribeUpdateVariable(CELL_FLOW);
            BeckhoffIoSubscribeUpdateVariable(WH_CLAMP);
            BeckhoffIoSubscribeUpdateVariable(CIRCULATION);
        }
        /// <summary>
        /// 订阅Operation
        /// </summary>
        protected override void InitializeOperation()
        {
            base.InitializeOperation();
            OP.Subscribe($"{Module}.PumpEnable", OpenPump);
            OP.Subscribe($"{Module}.PumpDisable", ClosePump);
            OP.Subscribe($"{Module}.CellSwitchToBypass", (cmd, args) => { return SwitchToBypass(cmd, args); });
            OP.Subscribe($"{Module}.CellSwitchToFlow", (cmd, args) => { return SwitchToFlow(cmd, args); });
            OP.Subscribe($"{Module}.ClampOn", (cmd, args) => { return WaferHolderClampOn(cmd, args); });
            OP.Subscribe($"{Module}.ClampOff", (cmd, args) => { return WaferHolderClampOff(cmd, args); });
            OP.Subscribe($"{Module}.WaferHolderClampOn", (cmd, args) => { return WaferHolderClampOn(cmd, args); });
            OP.Subscribe($"{Module}.WaferHolderUnclampOn", (cmd, args) => { return WaferHolderClampOff(cmd, args); });
            
        }

        /// <summary>
        /// 订阅IO变量
        /// </summary>
        /// <param name="variable"></param>
        private void BeckhoffIoSubscribeUpdateVariable(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)
        {
            if (!_metalDeviceData.IsDataInitialized)
            {
                _metalDeviceData.IsDataInitialized = true;
            }
            PropertyInfo property = _metalDeviceData.GetType().GetProperty(variable);
            if (property != null)
            {
                property.SetValue(_metalDeviceData, value);
            }
            if (_variableInitializeDic.ContainsKey(variable) && !_variableInitializeDic[variable])
            {
                _variableInitializeDic[variable] = true;
            }
            if (variable == CIRCULATION)
            {
                bool bValue = (bool)value;
                if (bValue)
                {
                    _flowValveStopWatch.Restart();
                }
            }
        }
        public bool OpenPump(string cmd, Object[] args)
        {
            bool result = false;
            result = PumpOnOperation(cmd, args);
            return result;
        }
        public bool ClosePump(string cmd, Object[] args)
        {

            bool result = false;
            result = PumpOffOperation(cmd, args);
            return result;
        }


        #region CellPump
        /// <summary>
        /// Cell Pump On操作
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool PumpOnOperation(string cmd, object[] param)
        {
            if (_status == RState.Running)
            {
                LOG.WriteLog(eEvent.ERR_METAL, Module.ToString(), $"{Module} current execute {_currentOperation},cannot Pump On");
                return false;
            }
            _status = _cellPumpRoutine.Start(true);
            _currentOperation = MetalOperation.CellPumpOn;
            return _status == RState.Running;
        }
        /// <summary>
        /// Cell Pump Off操作
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool PumpOffOperation(string cmd, object[] param)
        {
            bool result = true;
            if (MetalDeviceData.CellPump)
            {
                result = PumpOff();
            }
            return result;
            //return PumpOff();
        }
        /// <summary>
        /// Pump Off
        /// </summary>
        /// <returns></returns>
        public bool PumpOff()
        {
            if (_status == RState.Running && _currentOperation == MetalOperation.CellPumpOn)
            {
                IRoutine routine = GetCurrentRoutine();
                if (routine != null)
                {
                    routine.Abort();
                }
            }
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{CELL_PUMP}");
            return IOModuleManager.Instance.WriteIoValue(ioName, false);
        }
        #endregion

        #region WaferHolderClampOn
        /// <summary>
        /// Wafer Holder Clamp On
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool WaferHolderClampOn(string cmd, object[] param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{WH_CLAMP}");
            return IOModuleManager.Instance.WriteIoValue(ioName, true);
        }
        #endregion

        #region WaferHolderClampOff
        /// <summary>
        /// Wafer Holder Clamp On
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool WaferHolderClampOff(string cmd, object[] param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{WH_CLAMP}");
            return IOModuleManager.Instance.WriteIoValue(ioName, false);
        }
        #endregion

        #region circulation
        /// <summary>
        /// 切换至Bypass
        /// </summary>
        /// <returns></returns>
        public bool SwitchToBypass(string cmd, object[] param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{CIRCULATION}");
            return IOModuleManager.Instance.WriteIoValue(ioName, false);
        }
        /// <summary>
        /// 切换至Flow
        /// </summary>
        /// <returns></returns>
        public bool SwitchToFlow(string cmd, object[] param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{CIRCULATION}");
            return IOModuleManager.Instance.WriteIoValue(ioName, true);
        }
        #endregion

        /// <summary>
        /// Enter Disabled Operation
        /// </summary>
        /// <returns></returns>
        public void EnterDisabledOperation()
        {
            if (_metalDeviceData.CellPump)
            {
                ClosePump("", null);
            }
        }

        /// <summary>
        /// 定时器
        /// </summary>
        /// <returns></returns>
        public override bool OnTimer(int interval)
        {
            if (_status == RState.Running)
            {
                IRoutine routine = GetCurrentRoutine();
                if (routine != null)
                {
                    RState rsState = routine.Monitor();
                    if (rsState == RState.Failed || rsState == RState.Timeout)
                    {
                        _status = RState.Failed;
                        ClosePump("", null);
                        _currentOperation = MetalOperation.None;
                    }
                    else if (rsState == RState.End)
                    {
                        _status = RState.End;
                        _currentOperation = MetalOperation.None;
                    }
                }
            }
            return true;
        }

        /// <summary>
        /// 当前Routine;
        /// </summary>
        /// <returns></returns>
        private IRoutine GetCurrentRoutine()
        {
            switch (_currentOperation)
            {
                case MetalOperation.CellPumpOn:
                    return _cellPumpRoutine;
                default:
                    return null;
            }
        }

        #region 设备接口
        public override void Monitor()
        {
        }

        public override void Reset()
        {
        }

        public override void Terminate()
        {
        }
        #endregion
    }
}