using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Fsm;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.RecipeCenter;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Persistent.Reservoirs;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.Common.ToolLayout;
using CyberX8_Core;
using CyberX8_RT.Devices.Metal;
using CyberX8_RT.Devices.PowerSupplier;
using CyberX8_RT.Devices.Temperature;
using CyberX8_RT.Modules.Prewet;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Aitex.Core.Utilities;
using MECF.Framework.Common.ProcessCell;
using CyberX8_RT.Modules.Metal;
using CyberX8_RT.Modules.SRD;
using System.Windows;
using Aitex.Core.RT.SCCore;
using SecsGem.Core.ItemModel;

namespace CyberX8_RT.Modules.Reservoir
{
    public class ReservoirEntity : Entity, IEntity, IModuleEntity
    {
        #region 常量
        private const string STRATUS = "Stratus";
        private const string AUTO = "Auto";
        private const string MANUAL = "Manual";
        private const string DISABLED = "Disabled";
        private const string ENGINEERING = "Engineering";
        private const string PRODUCTION = "Production";
        #endregion

        #region 内部变量
        /// <summary>
        /// 持久化数值
        /// </summary>
        private ReservoirsPersistentValue _persistentValue;
        /// <summary>
        /// S$H Initialize Routine
        /// </summary>
        private StandardHotReservoirInitializeRoutine _shInitializeRoutine;
        /// <summary>
        /// C&HInitialize Routine
        /// </summary>
        private CompactEmbranceInitializeRoutine _cmInitializeRoutine;
        /// <summary>
        /// DosingSystem Initialize Routine
        /// </summary>
        private DosingSystemInitializeRoutine _dosingSystemInitializeRoutine;
        /// <summary>
        /// Metal 集合
        /// </summary>
        private List<MetalCellDevice> _metalDevices = new List<MetalCellDevice>();
        /// <summary>
        /// 电源
        /// </summary>
        private CellPowerSupplier _powerSupplier;
        /// <summary>
        /// 温度控制设备
        /// </summary>
        private TemperatureController _temperatureController;
        /// <summary>
        /// Reservoir项
        /// </summary>
        private ReservoirItem _reservoirItem;
        #endregion
        #region 属性
        /// <summary>
        /// 模块名称
        /// </summary>
        public ModuleName Module { get; private set; }
        /// <summary>
        /// 是否Init
        /// </summary>
        public bool IsInit
        {
            get { return fsm.State == (int)ReservoirState.Init; }
        }
        /// <summary>
        /// 是否Idle
        /// </summary>
        public bool IsIdle
        {
            get
            {
                return fsm.State == (int)ReservoirState.Idle;
            }
        }
        /// <summary>
        /// 是否错误
        /// </summary>
        public bool IsError
        {
            get { return fsm.State == (int)ReservoirState.Error; }
        }
        /// <summary>
        /// 正在忙碌
        /// </summary>
        public bool IsBusy
        {
            get { return fsm.State == (int)ReservoirState.Initializing; }
        }
        /// <summary>
        /// 化学液
        /// </summary>
        public string Chemistry
        {
            get { return CurrentRecipe != null ? CurrentRecipe.Metal : ""; }
        }
        /// <summary>
        /// 是否禁用
        /// </summary>
        public bool IsDisable { get { return _persistentValue == null || _persistentValue.OperatingMode == DISABLED; } }

