Kepler-Release/Venus/Venus_MainPages/ViewModels/OperationOverViewModel.cs

using Aitex.Core.RT.Log;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Jobs;
using MECF.Framework.Common.OperationCenter;
using OpenSEMI.ClientBase;
using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Threading;
using Venus_Core;
using Venus_MainPages.Unity;
using Venus_MainPages.Views;
using Venus_Themes.CustomControls;
using static Venus_Themes.UserControls.EFEM;

namespace Venus_MainPages.ViewModels
{
    public class OperationOverViewModel : BindableBase
    {
        #region 私有字段
        private bool m_TabIsChecked = true;
        private ModuleInfo m_LP1ModuleInfo;
        private ModuleInfo m_LP2ModuleInfo;
        private ModuleInfo m_LLAModuleInfo;
        private ModuleInfo m_LLBModuleInfo;

        private ModuleInfo m_LP3ModuleInfo;
        private ModuleInfo m_EFEMModuleInfo;
        private ModuleInfo m_TMModuleInfo;
        private WaferRobotTAction m_Robot1TAction;
        private WaferRobotXAction m_Robot1XAction;
        private WaferRobotTAction m_Robot2TAction;
        private WaferRobotXAction m_Robot2XAction;
        private WaferRobotTAction m_Robot3TAction;
        private WaferRobotXAction m_Robot3XAction;
        private WaferRobotTAction m_Robot4TAction;
        private WaferRobotXAction m_Robot4XAction;
        private RobotMoveInfo m_robotMoveInfo;
        private WaferInfo m_PMAWafer;
        private WaferInfo m_PMBWafer;
        private WaferInfo m_PMCWafer;
        private WaferInfo m_PMDWafer;
        private WaferInfo m_LLAWafer;
        private WaferInfo m_LLBWafer;
        private WaferInfo m_TMBladeAWafer;
        private WaferInfo m_TMBladeBWafer;
        private List<string> m_RtDataKeys = new List<string>();
        private Dictionary<string, object> m_RtDataValues;
        private bool m_PMAIsInstalled;
        private bool m_PMBIsInstalled;
        private bool m_PMCIsInstalled;
        private bool m_PMDIsInstalled;
        private bool m_LLAIsInstalled;
        private bool m_LLBIsInstalled;
        private bool m_TMIsInstalled;
        private bool m_EFEMIsInstalled;
        private WaferInfo m_EFEMBladeAWafer;
        private WaferInfo m_EFEMBladeBWafer;
        private WaferInfo m_Aligner1Wafer;
        private int m_LP1WaferCount;
        private int m_LP2WaferCount;
        private int m_LP3WaferCount;
        private WaferAssociationInfo _lp1WaferAssociation;
        private WaferAssociationInfo _lp2WaferAssociation;
        private WaferAssociationInfo _lp3WaferAssociation;

        private int m_CycledWafer;
        private int m_CycleCountDisplay;

        private RobotPosition m_CurrentRobotPosition;

        private WaferInfo m_BladeAWafer;
        private WaferInfo m_BladeBWafer;

        private RecipeResult m_PMARecipeResult;
        private RecipeResult m_PMBRecipeResult;
        private RecipeResult m_PMCRecipeResult;
        private RecipeResult m_PMDRecipeResult;

        private string m_ATMModeIsOn;


        private float m_TMPressure;

        private string m_RouteState;
        private PressureType m_PressureType;

        #endregion

        #region  属性
        public PressureType PressureType
        {
            get { return m_PressureType; }
            set { SetProperty(ref m_PressureType, value); }
        }

        public bool TabIsChecked
        {
            get { return m_TabIsChecked; }
            set { SetProperty(ref m_TabIsChecked, value); }
        }
        public ModuleInfo LP1ModuleInfo
        {
            get { return m_LP1ModuleInfo; }
            set { SetProperty(ref m_LP1ModuleInfo, value); }
        }

        public ModuleInfo LLAModuleInfo
        {
            get { return m_LLAModuleInfo; }
            set { SetProperty(ref m_LLAModuleInfo, value); }
        }
        public ModuleInfo LLBModuleInfo
        {
            get { return m_LLBModuleInfo; }
            set { SetProperty(ref m_LLBModuleInfo, value); }
        }

        public ModuleInfo EFEMModuleInfo
        {
            get { return m_EFEMModuleInfo; }
            set { SetProperty(ref m_EFEMModuleInfo, value); }
        }
        public ModuleInfo TMModuleInfo
        {
            get { return m_TMModuleInfo; }
            set { SetProperty(ref m_TMModuleInfo, value); }
        }
        public ModuleInfo LP2ModuleInfo
        {
            get { return m_LP2ModuleInfo; }
            set { SetProperty(ref m_LP2ModuleInfo, value); }
        }
        public ModuleInfo LP3ModuleInfo
        {
            get { return m_LP3ModuleInfo; }
            set { SetProperty(ref m_LP3ModuleInfo, value); }
        }
        public WaferRobotTAction Robot1TAction
        {
            get { return m_Robot1TAction; }
            set { SetProperty(ref m_Robot1TAction, value); }
        }
        public WaferRobotXAction Robot1XAction
        {
            get { return m_Robot1XAction; }
            set { SetProperty(ref m_Robot1XAction, value); }
        }
        public WaferRobotTAction Robot2TAction
        {
            get { return m_Robot2TAction; }
            set { SetProperty(ref m_Robot2TAction, value); }
        }
        public WaferRobotXAction Robot2XAction
        {
            get { return m_Robot2XAction; }
            set { SetProperty(ref m_Robot2XAction, value); }
        }

        public WaferRobotTAction Robot3TAction
        {
            get { return m_Robot3TAction; }
            set { SetProperty(ref m_Robot3TAction, value); }
        }
        public WaferRobotXAction Robot3XAction
        {
            get { return m_Robot3XAction; }
            set { SetProperty(ref m_Robot3XAction, value); }
        }
        public WaferRobotTAction Robot4TAction
        {
            get { return m_Robot4TAction; }
            set { SetProperty(ref m_Robot4TAction, value); }
        }
        public WaferRobotXAction Robot4XAction
        {
            get { return m_Robot4XAction; }
            set { SetProperty(ref m_Robot4XAction, value); }
        }

