using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using MECF.Framework.Common.Persistent.Reservoirs;
using MECF.Framework.Common.ToolLayout;
using CyberX8_Core;
using CyberX8_RT.Devices.LinMot;
using CyberX8_RT.Devices.PowerSupplier;
using Aitex.Core.RT.OperationCenter;
using CyberX8_RT.Modules.Reservoir;
using CyberX8_RT.Modules;
using CyberX8_RT.Modules.Metal;
using CyberX8_RT.Modules.Dryer;
using MECF.Framework.Common.Persistent.Dryer;

namespace CyberX8_RT.Devices.Metal
{
    public class MetalCellDevice : BaseDevice, IDevice
    {
        #region 常量 
        private const string PERSISTENT_VALUE = "PersistentValue";
        private const string AUTO = "Auto";
        private const string MANUAL = "Manual";
        private const string STRATUS = "Stratus";
        private const string DISABLED = "Disabled";
        #endregion

        #region 内部变量
        /// <summary>
        /// 操作当前状态
        /// </summary>
        protected RState _status;
        /// <summary>
        /// 持久化数据
        /// </summary>
        protected MetalPersistentValue _persistentValue;
        /// <summary>
        /// A面PowerSupplier
        /// </summary>
        protected CellPowerSupplier _sideAPowerSupplier;
        /// <summary>
        /// B面PowerSupplier
        /// </summary>
        protected CellPowerSupplier _sideBPowerSupplier;
        /// <summary>
        /// Linmot
        /// </summary>
        protected LinMotAxis _linmotAxis;
        /// <summary>
        /// Metal项
        /// </summary>
        private MetalItem _metalItem;
        #endregion

        #region 属性
        /// <summary>
        /// 状态
        /// </summary>
        public RState Status { get { return _status; } }
        /// <summary>
        /// 是否禁用
        /// </summary>
        public bool IsDisable { get { return _persistentValue == null || _persistentValue.OperatingMode == DISABLED; } }
        /// <summary>
        /// clamp off状态
        /// </summary>
        public bool ClampOff
        {
            get
            {
                if (_metalItem.SubType == STRATUS)
                {
                    StandardHotMetalDevice metalDevice = DEVICE.GetDevice<StandardHotMetalDevice>(Module.ToString());
                    return !metalDevice.MetalDeviceData.WaferHolderClamp;
                }
                else
                {
                    CompactMembranMetalDevice metalDevice = DEVICE.GetDevice<CompactMembranMetalDevice>(Module.ToString());
                    return !metalDevice.MetalDeviceData.WHClamp && metalDevice.MetalDeviceData.WHUnclamp;
                }
            }
        }
        /// <summary>
        /// 操作模式
        /// </summary>
        public string OperationMode { get { return _persistentValue.OperatingMode; } }
        /// <summary>
        /// 工程模式
        /// </summary>
        public string EngineerMode { get { return _persistentValue.RecipeOperatingMode; } }
        /// <summary>
        /// A面PowerSupplier
        /// </summary>
        public CellPowerSupplier SideAPowerSupplier { get { return _sideAPowerSupplier; } }
        /// <summary>
        /// B面PowerSupplier
        /// </summary>
        public CellPowerSupplier SideBPowerSupplier { get { return _sideBPowerSupplier; } }
        /// <summary>
        /// 是否为Auto
        /// </summary>
        public bool IsAuto { get { return _persistentValue != null ? _persistentValue.OperatingMode == AUTO : false; } }
        /// <summary>
        /// 是否为Auto
        /// </summary>
        public bool IsManual { get { return _persistentValue != null ? _persistentValue.OperatingMode == MANUAL : false; } }
        /// <summary>
        /// linmot motor on 
        /// </summary>
        public bool IsLinmotMotorOn { get { return _linmotAxis != null ? _linmotAxis.IsMotorOn : false; } }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="moduleName"></param>
        public MetalCellDevice(string moduleName) : base(moduleName, moduleName, moduleName, moduleName)
        {
        }
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        public virtual bool Initialize()
        {
            InitializeParameter();
            SubscribeData();
            InitializeOperation();
            return true;
        }
        /// <summary>
        /// 定时器执行
        /// </summary>
        public virtual bool OnTimer(int interval)
        {
            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=MetalItemManager.Instance.GetMetalItem(Module);
            if(_metalItem!=null)
            {
                _sideAPowerSupplier = DEVICE.GetDevice<CellPowerSupplier>(_metalItem.PlatingPowerSupplyAID);
                _sideBPowerSupplier = DEVICE.GetDevice<CellPowerSupplier>(_metalItem.PlatingPowerSupplyBID);
                _linmotAxis = DEVICE.GetDevice<LinMotAxis>(_metalItem.LinmotID);
            }
        }