        /// <summary>
        /// 自动模式
        /// </summary>
        public bool IsAuto { get { return _persistentValue != null && _persistentValue.OperatingMode == AUTO; } }
        /// <summary>
        /// 自动模式
        /// </summary>
        public bool IsManual { get { return _persistentValue != null && _persistentValue.OperatingMode == MANUAL; } }
        /// <summary>
        /// 是否为工程模式
        /// </summary>
        public bool IsEngineering { get { return _persistentValue != null && _persistentValue.RecipeOperatingMode == ENGINEERING; } }
        /// <summary>
        /// 是否为产品模式
        /// </summary>
        public bool IsProduction { get { return _persistentValue != null && _persistentValue.RecipeOperatingMode == PRODUCTION; } }
        /// <summary>
        /// 状态机状态
        /// </summary>
        public ReservoirState State { get { return (ReservoirState)fsm.State; } }
        /// <summary>
        /// 是否初始化完成
        /// </summary>
        public bool IsInitialized { get { return fsm.State >= (int)ReservoirState.Initialized; } }
        /// <summary>
        /// 当前Recipe
        /// </summary>
        public ResRecipe CurrentRecipe { get { return LoadCurrentRecipe(); } }
        /// <summary>
        /// 用量
        /// </summary>
        public ReservoirUsage ReservoirUsage { get { return ReservoirUsageManager.Instance.GetReservoirUsage(Module.ToString()); } }
        /// <summary>
        /// Metals是否有Busy
        /// </summary>
        public bool IsMetalBusy
        {
            get {
                if(_metalDevices == null) return false;
                foreach(var item in _metalDevices)
                {
                    MetalEntity metalEntity = Singleton<RouteManager>.Instance.GetModule<MetalEntity>(item.Module.ToString());
                    if (metalEntity != null && metalEntity.IsBusy) return true;
                };
                return false;
            }
        }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public ReservoirEntity(ModuleName module)
        {
            this.Module = module;
            InitializeParameter();
            InitialFsm();
        }

        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        protected override bool Init()
        {
            InitializeRoutine();
            InitialDATA();
            InitializeOperation();
            return true;
        }