        public RobotMoveInfo RobotMoveInfo
        {
            get { return m_robotMoveInfo; }
            set
            {
                RobotMoveInfoChanged(m_robotMoveInfo, value);
                //m_robotMoveInfo = value;
                SetProperty(ref m_robotMoveInfo, value);
            }
        }
        public WaferInfo LLAWafer
        {
            get { return m_LLAWafer; }
            set { SetProperty(ref m_LLAWafer, value); }
        }
        public WaferInfo LLBWafer
        {
            get { return m_LLBWafer; }
            set { SetProperty(ref m_LLBWafer, value); }
        }
        public WaferInfo PMAWafer
        {
            get { return m_PMAWafer; }
            set { SetProperty(ref m_PMAWafer, value); }
        }
        public WaferInfo PMBWafer
        {
            get { return m_PMBWafer; }
            set { SetProperty(ref m_PMBWafer, value); }
        }
        public WaferInfo PMCWafer
        {
            get { return m_PMCWafer; }
            set { SetProperty(ref m_PMCWafer, value); }
        }
        public WaferInfo PMDWafer
        {
            get { return m_PMDWafer; }
            set { SetProperty(ref m_PMDWafer, value); }
        }

        public WaferInfo TMBladeAWafer
        {
            get { return m_TMBladeAWafer; }
            set { SetProperty(ref m_TMBladeAWafer, value); }
        }
        public WaferInfo TMBladeBWafer
        {
            get { return m_TMBladeBWafer; }
            set { SetProperty(ref m_TMBladeBWafer, value); }
        }
        public Dictionary<string, object> RtDataValues
        {
            get { return m_RtDataValues; }
            set { SetProperty(ref m_RtDataValues, value); }
        }
        public bool PMAIsInstalled
        {
            get { return m_PMAIsInstalled; }
            set { SetProperty(ref m_PMAIsInstalled, value); }
        }
        public bool PMBIsInstalled
        {
            get { return m_PMBIsInstalled; }
            set { SetProperty(ref m_PMBIsInstalled, value); }
        }
        public bool PMCIsInstalled
        {
            get { return m_PMCIsInstalled; }
            set { SetProperty(ref m_PMCIsInstalled, value); }
        }
        public bool PMDIsInstalled
        {
            get { return m_PMDIsInstalled; }
            set { SetProperty(ref m_PMDIsInstalled, value); }
        }
        public bool LLAIsInstalled
        {
            get { return m_LLAIsInstalled; }
            set { SetProperty(ref m_LLAIsInstalled, value); }
        }
        public bool LLBIsInstalled
        {
            get { return m_LLBIsInstalled; }
            set { SetProperty(ref m_LLBIsInstalled, value); }
        }
        public bool TMIsInstalled
        {
            get { return m_TMIsInstalled; }
            set { SetProperty(ref m_TMIsInstalled, value); }
        }
        public bool EFEMIsInstalled
        {
            get { return m_EFEMIsInstalled; }
            set { SetProperty(ref m_EFEMIsInstalled, value); }
        }
        public WaferInfo EFEMBladeAWafer
        {
            get { return m_EFEMBladeAWafer; }
            set { SetProperty(ref m_EFEMBladeAWafer, value); }
        }
        public WaferInfo EFEMBladeBWafer
        {
            get { return m_EFEMBladeBWafer; }
            set { SetProperty(ref m_EFEMBladeBWafer, value); }
        }
        public WaferInfo Aligner1Wafer
        {
            get { return m_Aligner1Wafer; }
            set { SetProperty(ref m_Aligner1Wafer, value); }
        }
        public int LP1WaferCount
        {
            get { return m_LP1WaferCount; }
            set { SetProperty(ref m_LP1WaferCount, value); }
        }
        public int LP2WaferCount
        {
            get { return m_LP2WaferCount; }
            set { SetProperty(ref m_LP2WaferCount, value); }
        }
        public int LP3WaferCount
        {
            get { return m_LP3WaferCount; }
            set { SetProperty(ref m_LP3WaferCount, value); }
        }
        public WaferAssociationInfo LP1WaferAssociation
        {
            get { return _lp1WaferAssociation; }
            set { SetProperty(ref _lp1WaferAssociation, value); }
        }
        public WaferAssociationInfo LP2WaferAssociation
        {
            get { return _lp2WaferAssociation; }
            set { SetProperty(ref _lp2WaferAssociation, value); }
        }
        public WaferAssociationInfo LP3WaferAssociation
        {
            get { return _lp3WaferAssociation; }
            set { SetProperty(ref _lp3WaferAssociation, value); }
        }
        public int CycledWafer
        {
            get { return m_CycledWafer; }
            set { SetProperty(ref m_CycledWafer, value); }
        }
        public int CycleCountDisplay
        {
            get { return m_CycleCountDisplay; }
            set { SetProperty(ref m_CycleCountDisplay, value); }
        }
        public RobotMoveInfo m_EfemRobotMoveInfo;
        public RobotMoveInfo EfemRobotMoveInfo
        {
            get { return m_EfemRobotMoveInfo; }
            set
            {
                EFEMRobotMoveInfoChanged(m_EfemRobotMoveInfo, value);
                //m_EfemRobotMoveInfo = value;
                SetProperty(ref m_EfemRobotMoveInfo, value);

            }
        }
        public RobotPosition CurrentRobotPosition
        {
            get { return m_CurrentRobotPosition; }
            set { SetProperty(ref m_CurrentRobotPosition, value); }
        }
        public WaferInfo BladeAWafer
        {
            get { return m_BladeAWafer; }
            set { SetProperty(ref m_BladeAWafer, value); }
        }
        public WaferInfo BladeBWafer
        {
            get { return m_BladeBWafer; }
            set { SetProperty(ref m_BladeBWafer, value); }
        }
        public RecipeResult PMARecipeResult
        {
            get { return m_PMARecipeResult; }
            set { SetProperty(ref m_PMARecipeResult, value); }
        }
        public RecipeResult PMBRecipeResult
        {
            get { return m_PMBRecipeResult; }
            set { SetProperty(ref m_PMBRecipeResult, value); }
        }
        public RecipeResult PMCRecipeResult
        {
            get { return m_PMCRecipeResult; }
            set { SetProperty(ref m_PMCRecipeResult, value); }
        }
        public RecipeResult PMDRecipeResult
        {
            get { return m_PMDRecipeResult; }
            set { SetProperty(ref m_PMDRecipeResult, value); }
        }
        public string ATMModeIsOn
        {
            get { return m_ATMModeIsOn; }
            set { SetProperty(ref m_ATMModeIsOn, value); }
        }