        /// <summary>
        /// 订阅数据
        /// </summary>
        private void SubscribeData()
        {
            DATA.Subscribe($"{Module}.{PERSISTENT_VALUE}", () => _persistentValue, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideAPowerSupplierData", () => _sideAPowerSupplier.PowerSupplierData, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideBPowerSupplierData", () => _sideBPowerSupplier.PowerSupplierData, SubscriptionAttribute.FLAG.IgnoreSaveDB); 
            DATA.Subscribe($"{Module}.SideAPowerSupplier.ID", () => _sideAPowerSupplier.Module, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideAPowerSupplier.IsConnected", ()=>_sideAPowerSupplier.IsConnected, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideAPowerSupplier.Voltage", () => _sideAPowerSupplier.PowerSupplierData.Voltage, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideAPowerSupplier.Current", () => _sideAPowerSupplier.PowerSupplierData.Current, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideAPowerSupplier.SetPoint", () => _sideAPowerSupplier.PowerSupplierData.SetPoint, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideAPowerSupplier.RunModel", () => _sideAPowerSupplier.PowerSupplierData.PowerRunModelContent, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideAPowerSupplier.PowerControl", () => _sideAPowerSupplier.PowerSupplierData.PowerControlContent, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideAPowerSupplier.PowerStatus", () => _sideAPowerSupplier.PowerSupplierData.PowerStatusContent, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideAPowerSupplier.Enable", () => _sideBPowerSupplier.PowerSupplierData.Enabled, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideBPowerSupplier.ID", () => _sideBPowerSupplier.Module, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideBPowerSupplier.IsConnected", () => _sideAPowerSupplier.IsConnected, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideBPowerSupplier.Voltage", () => _sideBPowerSupplier.PowerSupplierData.Voltage, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideBPowerSupplier.Current", () => _sideBPowerSupplier.PowerSupplierData.Current, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideBPowerSupplier.SetPoint", () => _sideBPowerSupplier.PowerSupplierData.SetPoint, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideBPowerSupplier.RunModel", () => _sideBPowerSupplier.PowerSupplierData.PowerRunModelContent, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideBPowerSupplier.PowerControl", () => _sideBPowerSupplier.PowerSupplierData.PowerControlContent, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideBPowerSupplier.PowerStatus", () => _sideBPowerSupplier.PowerSupplierData.PowerStatusContent, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.SideBPowerSupplier.Enable", () => _sideBPowerSupplier.PowerSupplierData.Enabled, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Linmot.ID", () => _linmotAxis.Module, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Linmot.IsMotorOn", () => _linmotAxis.IsMotorOn, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Linmot.IsError", ()=>_linmotAxis.IsError, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Linmot.IsSwitchOn", () => _linmotAxis.IsSwitchOn, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Linmot.CurveSpeed", () => _linmotAxis.CurveSpeed, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Linmot.ErrorCode", () => _linmotAxis.ErrorCode, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Linmot.CurrentPosition", () => _linmotAxis.CurrentPosition, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 初始化操作
        /// </summary>
        protected virtual void InitializeOperation()
        {
            OP.Subscribe($"{Module}.DisabledAction", DisabledOperation);
            OP.Subscribe($"{Module}.ManualAction", ManualOperation);
            OP.Subscribe($"{Module}.AutoAction", AutoOperation);
            OP.Subscribe($"{Module}.EngineeringModeAction", EngineeringModeOperation);
            OP.Subscribe($"{Module}.ProductionModeAction", ProductionModeOperation);
            OP.Subscribe($"{Module}.SetMetalWaferSize", (cmd, args) => { return SetMetalWaferSize(cmd, args); });
        }
        /// <summary>
        /// 开始Curve
        /// </summary>
        /// <param name="speed"></param>
        /// <returns></returns>
        public bool StartCurveMotion(int speed)
        {
            if (_linmotAxis != null)
            {
                return _linmotAxis.StartCurve(speed);
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_METAL, Module, "linmot is null");
                return false;
            }
        }

        /// <summary>
        /// 开始Curve
        /// </summary>
        /// <param name="speed"></param>
        /// <returns></returns>
        public bool ChangeCurveSpeedMotion(int speed)
        {
            if (_linmotAxis != null)
            {
                return _linmotAxis.ChangeCurveSpeed(speed);
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_METAL, Module, "linmot is null");
                return false;
            }
        }
        /// <summary>
        /// ResetLinmot
        /// </summary>
        /// <returns></returns>
        public bool ResetLinmot()
        {
            if (_linmotAxis != null)
            {
                return _linmotAxis.ResetOperation("",false);
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_METAL, Module, "linmot is null");
                return false;
            }
        }
        /// <summary>
        /// 检验Linmot Routine状态是否为结束状态
        /// </summary>
        /// <returns></returns>
        public bool CheckLinmotRoutineEnd()
        {
            if (_linmotAxis != null)
            {
                return _linmotAxis.Status==RState.End;
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_METAL, Module, "linmot is null");
                return false;
            }
        }
        /// <summary>
        /// 检验Linmot Routine状态是否为错误状态
        /// </summary>
        /// <returns></returns>
        public bool CheckLinmotRoutineError()
        {
            if (_linmotAxis != null)
            {
                return _linmotAxis.Status == RState.Failed||_linmotAxis.Status==RState.Timeout;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 停止Linmot
        /// </summary>
        /// <returns></returns>
        public bool StopLinmot()
        {
            if(_linmotAxis != null)
            {
                return _linmotAxis.StopOperation("", null);
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_METAL, Module, "linmot is null");
                return false;
            }
        }

        #region Operation
        /// <summary>
        /// DisabledAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool DisabledOperation(string cmd, object[] args)
        {
            string currentOperation = "Disabled";
            MetalEntity metalEntity = Singleton<RouteManager>.Instance.GetModule<MetalEntity>(Module);
            if (metalEntity == null || _persistentValue == null) return false;
            if (_persistentValue.OperatingMode != "Disabled") metalEntity.EnterInit();
            _persistentValue.OperatingMode = currentOperation;           
            MetalPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        /// <summary>
        /// ManualAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool ManualOperation(string cmd, object[] args)
        {
            string currentOperation = "Manual";
            MetalEntity metalEntity = Singleton<RouteManager>.Instance.GetModule<MetalEntity>(Module);
            if (metalEntity == null || _persistentValue == null) return false;
            if (_persistentValue.OperatingMode == "Auto" && metalEntity.IsBusy)
            {
                LOG.WriteLog(eEvent.ERR_METAL, Module, $"{Module} is Busy, can't change to manual mode");
                return false;
            }
            if (_persistentValue.OperatingMode != "Manual") metalEntity.EnterInit();
            _persistentValue.OperatingMode = currentOperation;         
            MetalPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        /// <summary>
        /// AutoAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool AutoOperation(string cmd, object[] args)
        {
            string currentOperation = "Auto";
            MetalEntity metalEntity = Singleton<RouteManager>.Instance.GetModule<MetalEntity>(Module);
            if(metalEntity == null || _persistentValue == null) return false;
            if (_persistentValue.OperatingMode != "Auto") metalEntity.EnterInit();          
            _persistentValue.OperatingMode = currentOperation;
            MetalPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        /// <summary>
        /// EngineeringModeAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool EngineeringModeOperation(string cmd, object[] args)
        {
            string currentRecipeOperation = "Engineering";
            if (_persistentValue != null)
            {
                _persistentValue.RecipeOperatingMode = currentRecipeOperation;
            }
            MetalPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        /// <summary>
        /// ProductionAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool ProductionModeOperation(string cmd, object[] args)
        {
            string currentRecipeOperation = "Production";
            if (_persistentValue != null)
            {
                _persistentValue.RecipeOperatingMode = currentRecipeOperation;
            }
            MetalPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }

        private bool SetMetalWaferSize(string cmd, object[] args)
        {
            string metalWaferSize = args[0] as string;
            if (_persistentValue != null)
            {
                _persistentValue.MetalWaferSize = int.Parse(metalWaferSize);
            }
            MetalPersistentManager.Instance.UpdatePersistentValue(Module);
            return true;
        }
        #endregion


        #region Clamp
        /// <summary>
        /// Clamp Off
        /// </summary>
        /// <returns></returns>
        public bool WaferHolderClampOff()
        {
            if (_metalItem.SubType == STRATUS)
            {
                StandardHotMetalDevice metalDevice = DEVICE.GetDevice<StandardHotMetalDevice>(Module.ToString());
                return metalDevice.WaferHolderClampOff("", null);
            }
            else
            {
                CompactMembranMetalDevice metalDevice = DEVICE.GetDevice<CompactMembranMetalDevice>(Module.ToString());
                return metalDevice.WaferHolderUnclampOn("", null);
            }
        }
        #endregion

        public virtual void Monitor()
        {
        }

        public virtual void Reset()
        {
        }

        public virtual void Terminate()
        {
        }
    }
}