        /// <summary>
        /// 初始化参数
        /// </summary>
        private void InitializeParameter()
        {
            _persistentValue = ReservoirsPersistentManager.Instance.GetReservoirsPersistentValue(Module.ToString());
            if (_persistentValue == null)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module.ToString(), "Persistent Value Object is not exist");
            }
            LoadAllComponents();
        }
        /// <summary>
        /// 加载当前recipe
        /// </summary>
        /// <returns></returns>
        private ResRecipe LoadCurrentRecipe()
        {
            if(_persistentValue!=null&&!string.IsNullOrEmpty(_persistentValue.Recipe))
            {
                return RecipeFileManager.Instance.LoadGenericityRecipe<ResRecipe>(_persistentValue.Recipe);
            }
            return null;
        }
        /// <summary>
        /// 加载Metals
        /// </summary>
        private void LoadAllComponents()
        {
            _reservoirItem = ReservoirItemManager.Instance.GetReservoirItem(Module.ToString());
            if (_reservoirItem != null)
            {
                List<MetalItem> metalItems = _reservoirItem.MetalCells;
                if (metalItems != null && metalItems.Count > 0)
                {
                    foreach (MetalItem metalItem in metalItems)
                    {
                        MetalCellDevice metalDevice = DEVICE.GetDevice<MetalCellDevice>(metalItem.ModuleName);
                        if (metalDevice != null)
                        {
                            _metalDevices.Add(metalDevice);
                        }
                    }
                }

                if (!string.IsNullOrEmpty(_reservoirItem.CMMSupplyID))
                {
                    _powerSupplier = DEVICE.GetDevice<CellPowerSupplier>(_reservoirItem.CMMSupplyID);                                 
                }

                if (!string.IsNullOrEmpty(_reservoirItem.TCID))
                {
                    _temperatureController = DEVICE.GetDevice<TemperatureController>(_reservoirItem.TCID);
                }
            }
        }
        /// 初始化状态机
        /// </summary>
        private void InitialFsm()
        {
            fsm = new StateMachine<ReservoirEntity>(Module.ToString(), (int)ReservoirState.Init, 100);
            fsm.EnableRepeatedMsg(true);

            AnyStateTransition(ReservoirMsg.Error, NullFunc, ReservoirState.Error);
            //Initialized
            Transition(ReservoirState.Error, ReservoirMsg.Initialize, InitializeAll, ReservoirState.Initializing);
            Transition(ReservoirState.Init, ReservoirMsg.Initialize, InitializeAll, ReservoirState.Initializing);
            Transition(ReservoirState.Idle, ReservoirMsg.Initialize, InitializeAll, ReservoirState.Initializing);
            Transition(ReservoirState.Initializing, FSM_MSG.TIMER, InitializeAllMonitor, ReservoirState.Idle);

            //直接进入Idle
            Transition(ReservoirState.Initialized, FSM_MSG.TIMER, NullFunc, ReservoirState.Idle);
            //Enter Init
            Transition(ReservoirState.Idle, ReservoirMsg.Init, NullFunc, ReservoirState.Init);

            EnumLoop<ReservoirState>.ForEach((item) => { fsm.MapState((int)item, item.ToString()); });

            EnumLoop<ReservoirMsg>.ForEach((item) => { fsm.MapMessage((int)item, item.ToString()); });
        }
        /// <summary>
        /// 初始化数据
        /// </summary>
        private void InitialDATA()
        {
            InitializeSVID();
            DATA.Subscribe($"{Module}.FsmState", () => ((ReservoirState)fsm.State).ToString(), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsIdle", () => IsIdle,SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsInit", () => IsInit, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsDisable", () => IsDisable,SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsBusy", () => IsBusy, SubscriptionAttribute.FLAG.IgnoreSaveDB);            
            DATA.Subscribe($"{Module}.IsError", () => IsError, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Metals",()=>_metalDevices.Select(O=>O.Name).ToList(),SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.TemperatureControllerData", () => _temperatureController == null ? null : _temperatureController.TemperatureData, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.CmmPowerSupplierData", () => _powerSupplier == null ? null : _powerSupplier.PowerSupplierData, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.ReservoirUsage", () => ReservoirUsage, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsCMMInstalled", () => ReservoirItemManager.Instance.GetReservoirItem(Module.ToString()).CMMType == "Standard"? true : false, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 初始化SVID
        /// </summary>
        private void InitializeSVID()
        {
            DATA.Subscribe($"{Module}.State", () => ((ReservoirState)fsm.State).ToString(), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.OperatingMode", () => _persistentValue != null ? _persistentValue.OperatingMode : "None", SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.ReservoirTotalAmpHours",()=> ReservoirUsage!=null?ReservoirUsage.TotalUsage:0, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.ReservoirTotalAmpHours.WarningLimit", () => SC.GetValue<double>("Reservoir.ReservoirTotalAmpHoursWarningLimit"), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.ReservoirTotalAmpHours.FaultLimit", () => SC.GetValue<double>("Reservoir.ReservoirTotalAmpHoursFaultLimit"), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.BathTotalAmpHours",()=> ReservoirUsage != null ? ReservoirUsage.BathUsage:0, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.BathTotalAmpHours.WarningLimit", () => SC.GetValue<double>("Reservoir.BathTotalAmpHoursWarningLimit"), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.BathTotalAmpHours.FaultLimit", () => SC.GetValue<double>("Reservoir.BathTotalAmpHoursFaultLimit"), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.ANBathTotalAmpHours",()=> ReservoirUsage != null ? ReservoirUsage.AnodeUsage:0, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.ANBathTotalAmpHours.WarningLimit", () => SC.GetValue<double>("Reservoir.ANBathTotalAmpHoursWarningLimit"), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.ANBathTotalAmpHours.FaultLimit", () => SC.GetValue<double>("Reservoir.ANBathTotalAmpHoursFaultLimit"), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.MembraneTotalAmpHours",()=> ReservoirUsage != null ? ReservoirUsage.MembranceUsage:0, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.MembraneTotalAmpHours.WarningLimit", () => SC.GetValue<double>("Reservoir.MembraneTotalAmpHoursWarningLimit"), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.MembraneTotalAmpHours.FaultLimit", () => SC.GetValue<double>("Reservoir.MembraneTotalAmpHoursFaultLimit"), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.BathTotalDays", () => ReservoirUsage != null ? ReservoirUsage.BathUsageDays:0, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.BathTotalDays.WarningLimit", () => SC.GetValue<int>("Reservoir.BathTotalDaysWarningLimit"), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.BathTotalDays.FaultLimit", () => SC.GetValue<int>("Reservoir.BathTotalDaysFaultLimit"), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.ReservoirTotalWafers",()=> ReservoirUsage != null ? ReservoirUsage.TotalWafers:0, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.ReservoirTotalWafers.WarningLimit", () => SC.GetValue<int>("Reservoir.ReservoirTotalWafersWarningLimit"), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.ReservoirTotalWafers.FaultLimit", () => SC.GetValue<int>("Reservoir.ReservoirTotalWafersFaultLimit"), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Temperature", () => _temperatureController!=null? _temperatureController.TemperatureData.ReserviorTemperature:0, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Temperature.ID", () => _temperatureController != null ? _temperatureController.Module : "", SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Temperature.Status", () => _temperatureController != null ? _temperatureController.TemperatureData.Status : "", SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Temperature.TargetTemperature", () => _temperatureController != null ? _temperatureController.TemperatureData.TargetTemperature : 0, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Temperature.Alarm", () => _temperatureController != null ? _temperatureController.TemperatureData.Alarm : "", SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.Temperature.HeatExchangerTemperature", () => _temperatureController != null ? _temperatureController.TemperatureData.HeatExchangerTemperature : 0, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 初始化Routine
        /// </summary>
        private void InitializeRoutine()
        {
            _shInitializeRoutine = new StandardHotReservoirInitializeRoutine(Module.ToString());
            _cmInitializeRoutine=new CompactEmbranceInitializeRoutine(Module.ToString()); 
            _dosingSystemInitializeRoutine = new DosingSystemInitializeRoutine(Module.ToString());
        }
        /// <summary>
        /// 初始化Operation
        /// </summary>
        private void InitializeOperation()
        {
            OP.Subscribe($"{Module}.UpdateReservoirUsage", UpdateReservoirUsageAction);
            OP.Subscribe($"{Module}.InitializeAll", (cmd, args) => { return CheckToPostMessage<ReservoirState, ReservoirMsg>(eEvent.ERR_RESERVOIR, Module.ToString(), (int)ReservoirMsg.Initialize); });
        }
        /// <summary>
        /// EnterInit
        /// </summary>
        public void EnterInit()
        {
            if ((ReservoirState)fsm.State != ReservoirState.Idle) return;
            else
            {
                CheckToPostMessage<ReservoirState, ReservoirMsg>(eEvent.ERR_RESERVOIR, Module.ToString(), (int)ReservoirMsg.Init);
            }
        }
        /// <summary>
        /// UpdateReservoirUsageAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool UpdateReservoirUsageAction(string cmd, object[] args)
        {
            if (args.Length > 2)
            {
                ReservoirUsageManager.Instance.UpdateReservoirUsageByManualOperation(args[0].ToString(), args[1].ToString(), args[2].ToString());
                LOG.WriteLog(eEvent.INFO_RESERVOIR, Module.ToString(), $"New {args[1].ToString()} value {args[2].ToString()} was input");
            }
            return true;
        }



        #region InitializeAll
        /// <summary>
        /// Initialize
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool InitializeAll(object[] param)
        {
            if (_metalDevices==null||_metalDevices.Count==0)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module.ToString(), "metal device is empty");
                return false;
            }
            if(_persistentValue==null)
            {
                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module.ToString(), "persistent is null");
                return false;
            }
            if (_reservoirItem.SubType == STRATUS)
            {
                return _shInitializeRoutine.Start(_metalDevices, _powerSupplier, _temperatureController) == RState.Running;
            }
            else
            {
                return _cmInitializeRoutine.Start(_metalDevices, _temperatureController) ==RState.Running;
            }
        }
        /// <summary>
        /// Initialize 监控
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool InitializeAllMonitor(object[] param)
        {
            RState ret = RState.Init;
            if (_reservoirItem.SubType == STRATUS)
            {
                ret= _shInitializeRoutine.Monitor();
            }
            else
            {
                ret = _cmInitializeRoutine.Monitor();
            }
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(ReservoirMsg.Error);
                return false;
            }

            return ret == RState.End;
        }
        #endregion
               
        public bool Check(int msg, out string reason, params object[] args)
        {
            reason = "";
            return true;
        }

        public bool CheckAcked(int msg)
        {
            return true;
        }

        public int Invoke(string function, params object[] args)
        {
            switch (function)
            {
                case "HomeAll":
                    if (IsIdle)
                    {
                        return (int)ReservoirMsg.Initialize;
                    }
                    if (CheckToPostMessage<ReservoirState, ReservoirMsg>(eEvent.ERR_RESERVOIR, Module.ToString(), (int)ReservoirMsg.Initialize))
                    {
                        return (int)ReservoirMsg.Initialize;
                    }
                    else
                    {
                        return (int)FSM_MSG.NONE;
                    }
            }
            return (int)FSM_MSG.NONE;
        }
        
    }
}