        public float TMPressure
        {
            get { return m_TMPressure; }
            set { SetProperty(ref m_TMPressure, value); }
        }
        public string RouteState
        {
            get { return m_RouteState; }
            set { SetProperty(ref m_RouteState, value); }
        }
        #endregion

        #region 命令
        private DelegateCommand _LoadCommand;
        public DelegateCommand LoadCommand =>
            _LoadCommand ?? (_LoadCommand = new DelegateCommand(OnLoad));

        private DelegateCommand<object> _LoadWaferCommand;
        public DelegateCommand<object> LoadWaferCommand =>
            _LoadWaferCommand ?? (_LoadWaferCommand = new DelegateCommand<object>(OnLoadWafer));

        private DelegateCommand<object> _UnLoadWaferCommand;
        public DelegateCommand<object> UnLoadWaferCommand =>
            _UnLoadWaferCommand ?? (_UnLoadWaferCommand = new DelegateCommand<object>(OnUnLoadWafer));

        private DelegateCommand<object> _SelectAllCommand;
        public DelegateCommand<object> SelectAllCommand =>
            _SelectAllCommand ?? (_SelectAllCommand = new DelegateCommand<object>(OnSelectAll));

        private DelegateCommand<object> _UnSelectAllCommand;
        public DelegateCommand<object> UnSelectAllCommand =>
            _UnSelectAllCommand ?? (_UnSelectAllCommand = new DelegateCommand<object>(OnUnSelectAll));

        private DelegateCommand<object> _StartCommand;
        public DelegateCommand<object> StartCommand =>
            _StartCommand ?? (_StartCommand = new DelegateCommand<object>(OnStart));

        private DelegateCommand<object> _StopCommand;
        public DelegateCommand<object> StopCommand =>
            _StopCommand ?? (_StopCommand = new DelegateCommand<object>(OnStop));

        private DelegateCommand<object> _AbortCommand;
        public DelegateCommand<object> AbortCommand =>
            _AbortCommand ?? (_AbortCommand = new DelegateCommand<object>(OnAbort));


        private DelegateCommand _HomeAllCommand;
        public DelegateCommand HomeAllCommand =>
            _HomeAllCommand ?? (_HomeAllCommand = new DelegateCommand(OnHomeAll));


        private DelegateCommand _ResumeAllJobCommand;
        public DelegateCommand ResumeAllJobCommand =>
            _ResumeAllJobCommand ?? (_ResumeAllJobCommand = new DelegateCommand(OnResumeAllJob));

        private DelegateCommand _AbortAllCommand;
        public DelegateCommand AbortAllCommand =>
            _AbortAllCommand ?? (_AbortAllCommand = new DelegateCommand(OnAbortAll));

        private DelegateCommand _ReturnAllWaferCommand;
        public DelegateCommand ReturnAllWaferCommand =>
            _ReturnAllWaferCommand ?? (_ReturnAllWaferCommand = new DelegateCommand(OnReturnAllWafer));

        private DelegateCommand<object> _SetSequenceCommand;
        public DelegateCommand<object> SetSequenceCommand =>
            _SetSequenceCommand ?? (_SetSequenceCommand = new DelegateCommand<object>(OnSetSequence));

        private DelegateCommand<object> _CreateJobCommand;
        public DelegateCommand<object> CreateJobCommand =>
            _CreateJobCommand ?? (_CreateJobCommand = new DelegateCommand<object>(OnCreateJob));

        private DelegateCommand<object> _AbortJobCommand;
        public DelegateCommand<object> AbortJobCommand =>
            _AbortJobCommand ?? (_AbortJobCommand = new DelegateCommand<object>(OnAbortJob));

        private DelegateCommand _EnableAutoCommand;
        public DelegateCommand EnableAutoCommand =>
            _EnableAutoCommand ?? (_EnableAutoCommand = new DelegateCommand(OnEnableAuto));

        private DelegateCommand _EnableManualCommand;
        public DelegateCommand EnableManualCommand =>
            _EnableManualCommand ?? (_EnableManualCommand = new DelegateCommand(OnEnableManual));


        public bool SwitchFlag;

        #endregion

        #region 构造函数
        public OperationOverViewModel()
        {
            DispatcherTimer timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(0.1);
            addDataKeys();
            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);
            timer.Tick += Timer_Tick;
            timer.Start();

            string allModules = QueryDataClient.Instance.Service.GetConfig($"System.InstalledModules").ToString();
            PMAIsInstalled = allModules.Contains("PMA");
            PMBIsInstalled = allModules.Contains("PMB");
            PMCIsInstalled = allModules.Contains("PMC");
            PMDIsInstalled = allModules.Contains("PMD");
            LLAIsInstalled = allModules.Contains("LLA");
            LLBIsInstalled = allModules.Contains("LLB");
            EFEMIsInstalled = allModules.Contains("EFEM");
            TMIsInstalled = allModules.Contains("TM");
            



            SwitchFlag = false;

            ATMModeIsOn = Convert.ToBoolean(QueryDataClient.Instance.Service.GetConfig("System.IsATMMode")) == true ? "ATM Mode On" : "ATM Mode Off";

            LOG.Info("开启UI界面");
        }


        #endregion

        #region 命令方法
        private void OnLoad()
        {
            if (!SwitchFlag)
            {
                LP1WaferAssociation = new WaferAssociationInfo();
                LP3WaferAssociation = new WaferAssociationInfo();
                LP2WaferAssociation = new WaferAssociationInfo();
                LP1WaferAssociation.ModuleData = ModuleManager.ModuleInfos["LP1"];
                LP2WaferAssociation.ModuleData = ModuleManager.ModuleInfos["LP2"];
                LP3WaferAssociation.ModuleData = ModuleManager.ModuleInfos["LP3"];
                SwitchFlag = true;
                object obj = QueryDataClient.Instance.Service.GetData("System.PressureUnitType");
                PressureType = (PressureType)Convert.ToInt32(obj);
            }

        }

        private void OnLoadWafer(object obj)
        {
            InvokeClient.Instance.Service.DoOperation($"{obj.ToString()}.Load", ModuleManager.ModuleInfos[obj.ToString()].ModuleID);
        }
        private void OnUnLoadWafer(object obj)
        {
            InvokeClient.Instance.Service.DoOperation($"{obj.ToString()}.Unload", ModuleManager.ModuleInfos[obj.ToString()].ModuleID);
        }
        private void OnSelectAll(object obj)
        {
            var info = obj as WaferAssociationInfo;

            var module = info.ModuleData.ModuleID;

            if (CommonFunction.GetValue<bool>(RtDataValues, $"{module}.IsLoaded"))
            {
                info.SlotFrom = 1;
                info.SlotTo = 25;
                AssociateSequence(info, true);
            }
        }
        private void OnUnSelectAll(object obj)
        {
            var info = obj as WaferAssociationInfo;

            var module = info.ModuleData.ModuleID;

            info.SlotFrom = 1;
            info.SlotTo = 25;
            AssociateSequence(info, false);
        }
        private void OnStart(object obj)
        {
            var info = obj as WaferAssociationInfo;
            InvokeClient.Instance.Service.DoOperation("System.StartJob", info.LotId);
            LOG.Info("System,Start Job");

        }
        private void OnStop(object obj)
        {
            var info = obj as WaferAssociationInfo;
            InvokeClient.Instance.Service.DoOperation("System.AbortJob", info.JobID);
            LOG.Info($"System,Stop Job{info.JobID}");
        }
        private void OnAbort(object obj)
        {
            var info = obj as WaferAssociationInfo;

            InvokeClient.Instance.Service.DoOperation("System.StopJob", info.JobID);
            LOG.Info($"System,Stop Job{info.JobID}");

        }
        private void OnHomeAll()
        {
            InvokeClient.Instance.Service.DoOperation("System.HomeAll");
            LOG.Info("System,Home All");
        }

        private void OnResumeAllJob()
        {
            var t = CommonFunction.GetValue<List<string>>(RtDataValues, "Scheduler.PjNameList");
            if (t == null && t.Count == 0)
            {
                return;
            }
            if (CommonFunction.GetValue<int>(RtDataValues, "EquipmentStatus") == 4)
            {
                t.ForEach(x =>
                {
                    InvokeClient.Instance.Service.DoOperation("System.ResumeJob", x);
                });
                LOG.Info("System,Resume All Job");

            }
            else
            {
                t.ForEach(x =>
                {
                    InvokeClient.Instance.Service.DoOperation("System.PauseJob", x);
                });
                LOG.Info("System,Pause All Job");
            }
        }
        private void OnAbortAll()
        {
            InvokeClient.Instance.Service.DoOperation("System.Abort");
            LOG.Info("System, Abort");

        }
        private void OnReturnAllWafer()
        {
            //Dialog
            WaferDialogView dialog = new WaferDialogView()
            {
                Owner = Application.Current.MainWindow,
            };
            dialog.Height = 300;
            dialog.Width = 400;
            double angel = 0;
            double coolingtime = 0;
            string message = "Please Confirm Return Wafer";
            WaferDialogViewModel vm = new WaferDialogViewModel();
            vm.ConfirmText = message;
            dialog.DataContext = vm;
            if (dialog.ShowDialog() == true)
            {
                if ((bool)dialog.AlignFlag == true && !string.IsNullOrEmpty(dialog.Angle))
                {
                    angel = Convert.ToDouble(dialog.Angle);
                }

                if ((bool)dialog.CoolingFlag == true && !string.IsNullOrEmpty(dialog.CoolingTime))
                {
                    coolingtime = Convert.ToDouble(dialog.CoolingTime);
                }

                InvokeClient.Instance.Service.DoOperation("System.ReturnAllWafer", dialog.CoolingFlag, coolingtime, dialog.AlignFlag, angel);
            }
            LOG.Info("System,Return All Wafer");
        }

        private void OnSetSequence(object obj)
        {
            var info = obj as WaferInfo;
            bool flag = info.SequenceName != "" ? false : true;
            if (info.ModuleID == "LP1" && (CommonFunction.GetValue<bool>(RtDataValues, "LP1.IsLoaded")))
            {
                AssociateSequence(LP1WaferAssociation, flag, info.SlotID);
            }
            else if (info.ModuleID == "LP2" && (CommonFunction.GetValue<bool>(RtDataValues, "LP2.IsLoaded")))
            {
                AssociateSequence(LP2WaferAssociation, flag, info.SlotID);
            }
            else if (info.ModuleID == "LP3" && (CommonFunction.GetValue<bool>(RtDataValues, "LP3.IsLoaded")))
            {
                AssociateSequence(LP3WaferAssociation, flag, info.SlotID);
            }
        }
        private void OnCreateJob(object obj)
        {
            var info = obj as WaferAssociationInfo;
            List<string> slotSequence = new List<string>();
            info.ModuleData.WaferManager.Wafers.ForEach(key => { slotSequence.Insert(0, key.SequenceName); });

            string jobId = info.LotId.Trim();
            //if (string.IsNullOrEmpty(jobId))
            //    jobId = "CJ_Local_" + info.ModuleData.ModuleID;
            //info.LotId = jobId;
            //info.JobID = jobId;
            //info.JobStatus = "WaitingForStart";
            info.LotIdSaved = true;

            Dictionary<string, object> param = new Dictionary<string, object>()
            {
                {"JobId", ""},
                {"Module", info.ModuleData.ModuleID},
                {"SlotSequence", slotSequence.ToArray()},
                {"AutoStart", true},
                { "PreCleanRecipeName",info.PreCleanRecipeName},
                { "PostCleanRecipeName",info.PostCleanRecipeName}
            };
            InvokeClient.Instance.Service.DoOperation("System.CreateJob", param);
        }
        private void OnAbortJob(object obj)
        {
            InvokeClient.Instance.Service.DoOperation("System.AbortJob", obj.ToString());
        }
        private void OnEnableAuto()
        {
            InvokeClient.Instance.Service.DoOperation("System.SetAutoMode");
        }
        private void OnEnableManual()
        {
            InvokeClient.Instance.Service.DoOperation("System.SetManualMode");
        }
        #endregion

        #region 私有方法
        private void Timer_Tick(object sender, EventArgs e)
        {
            LP1ModuleInfo = ModuleManager.ModuleInfos["LP1"];
            LP2ModuleInfo = ModuleManager.ModuleInfos["LP2"];
            LP3ModuleInfo = ModuleManager.ModuleInfos["LP3"];
            EFEMModuleInfo = ModuleManager.ModuleInfos["EfemRobot"];
            TMModuleInfo = ModuleManager.ModuleInfos["TMRobot"];
            BladeAWafer = ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[0];
            BladeBWafer = ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[1];

            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);

            if (LLAIsInstalled == true)
            {
                LLAModuleInfo = ModuleManager.ModuleInfos["LLA"];
                LLAWafer = ModuleManager.ModuleInfos["LLA"].WaferManager.Wafers.FirstOrDefault(x => x.WaferStatus != 0);

            }
            if (LLBIsInstalled == true)
            {
                LLBModuleInfo = ModuleManager.ModuleInfos["LLB"];
                LLBWafer = ModuleManager.ModuleInfos["LLB"].WaferManager.Wafers.FirstOrDefault(x => x.WaferStatus != 0);
            }
            if (PMAIsInstalled == true)
            {
                PMAWafer = ModuleManager.ModuleInfos["PMA"].WaferManager.Wafers[0];
                PMARecipeResult = CommonFunction.GetValue<RecipeResult>(RtDataValues, $"PMA.CurrentRecipeResult");
            }
            if (PMBIsInstalled == true)
            {
                PMBWafer = ModuleManager.ModuleInfos["PMB"].WaferManager.Wafers[0];
                PMBRecipeResult = CommonFunction.GetValue<RecipeResult>(RtDataValues, $"PMB.CurrentRecipeResult");

            }
            if (PMCIsInstalled == true)
            {
                PMCWafer = ModuleManager.ModuleInfos["PMC"].WaferManager.Wafers[0];
                PMCRecipeResult = CommonFunction.GetValue<RecipeResult>(RtDataValues, $"PMC.CurrentRecipeResult");
            }
            if (PMDIsInstalled == true)
            {
                PMDWafer = ModuleManager.ModuleInfos["PMD"].WaferManager.Wafers[0];
                PMDRecipeResult = CommonFunction.GetValue<RecipeResult>(RtDataValues, $"PMD.CurrentRecipeResult");

            }

            if (TMIsInstalled == true)
            {
                TMBladeAWafer = ModuleManager.ModuleInfos["TMRobot"].WaferManager.Wafers[0];
                TMBladeBWafer = ModuleManager.ModuleInfos["TMRobot"].WaferManager.Wafers[1];
                TMPressure = CommonFunction.GetValue<float>(RtDataValues, $"TM.TMProcessGauge.Value");
            }

            if (EFEMIsInstalled == true)
            {
                EFEMBladeAWafer = ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[0];
                EFEMBladeBWafer = ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[1];
                Aligner1Wafer = ModuleManager.ModuleInfos["Aligner1"].WaferManager.Wafers[0];
                ControlJobInfo lp1Cj = CommonFunction.GetValue<ControlJobInfo>(RtDataValues, "LP1.CurrentControlJob");
                UPdateWaferAssociation(LP1WaferAssociation, lp1Cj);
                ControlJobInfo lp2Cj = CommonFunction.GetValue<ControlJobInfo>(RtDataValues, "LP2.CurrentControlJob");
                UPdateWaferAssociation(LP2WaferAssociation, lp2Cj);
                ControlJobInfo lp3Cj = CommonFunction.GetValue<ControlJobInfo>(RtDataValues, "LP3.CurrentControlJob");
                UPdateWaferAssociation(LP3WaferAssociation, lp3Cj);
            }

            RobotMoveInfo = (RobotMoveInfo)QueryDataClient.Instance.Service.GetData("TM.RobotMoveAction");
            EfemRobotMoveInfo = (RobotMoveInfo)QueryDataClient.Instance.Service.GetData("EFEM.RobotMoveAction");
            LP1WaferCount = LP1ModuleInfo.WaferManager.Wafers.Where(x => x.WaferStatus != 0).Count();
            LP2WaferCount = LP2ModuleInfo.WaferManager.Wafers.Where(x => x.WaferStatus != 0).Count();
            LP3WaferCount = LP3ModuleInfo.WaferManager.Wafers.Where(x => x.WaferStatus != 0).Count();
            if (CommonFunction.GetValue<int>(RtDataValues, "EquipmentStatus") == 4)
            {
                RouteState = "Resume";
            }
            else
            {
                RouteState = "Pause";
            }
        }
        /// <summary>
        /// 更新Wafer情况
        /// </summary>
        /// <param name="info"></param>
        /// <param name="cjInfo"></param>
        private void UPdateWaferAssociation(WaferAssociationInfo info, ControlJobInfo cjInfo)
        {
            if (cjInfo != null)
            {
                info.LotId = cjInfo.Name;
                info.JobID = cjInfo.Name;
                info.JobStatus = cjInfo.State.ToString();
                if (cjInfo.SequenceNameList != null)
                {
                    for (int i = 0; i < cjInfo.SequenceNameList.Length; i++)
                    {
                        info.ModuleData.WaferManager.Wafers[24 - i].SequenceName = cjInfo.SequenceNameList[i];
                    }
                }
                info.PreCleanRecipeName = cjInfo.PreJobClean;
                info.PostCleanRecipeName = cjInfo.PostJobClean;
            }
            else
            {
                if (!string.IsNullOrEmpty(info.JobID))
                {
                    info.LotId = "";
                    info.JobID = "";
                    info.JobStatus = "";
                    info.PreCleanRecipeName = "";
                    info.PostCleanRecipeName = "";
                    AssociateSequence(info, false);
                }
            }
        }
        private async void RobotMoveInfoChanged(RobotMoveInfo oldValue, RobotMoveInfo newValue)
        {
            string RobotTarget;
            if (oldValue == null || newValue == null)
            {
                return;
            }

            #region Rotating
            if ((oldValue.Action == RobotAction.None || oldValue.ArmTarget != newValue.ArmTarget) && (newValue.Action == RobotAction.Rotating))
            {
                var TMRobotMoveActionBladeTarget = newValue.BladeTarget;
                if (TMRobotMoveActionBladeTarget != null)
                {
                    RobotTarget = TMRobotMoveActionBladeTarget.ToString();
                }
                else
                {
                    return;
                }
                var values = RobotTarget.Split('.');
                var arm = values[0];
                var module = values[1];
                if (arm == "ArmA")
                {
                    Robot1TAction = (WaferRobotTAction)Enum.Parse(typeof(WaferRobotTAction), module, true);
                }
                else if (arm == "ArmB")
                {
                    Robot2TAction = (WaferRobotTAction)Enum.Parse(typeof(WaferRobotTAction), module, true);
                }
            }
            #endregion

            #region pick 和 place LL
            else if ((oldValue.Action == RobotAction.None || oldValue.ArmTarget != newValue.ArmTarget) && (newValue.Action == RobotAction.Placing || newValue.Action == RobotAction.Picking))
            {
                var TMRobotMoveActionBladeTarget = newValue.BladeTarget;
                if (TMRobotMoveActionBladeTarget != null)
                {
                    RobotTarget = TMRobotMoveActionBladeTarget.ToString();
                }
                else
                {
                    return;
                }
                var values = RobotTarget.Split('.');
                var arm = values[0];
                var module = values[1];

                if (arm == "ArmA")
                {
                    var waferRobotTAction = (WaferRobotTAction)Enum.Parse(typeof(WaferRobotTAction), module, true);
                    if (waferRobotTAction != Robot1TAction)
                    {
                        Robot1TAction = waferRobotTAction;
                    }
                    else
                    {
                        //await Task.Delay(100);
                    }
                    await Task.Delay(600);

                    //Robot1TAction = (WaferRobotTAction)Enum.Parse(typeof(WaferRobotTAction), module, true);
                    //await Task.Delay(600);
                    Robot1XAction = WaferRobotXAction.Extend;
                    while ((newValue.Action == RobotAction.Placing && ModuleManager.ModuleInfos["TMRobot"].WaferManager.Wafers[0].WaferStatus != 0) || (newValue.Action == RobotAction.Picking && ModuleManager.ModuleInfos["TMRobot"].WaferManager.Wafers[0].WaferStatus == 0))
                    {
                        await Task.Delay(100);
                    }
                    Robot1XAction = WaferRobotXAction.Retract;
                }
                else if (arm == "ArmB")
                {
                    var waferRobotTAction = (WaferRobotTAction)Enum.Parse(typeof(WaferRobotTAction), module, true);
                    if (waferRobotTAction != Robot2TAction)
                    {
                        Robot2TAction = waferRobotTAction;
                    }
                    else
                    {
                        //await Task.Delay(100);
                    }
                    await Task.Delay(600);

                    //Robot2TAction = (WaferRobotTAction)Enum.Parse(typeof(WaferRobotTAction), module, true);
                    //await Task.Delay(600);
                    Robot2XAction = WaferRobotXAction.Extend;
                    while ((newValue.Action == RobotAction.Placing && ModuleManager.ModuleInfos["TMRobot"].WaferManager.Wafers[1].WaferStatus != 0) || (newValue.Action == RobotAction.Picking && ModuleManager.ModuleInfos["TMRobot"].WaferManager.Wafers[1].WaferStatus == 0))
                    {
                        await Task.Delay(100);
                    }
                    Robot2XAction = WaferRobotXAction.Retract;
                }
            }

            #endregion

            #region pick 和 place pm
            else if ((oldValue.Action == RobotAction.None || oldValue.ArmTarget != newValue.ArmTarget) && newValue.Action == RobotAction.Extending)
            {
                var TMRobotMoveActionBladeTarget = newValue.BladeTarget;
                if (TMRobotMoveActionBladeTarget != null)
                {
                    RobotTarget = TMRobotMoveActionBladeTarget.ToString();
                }
                else
                {
                    return;
                }
                var values = RobotTarget.Split('.');
                var arm = values[0];
                var module = values[1];
                if (arm == "ArmA")
                {
                    var waferRobotTAction = (WaferRobotTAction)Enum.Parse(typeof(WaferRobotTAction), module, true);
                    if (waferRobotTAction != Robot1TAction)
                    {
                        Robot1TAction = waferRobotTAction;
                    }
                    else
                    {
                        // await Task.Delay(100);
                    }
                    await Task.Delay(600);

                    Robot1XAction = WaferRobotXAction.Extend;
                }
                else if (arm == "ArmB")
                {
                    var waferRobotTAction = (WaferRobotTAction)Enum.Parse(typeof(WaferRobotTAction), module, true);
                    if (waferRobotTAction != Robot2TAction)
                    {
                        Robot2TAction = waferRobotTAction;
                    }
                    else
                    {
                        // await Task.Delay(100);
                    }
                    await Task.Delay(600);

                    Robot2XAction = WaferRobotXAction.Extend;
                }
            }
            else if ((oldValue.Action == RobotAction.None || oldValue.ArmTarget != newValue.ArmTarget) && newValue.Action == RobotAction.Retracting)
            {
                var TMRobotMoveActionBladeTarget = newValue.BladeTarget;
                if (TMRobotMoveActionBladeTarget != null)
                {
                    RobotTarget = TMRobotMoveActionBladeTarget.ToString();
                }
                else
                {
                    return;
                }
                var values = RobotTarget.Split('.');
                var arm = values[0];
                if (arm == "ArmA")
                {
                    Robot1XAction = WaferRobotXAction.Retract;
                }
                else if (arm == "ArmB")
                {
                    Robot2XAction = WaferRobotXAction.Retract;
                }
            }
            #endregion

            #region Home
            else if (oldValue.Action == RobotAction.None && newValue.Action == RobotAction.Homing)
            {
                if (Robot1XAction == WaferRobotXAction.Extend)
                {
                    Robot1XAction = WaferRobotXAction.Retract;
                }
                if (Robot2XAction == WaferRobotXAction.Extend)
                {
                    Robot2XAction = WaferRobotXAction.Retract;
                }
                await Task.Delay(2000);
                if (Robot1TAction != WaferRobotTAction.T_Origin)
                {
                    Robot1TAction = WaferRobotTAction.T_Origin;
                }
                if (Robot2TAction != WaferRobotTAction.T_Origin)
                {
                    Robot2TAction = WaferRobotTAction.T_Origin;
                }
            }

            #endregion

        }
        private async void EFEMRobotMoveInfoChanged(RobotMoveInfo oldValue, RobotMoveInfo newValue)
        {
            string RobotTarget;
            if (oldValue == null || newValue == null)
            {
                return;
            }
            #region pick 和 place LL

            if ((oldValue.Action == RobotAction.None || oldValue.ArmTarget != newValue.ArmTarget) && (newValue.Action == RobotAction.Placing || newValue.Action == RobotAction.Picking))
            {
                var TMRobotMoveActionBladeTarget = newValue.BladeTarget;
                if (TMRobotMoveActionBladeTarget != null)
                {
                    RobotTarget = TMRobotMoveActionBladeTarget.ToString();
                }
                else
                {
                    return;
                }
                var values = RobotTarget.Split('.');
                var arm = values[0];
                var module = values[1];

                if (arm == "ArmA")
                {
                    var robot3Robot3TAction = (WaferRobotTAction)Enum.Parse(typeof(WaferRobotTAction), module, true);
                    //await Task.Delay(1000);
                    await ChangePosition(robot3Robot3TAction);
                    if (Robot3TAction != robot3Robot3TAction)
                    {
                        Robot3TAction = robot3Robot3TAction;
                        await Task.Delay(600);
                    }


                    Robot3XAction = WaferRobotXAction.Extend;
                    while ((newValue.Action == RobotAction.Placing && ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[0].WaferStatus != 0) || (newValue.Action == RobotAction.Picking && ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[0].WaferStatus == 0))
                    {
                        await Task.Delay(100);
                    }
                    Robot3XAction = WaferRobotXAction.Retract;
                }
                else if (arm == "ArmB")
                {
                    var robot4Robot4TAction = (WaferRobotTAction)Enum.Parse(typeof(WaferRobotTAction), module, true);
                    //await Task.Delay(1000);
                    await ChangePosition(robot4Robot4TAction);
                    if (Robot4TAction != robot4Robot4TAction)
                    {
                        Robot4TAction = robot4Robot4TAction;
                        await Task.Delay(600);
                    }

                    //ChangePosition(Robot4TAction);
                    //await Task.Delay(2000);
                    Robot4XAction = WaferRobotXAction.Extend;
                    while ((newValue.Action == RobotAction.Placing && ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[1].WaferStatus != 0) || (newValue.Action == RobotAction.Picking && ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[1].WaferStatus == 0))
                    {
                        await Task.Delay(100);
                    }
                    Robot4XAction = WaferRobotXAction.Retract;
                }
            }

            #endregion

            #region pick 和 place pm
            if (oldValue.Action == RobotAction.None && newValue.Action == RobotAction.Extending)
            {
                var TMRobotMoveActionBladeTarget = newValue.BladeTarget;
                if (TMRobotMoveActionBladeTarget != null)
                {
                    RobotTarget = TMRobotMoveActionBladeTarget.ToString();
                }
                else
                {
                    return;
                }
                var values = RobotTarget.Split('.');
                var arm = values[0];
                var module = values[1];
                if (arm == "ArmA")
                {
                    Robot3TAction = (WaferRobotTAction)Enum.Parse(typeof(WaferRobotTAction), module, true);
                    await Task.Delay(1500);
                    //ChangePosition(Robot3TAction);
                    //await Task.Delay(2000);
                    Robot3XAction = WaferRobotXAction.Extend;
                }
                else if (arm == "ArmB")
                {
                    Robot4TAction = (WaferRobotTAction)Enum.Parse(typeof(WaferRobotTAction), module, true);
                    await Task.Delay(1500);
                    //ChangePosition(Robot4TAction);
                    //await Task.Delay(2000);
                    Robot4XAction = WaferRobotXAction.Extend;
                }

            }
            if (oldValue.Action == RobotAction.None && newValue.Action == RobotAction.Retracting)
            {
                var TMRobotMoveActionBladeTarget = newValue.BladeTarget;
                if (TMRobotMoveActionBladeTarget != null)
                {
                    RobotTarget = TMRobotMoveActionBladeTarget.ToString();
                }
                else
                {
                    return;
                }
                var values = RobotTarget.Split('.');
                var arm = values[0];
                if (arm == "ArmA")
                {

                    Robot3XAction = WaferRobotXAction.Retract;
                    await Task.Delay(3000);
                    //ChangePosition(Robot3TAction);
                    //await Task.Delay(2000);
                }
                else if (arm == "ArmB")
                {
                    Robot4XAction = WaferRobotXAction.Retract;
                    await Task.Delay(3000);
                    //ChangePosition(Robot3TAction);
                    //await Task.Delay(2000);
                }

            }
            #endregion

            #region Home
            else if (oldValue.Action == RobotAction.None && newValue.Action == RobotAction.Homing)
            {
                if (Robot3XAction == WaferRobotXAction.Extend)
                {
                    Robot3XAction = WaferRobotXAction.Retract;
                }
                if (Robot4XAction == WaferRobotXAction.Extend)
                {
                    Robot4XAction = WaferRobotXAction.Retract;
                }
                if (Robot3TAction != WaferRobotTAction.T_Origin)
                {
                    Robot3TAction = WaferRobotTAction.T_Origin;
                }
                if (Robot4TAction != WaferRobotTAction.T_Origin)
                {
                    Robot4TAction = WaferRobotTAction.T_Origin;
                }
                await Task.Delay(1000);
                await ChangePosition(WaferRobotTAction.T_Origin);

            }

            #endregion

        }

        private void addDataKeys()
        {
            m_RtDataKeys.Add("PMA.IsSlitDoorClosed");
            m_RtDataKeys.Add("PMA.CurrentRecipeResult");
            m_RtDataKeys.Add("PMA.IsOnline");
            m_RtDataKeys.Add("PMA.CalculationPressure");
            m_RtDataKeys.Add("PMA.IsLidClosed");
            m_RtDataKeys.Add("PMB.IsSlitDoorClosed");
            m_RtDataKeys.Add("PMB.CurrentRecipeResult");
            m_RtDataKeys.Add("PMB.IsOnline");
            m_RtDataKeys.Add("PMB.CalculationPressure");
            m_RtDataKeys.Add("PMB.IsLidClosed");
            m_RtDataKeys.Add("PMC.IsSlitDoorClosed");
            m_RtDataKeys.Add("PMC.CurrentRecipeResult");
            m_RtDataKeys.Add("PMC.IsOnline");
            m_RtDataKeys.Add("PMC.CalculationPressure");
            m_RtDataKeys.Add("PMC.IsLidClosed");
            m_RtDataKeys.Add("PMD.IsSlitDoorClosed");
            m_RtDataKeys.Add("PMD.CurrentRecipeResult");
            m_RtDataKeys.Add("PMD.IsOnline");
            m_RtDataKeys.Add("PMD.CalculationPressure");
            m_RtDataKeys.Add("PMD.IsLidClosed");
            m_RtDataKeys.Add("TM.LLATSlitDoor.IsClosed");
            m_RtDataKeys.Add("TM.LLBTSlitDoor.IsClosed");
            m_RtDataKeys.Add("TM.LLAESlitDoor.IsClosed");
            m_RtDataKeys.Add("TM.LLBESlitDoor.IsClosed");
            m_RtDataKeys.Add("TM.IsOnline");
            m_RtDataKeys.Add("TM.TMProcessGauge.Value");
            m_RtDataKeys.Add("TM.TMATMSwitch.Value");
            m_RtDataKeys.Add("TM.TMVacSwitch.Value");
            m_RtDataKeys.Add("TM.TMProcessGauge.Value");
            m_RtDataKeys.Add("TM.TMLidClosed");
            m_RtDataKeys.Add("TM.LLALidClosed");
            m_RtDataKeys.Add("TM.LLBLidClosed");

            m_RtDataKeys.Add("TM.PMASlitDoor.IsClosed");
            m_RtDataKeys.Add("TM.PMBSlitDoor.IsClosed");
            m_RtDataKeys.Add("TM.PMCSlitDoor.IsClosed");
            m_RtDataKeys.Add("TM.PMDSlitDoor.IsClosed");
            m_RtDataKeys.Add("LLA.IsOnline");
            m_RtDataKeys.Add($"TM.LLAPressureGauge.Value");
            m_RtDataKeys.Add($"TM.LLAVacSwitch.Value");
            m_RtDataKeys.Add($"TM.LLAATMSwitch.Value");
            m_RtDataKeys.Add("LLB.IsOnline");
            m_RtDataKeys.Add($"TM.LLBPressureGauge.Value");
            m_RtDataKeys.Add($"TM.LLBVacSwitch.Value");
            m_RtDataKeys.Add($"TM.LLBATMSwitch.Value");
            m_RtDataKeys.Add("LP1.IsLoaded");
            m_RtDataKeys.Add("LP2.IsLoaded");
            m_RtDataKeys.Add("LP3.IsLoaded");
            m_RtDataKeys.Add("LP1.CassettePlaced");
            m_RtDataKeys.Add("LP2.CassettePlaced");
            m_RtDataKeys.Add("LP3.CassettePlaced");
            m_RtDataKeys.Add("LP1.CurrentControlJob");
            m_RtDataKeys.Add("LP2.CurrentControlJob");
            m_RtDataKeys.Add("LP3.CurrentControlJob");
            m_RtDataKeys.Add("EFEM.IsOnline");
            m_RtDataKeys.Add("System.IsAutoMode");
            m_RtDataKeys.Add("System.IsBusy");
            m_RtDataKeys.Add("Scheduler.CycledCount");
            m_RtDataKeys.Add("Scheduler.CycledWafer");
            m_RtDataKeys.Add("Scheduler.CycleSetPoint");
            m_RtDataKeys.Add("Scheduler.Throughput");
            m_RtDataKeys.Add("EquipmentStatus");
            m_RtDataKeys.Add("Scheduler.PjNameList");
        }
        private void AssociateSequence(WaferAssociationInfo info, bool flag, int slot = -1)
        {
            List<WaferInfo> wafers = info.ModuleData.WaferManager.Wafers;

            if (slot >= 0) //by wafer
            {
                int index = wafers.Count - slot - 1;
                if (index < wafers.Count)
                {
                    if (flag && HasWaferOnSlot(wafers, index))
                        wafers[index].SequenceName = info.SequenceName;
                    else
                        wafers[index].SequenceName = string.Empty;
                }
            }
            else //by from-to
            {
                for (int i = info.SlotFrom - 1; i < info.SlotTo; i++)
                {
                    int index = wafers.Count - i - 1;
                    if (index < wafers.Count)
                    {
                        if (flag && HasWaferOnSlot(wafers, index))
                            wafers[index].SequenceName = info.SequenceName;
                        else
                            wafers[index].SequenceName = string.Empty;
                    }
                }
            }

            switch (info.ModuleData.ModuleID)
            {
                case "LP1":
                    LP1WaferAssociation = info;
                    break;
                case "LP2":
                    LP2WaferAssociation = info;
                    break;
                case "LP3":
                    LP3WaferAssociation = info;
                    break;
            }
        }
        private bool HasWaferOnSlot(List<WaferInfo> wafers, int index)
        {
            if (wafers[index].WaferStatus == 0)
                return false;

            return true;
        }
        private async Task ChangePosition(WaferRobotTAction waferRobotTAction)
        {
            await Task.Delay(500);
            int delay = 500;
            if (waferRobotTAction == WaferRobotTAction.LP1)
            {
                CurrentRobotPosition = RobotPosition.Left;
                await Task.Delay(delay);
            }
            else if (waferRobotTAction == WaferRobotTAction.LP3)
            {
                CurrentRobotPosition = RobotPosition.Right;
                await Task.Delay(delay);
            }
            else if (waferRobotTAction == WaferRobotTAction.LP2)
            {
                CurrentRobotPosition = RobotPosition.Middle;
                await Task.Delay(delay);
            }
            else
            {
                CurrentRobotPosition = RobotPosition.Origin;
                await Task.Delay(delay);
            }
        }
        #endregion
    }
}