Virgo_Mask/VirgoUI/Models/Operate/Overview/OverViewModel.cs

using Aitex.Core.Common.DeviceData;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using Bolt.Toolkit.Wpf.Data.Enum;
using Caliburn.Micro;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.RecipeCenter;
using OpenSEMI.ClientBase;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Windows;
using System.Windows.Input;
using Aitex.Core.UI.MVVM;
using VirgoCommon;
using VirgoUI.Client.Dialog;
using VirgoUI.Client.Models.Operate.WaferAssociation;
using VirgoUI.Client.Models.Platform.LoadPort;
using VirgoUI.Client.Models.Recipe;
using VirgoUI.Client.Models.Sys;

namespace VirgoUI.Client.Models.Operate
{
    public enum EfemType
    {
        FutureEfem = 1,
        JetEfem = 2,
    }

    public class OverViewModel : UiViewModelBase
    {
        #region Property

        //private int MenuPermission;

        #region PM

        public string PMABackground
        {
            get
            {
                if (!PMAIsOnline)
                    return "Red";

                if (PMAServiceStatus == PMState.Error.ToString())
                    return "Red";

                if (PMAServiceStatus == PMState.Idle.ToString()
                    || PMAServiceStatus == PMState.Init.ToString())
                {
                    return "Transparent";
                }

                return "Green";
            }

        }

        public string PMBBackground
        {
            get
            {
                if (!PMBIsOnline)
                    return "Red";

                if (PMBServiceStatus == PMState.Error.ToString())
                    return "Red";

                if (PMBServiceStatus == PMState.Idle.ToString()
                    || PMBServiceStatus == PMState.Init.ToString())
                {
                    return "Transparent";
                }

                return "Green";
            }

        }
        #endregion

        #region EFEM

        private WaferAssociationInfo _lp1WaferAssociation;
        public WaferAssociationInfo LP1WaferAssociation
        {
            get { return _lp1WaferAssociation; }
            set { _lp1WaferAssociation = value; }
        }

        private WaferAssociationInfo _lp2WaferAssociation;
        public WaferAssociationInfo LP2WaferAssociation
        {
            get { return _lp2WaferAssociation; }
            set { _lp2WaferAssociation = value; }
        }

        public string LP1ProcStatus
        {
            get
            {
                if (LP1WaferAssociation.JobStatus == "")
                {
                    return "Idle";
                }
                return LP1WaferAssociation.JobStatus;
            }
        }

        public string LP2ProcStatus
        {
            get
            {
                if (LP2WaferAssociation.JobStatus == "")
                {
                    return "Idle";
                }
                return LP2WaferAssociation.JobStatus;
            }
        }

        private string[] _LP1StatusColor = new string[2];
        public string[] LP1StatusColor
        {
            get
            {
                switch (LP1ProcStatus)
                {
                    case "Idle":
                        _LP1StatusColor[0] = "Gold";
                        _LP1StatusColor[1] = "Black";
                        break;

                    case "WaitingForStart":
                        _LP1StatusColor[0] = "Blue";
                        _LP1StatusColor[1] = "White";
                        break;

                    case "Executing":
                        _LP1StatusColor[0] = "Cyan";
                        _LP1StatusColor[1] = "Black";
                        break;

                    case "Paused":
                        _LP1StatusColor[0] = "Blue";
                        _LP1StatusColor[1] = "White";
                        break;

                    default:
                        _LP1StatusColor[0] = "Gold";
                        _LP1StatusColor[1] = "Black";
                        break;
                }
                return _LP1StatusColor;
            }
        }

        private string[] _LP2StatusColor = new string[2];
        public string[] LP2StatusColor
        {
            get
            {
                switch (LP2ProcStatus)
                {
                    case "Idle":
                        _LP2StatusColor[0] = "Gold";
                        _LP2StatusColor[1] = "Black";
                        break;

                    case "WaitingForStart":
                        _LP2StatusColor[0] = "Blue";
                        _LP2StatusColor[1] = "White";
                        break;

                    case "Executing":
                        _LP2StatusColor[0] = "Cyan";
                        _LP2StatusColor[1] = "Black";
                        break;

                    case "Paused":
                        _LP2StatusColor[0] = "Blue";
                        _LP2StatusColor[1] = "White";
                        break;

                    default:
                        _LP2StatusColor[0] = "Gold";
                        _LP2StatusColor[1] = "Black";
                        break;
                }
                return _LP2StatusColor;
            }
        }

        [Subscription("LP1.CassetteState")]
        public LoadportCassetteState LP1CassetteState { get; set; }
        [Subscription("LP1.FoupDoorState")]
        public FoupDoorState LP1DoorState { get; set; }

        [Subscription("LP2.CassetteState")]
        public LoadportCassetteState LP2CassetteState { get; set; }
        [Subscription("LP2.FoupDoorState")]
        public FoupDoorState LP2DoorState { get; set; }

        [Subscription("LP1.CassettePlaced")]
        public bool PlacedLP1 { get; set; }

        public Visibility Foup1Visibility
        {
            get
            {
                if (IsLP1Installed)
                {
                    return Visibility.Visible;
                }
                else
                    return Visibility.Hidden;

            }
        }


        [Subscription("LP1.IsLoaded")]
        public bool IsLoadedLP1 { get; set; }

        [Subscription("LP2.CassettePlaced")]
        public bool PlacedLP2 { get; set; }

        public Visibility Foup2Visibility
        {
            get
            {
                if (IsLP2Installed)
                {
                    return Visibility.Visible;
                }
                else
                    return Visibility.Hidden;

            }
        }

        [Subscription("LP2.IsLoaded")]
        public bool IsLoadedLP2 { get; set; }

        private R_TRIG _lp1JobFinished = new R_TRIG();
        private R_TRIG _lp2JobFinished = new R_TRIG();

        private R_TRIG _lp1Removed = new R_TRIG();
        private R_TRIG _lp2Removed = new R_TRIG();

        [Subscription("EfemRobot.RobotMoveAction")]
        public MECF.Framework.Common.CommonData.RobotMoveInfo EfemRobotMoveAction
        {
            get;
            set;
        }

        public bool Foup1Present
        {
            get { return LP1CassetteState == LoadportCassetteState.Normal; }
        }
        public bool Foup1Idle
        {
            get { return LP1CassetteState == LoadportCassetteState.Normal && !Foup1Busy && !Foup1Complete; }
        }
        public bool Foup1Complete
        {
            get { return LP1JobDone && Foup1Present; }
        }
        public bool Foup1Busy
        {
            get { return LP1JobStatus == "WaitingForStart" || LP1JobStatus == "Executing" || LP1JobStatus == "Paused"; }
        }
        public bool Foup1Error
        {
            get { return LP1WaferProtrude == 1; }
        }

        public bool Foup2Present
        {
            get { return LP2CassetteState == LoadportCassetteState.Normal; }
        }
        public bool Foup2Idle
        {
            get { return LP2CassetteState == LoadportCassetteState.Normal && !Foup2Busy && !Foup2Complete; }
        }
        public bool Foup2Complete
        {
            get { return LP2JobDone && Foup2Present; }
        }
        public bool Foup2Busy
        {
            get { return LP2JobStatus == "WaitingForStart" || LP2JobStatus == "Executing" || LP2JobStatus == "Paused"; }
        }
        public bool Foup2Error
        {
            get { return LP2WaferProtrude == 1; }
        }


        //public RobotMoveInfo EfemRobotMoveInfo
        //{
        //    get
        //    {
        //        RobotMoveInfo _moveInfo = new RobotMoveInfo() { BladeTarget = "System" };

        //        if (!string.IsNullOrEmpty(EfemRobotMoveAction))
        //        {
        //            var action = EfemRobotMoveAction.Split('.');
        //            _moveInfo.BladeTarget = action[0];
        //            _moveInfo.Action = (RobotAction)Enum.Parse(typeof(RobotAction), action[1]);
        //        }

        //        return _moveInfo;
        //    }
        //}

        [Subscription("LP1.JobDone")]
        public bool LP1JobDone { get; set; }

        [Subscription("LP1.IsWaferProtrude")]
        public int LP1WaferProtrude { get; set; }

        [Subscription("LP2.JobDone")]
        public bool LP2JobDone { get; set; }

        [Subscription("LP2.IsWaferProtrude")]
        public int LP2WaferProtrude { get; set; }

        [Subscription("LP1.WaferSize")]
        public string LP1WaferSize { get; set; }
        public string WaferSizeLP1
        {
            get { return LP1CassetteState == LoadportCassetteState.Normal ? GetWaferSize(LP1WaferSize) : "--"; }
        }

        [Subscription("LP2.WaferSize")]
        public string LP2WaferSize { get; set; }
        public string WaferSizeLP2
        {
            get { return LP2CassetteState == LoadportCassetteState.Normal ? GetWaferSize(LP2WaferSize) : "--"; }
        }

        [Subscription("Aligner1.WaferSize")]
        public string Aligner1WaferSize { get; set; }
        public string WaferSizeAligner1
        {
            get { return GetWaferSize(Aligner1WaferSize); }
        }

        [Subscription("Aligner2.WaferSize")]
        public string Aligner2WaferSize { get; set; }
        public string WaferSizeAligner2
        {
            get { return GetWaferSize(Aligner2WaferSize); }
        }

        [Subscription("Cooling1.WaferSize")]
        public string Cooling1WaferSize { get; set; }
        public string WaferSizeCooling1
        {
            get { return GetWaferSize(Cooling1WaferSize); }
        }

        [Subscription("Cooling2.WaferSize")]
        public string Cooling2WaferSize { get; set; }
        public string WaferSizeCooling2
        {
            get { return GetWaferSize(Cooling2WaferSize); }
        }

        [Subscription("EfemRobot.WaferSize")]
        public string EfemRobotWaferSize { get; set; }
        public string WaferSizeEfemRobot
        {
            get { return GetWaferSize(EfemRobotWaferSize); }
        }

        [Subscription("PMA.WaferSize")]
        public string PMAWaferSize { get; set; }
        public string WaferSizePMA
        {
            get { return GetWaferSize(PMAWaferSize); }
        }

        [Subscription("PMB.WaferSize")]
        public string PMBWaferSize { get; set; }
        public string WaferSizePMB
        {
            get { return GetWaferSize(PMBWaferSize); }
        }

        [Subscription("PMA.IsAutoMode")]
        public bool PMAIsAutoMode { get; set; }

        [Subscription("PMB.IsAutoMode")]
        public bool PMBIsAutoMode { get; set; }

        [Subscription("PMA.IsOnline")]
        public bool PMAIsOnline { get; set; }

        [Subscription("PMB.IsOnline")]
        public bool PMBIsOnline { get; set; }

        public string PMAState
        {
            get
            {
                return "PMA/" + (PMAIsAutoMode ? "Auto/" : "Manual/") + (PMAIsOnline ? "Online" : "Offline");
            }
        }

        public string PMBState
        {
            get
            {
                return "PMB/" + (PMBIsAutoMode ? "Auto/" : "Manual/") + (PMBIsOnline ? "Online" : "Offline");
            }
        }

        [Subscription("EFEM.SmallWafer")]
        public int SmallWafer { get; set; }

        [Subscription("EFEM.MidWafer")]
        public int MidWafer { get; set; }

        [Subscription("EFEM.BigWafer")]
        public int BigWafer { get; set; }

        //[Subscription("EFEM.CassetteDoor")]
        //public AITSensorData CassetteDoorStatus
        //{
        //    get;
        //    set;
        //}


        [Subscription("EFEM.CassetteDoor")]
        public LidState CassetteDoorStatus
        {
            get;
            set;
        }
        public Visibility CassetteDoorIsOpened
        {
            get
            {
                return CassetteDoorStatus == LidState.Open ? Visibility.Visible : Visibility.Hidden;
            }
        }

        //public Visibility CassetteDoorVisibility
        //{
        //    get
        //    {
        //        return _efemType == EfemType.FutureEfem ? Visibility.Visible : Visibility.Collapsed;
        //    }
        //}

        public Dictionary<string, string> _waferSizeMap = new Dictionary<string, string>()
        {
            {"WS3", "3'"},{"WS4", "4'"},{"WS6", "6'"}
        };

        private string GetWaferSize(string size)
        {
            //if (_efemType == EfemType.JetEfem)
            //    return "";

            if (size != null && _waferSizeMap.ContainsKey(size))
                switch (size)
                {
                    case "WS3": return SmallWafer.ToString();
                    case "WS4": return MidWafer.ToString();
                    case "WS6": return BigWafer.ToString();
                    default: return "";
                }
            //return _waferSizeMap[size];
            return "";
        }

        public DoorState Chamber1DoorState
        {
            get { return DoorState.Unknown; }
        }

        public DoorState Chamber2DoorState
        {
            get { return DoorState.Unknown; }
        }

        public bool EnableAuto
        {
            get { return !IsAutoMode; }
        }

        public bool EnableManual
        {
            get { return IsAutoMode; }
        }

        public bool IsRtInitialized
        {
            get { return false; }
        }

        public bool EnableMapLP1
        {
            get
            {
                return Foup1Present && CassetteDoorStatus == LidState.Close;
            }
        }

        public bool EnableMapLP2
        {
            get
            {
                return Foup2Present && CassetteDoorStatus == LidState.Close;
            }
        }

        public bool EnableJobLP1
        {
            get { return IsAutoMode; }
        }

        public bool EnableJobLP2
        {
            get { return IsAutoMode; }
        }

        #region Mainframe

        public bool ButtonControl { get; set; }

        [Subscription("Aligner.Status")]
        public string AlignerStatus { get; set; }
        [Subscription("EFEM.Status")]
        public string EFEMStatus { get; set; }
        [Subscription("LP1.Status")]
        public string LP1Status { get; set; }
        [Subscription("LP2.Status")]
        public string LP2Status { get; set; }

        #endregion Mainframe

        #region PM


        public string PMALabel
        {
            get;
            set;
        }

        public string PMBLabel
        {
            get;
            set;
        }

        [Subscription("PMA.FsmState")]
        public string PMAServiceStatus { get; set; }

        [Subscription("PMA.RecipeName")]
        public string PMARecipeName { get; set; }

        [Subscription("PMA.RecipeProcessTime")]
        public string PMARemainTime { get; set; }

        [Subscription("PMA.StepNo")]
        public int PMAStepNo { get; set; }

        [Subscription("PMA.RecipeStepName")]
        public string PMAStepName { get; set; }

        [Subscription("PMA.ChamberPressure")]
        public double PMAChamberPressure { get; set; }

        [Subscription("PMA.HeaterChamber.Temperature")]
        public double PMATemperature { get; set; }

        [Subscription("PMA.Chiller.CoolantOutletTempFeedback")]
        public double PMAChillerTemperature { get; set; }

        public bool PMASlitValveIsOpen
        {
            get { return SlitDoorDataA != null && SlitDoorDataA.OpenFeedback && !SlitDoorDataA.CloseFeedback; }
        }

        [Subscription("PMA.SlitDoor.DeviceData")]
        public AITCylinderData SlitDoorDataA
        {
            get;
            set;
        }

        [Subscription("PMB.FsmState")]
        public string PMBServiceStatus { get; set; }

        [Subscription("PMB.RecipeName")]
        public string PMBRecipeName { get; set; }

        [Subscription("PMB.RecipeProcessTime")]
        public string PMBRemainTime { get; set; }

        [Subscription("PMB.StepNo")]
        public string PMBStepNo { get; set; }

        [Subscription("PMB.RecipeStepName")]
        public string PMBStepName { get; set; }

        [Subscription("PMB.ChamberPressure")]
        public double PMBChamberPressure { get; set; }

        [Subscription("PMB.HeaterChamber.Temperature")]
        public double PMBTemperature { get; set; }

        [Subscription("PMB.Chiller.CoolantOutletTempFeedback")]
        public double PMBChillerTemperature { get; set; }

        public bool PMBSlitValveIsOpen
        {
            get { return SlitDoorDataB != null && SlitDoorDataB.OpenFeedback && !SlitDoorDataB.CloseFeedback; }
        }

        [Subscription("PMB.SlitDoor.DeviceData")]
        public AITCylinderData SlitDoorDataB
        {
            get;
            set;
        }

        public bool IsPMAChillerVisibility
        {
            get
            {
                return (bool)QueryDataClient.Instance.Service.GetConfig($"PMA.Chiller.EnableChiller");
            }
        }

        public bool IsPMBChillerVisibility
        {
            get
            {
                return (bool)QueryDataClient.Instance.Service.GetConfig($"PMB.Chiller.EnableChiller");
            }
        }

        public bool IsPMAHeaterVisibility
        {
            get
            {
                return !IsPMAChillerVisibility;
            }
        }

        public bool IsPMBHeaterVisibility
        {
            get
            {
                return !IsPMBChillerVisibility;
            }
        }

        #endregion PM

        #region Scheduler

        [Subscription("System.IsAutoMode")]
        public bool IsAutoMode { get; set; }

        public bool _isCycleMode;
        public bool _isATMMode;
        public Visibility IsCycleInfoVisibility
        {
            get { return _isCycleMode ? Visibility.Visible : Visibility.Hidden; }
        }
        public Visibility IsATMInfoVisibility
        {
            get { return _isATMMode ? Visibility.Visible : Visibility.Hidden; }
        }

        [Subscription("Scheduler.CycledCount")]
        public int CycledCount { get; set; }
        [Subscription("Scheduler.CycledWafer")]
        public int CycledWafer { get; set; }
        [Subscription("Scheduler.CycleSetPoint")]
        public int CycleSetPoint { get; set; }

        public string CycleCountDisplay
        {
            get { return (CycleSetPoint > 0 && (CycledCount > CycleSetPoint)) ? $"{CycledCount + 1}/{CycleSetPoint}" : $"{CycledCount}/{CycleSetPoint}"; }
        }

        [Subscription("LP1.CurrentRecipeList")]
        public List<string> LP1CurrentRecipeList { get; set; }

        [Subscription("LP1.LocalJobName")]
        public string LP1JobName { get; set; }

        [Subscription("LP1.LocalJobStatus")]
        public string LP1JobStatus { get; set; }

        [Subscription("LP1.JobLotName")]
        public string LP1JobLotName { get; set; }

        [Subscription("LP2.CurrentRecipeList")]
        public List<string> LP2CurrentRecipeList { get; set; }

        [Subscription("LP2.LocalJobName")]
        public string LP2JobName { get; set; }

        [Subscription("LP2.LocalJobStatus")]
        public string LP2JobStatus { get; set; }

        [Subscription("LP2.JobLotName")]
        public string LP2JobLotName { get; set; }

        public bool IsPauseAllEnable => LP1JobStatus == "Executing" || LP2JobStatus == "Executing";

        #endregion Scheduler

        #endregion EFEM

        public Visibility MapVisibility => (bool)QueryDataClient.Instance.Service.GetConfig("EFEM.LoadPort.HasMapFunction") ? Visibility.Visible : Visibility.Collapsed;
        public Visibility LoadVisibility => (bool)QueryDataClient.Instance.Service.GetConfig("EFEM.LoadPort.HasLoadFunction") ? Visibility.Visible : Visibility.Collapsed;

        #region LP
        public bool EnableLoadLP1
        {
            get
            {
                return Foup1Present && string.IsNullOrEmpty(LP1JobStatus) && !IsLoadedLP1 && LP1Status != "Loading";
            }
        }
        public bool EnableLoadLP2
        {
            get
            {
                return Foup2Present && string.IsNullOrEmpty(LP2JobStatus) && !IsLoadedLP2 && LP1Status != "Loading";
            }
        }

        public bool EnableUnloadLP1
        {
            get
            {
                return Foup1Present && (string.IsNullOrEmpty(LP1JobStatus) || LP1JobStatus == "Completed") && IsLoadedLP1 && LP1Status != "Unloading";
            }
        }
        public bool EnableUnloadLP2
        {
            get
            {
                return Foup2Present && (string.IsNullOrEmpty(LP2JobStatus) || LP2JobStatus == "Completed") && IsLoadedLP2 && LP1Status != "Unloading";
            }
        }

        public ICommand LP1CarrierIDChangedCommand
        {
            get;
            set;
        }

        public ICommand LP2CarrierIDChangedCommand
        {
            get;
            set;
        }

        public string LP1CarrierIDText
        {
            get;
            set;
        }

        public string LP2CarrierIDText
        {
            get;
            set;
        }

        public Visibility ScannerVisibility
        {
            get;
            set;
        }

        #endregion

        public Visibility IsLP1Visibility
        {
            get { return IsLP1Installed ? Visibility.Visible : Visibility.Collapsed; }
        }

        public Visibility IsLP2Visibility
        {
            get { return IsLP2Installed ? Visibility.Visible : Visibility.Collapsed; }
        }

        #endregion Property

        public OverViewModel()
        {
            this.DisplayName = "OverView";
        }

        protected override void OnInitialize()
        {
            base.OnInitialize();

            base.InitModules();

            LP1WaferAssociation = new WaferAssociationInfo();
            if(ModuleManager.ModuleInfos.ContainsKey("LP1"))
            {
                LP1WaferAssociation.ModuleData = ModuleManager.ModuleInfos["LP1"];
            }

            LP2WaferAssociation = new WaferAssociationInfo();
            if (ModuleManager.ModuleInfos.ContainsKey("LP2"))
            {
                LP2WaferAssociation.ModuleData = ModuleManager.ModuleInfos["LP2"];
            }

            LP1CarrierIDChangedCommand = new DelegateCommand<object>(LP1CarrierIDInputChanged);
            LP2CarrierIDChangedCommand = new DelegateCommand<object>(LP2CarrierIDInputChanged);

        }

        protected override void OnActivate()
        {
            base.OnActivate();

            ScannerVisibility = (bool)QueryDataClient.Instance.Service.GetConfig("EFEM.LoadPort.EnableScanner") ? Visibility.Visible:Visibility.Hidden;

            _isCycleMode = (bool)QueryDataClient.Instance.Service.GetConfig("System.IsCycleMode");
            _isATMMode = (bool)QueryDataClient.Instance.Service.GetConfig("System.IsATMMode");

            PMALabel = (string)QueryDataClient.Instance.Service.GetConfig("PMA.ChamberLabel");
            PMBLabel = (string)QueryDataClient.Instance.Service.GetConfig("PMB.ChamberLabel");

        }

        public void Start()
        {
            //if (MenuPermission != 3) return;
            InvokeClient.Instance.Service.DoOperation("System.StartAutoRun");
        }

        public void Stop()
        {
            //InvokeClient.Instance.Service.DoOperation("System.StartAutoRun");
        }

        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
            ContextMenuManager.Instance.IsAutoMode = this.IsAutoMode;

            ModuleTemperature["PMA"] = (float)PMATemperature;
            ModuleTemperature["PMB"] = (float)PMBTemperature;

            LP1WaferAssociation.JobID = LP1JobName;
            LP1WaferAssociation.JobStatus = LP1JobStatus;

            LP2WaferAssociation.JobID = LP2JobName;
            LP2WaferAssociation.JobStatus = LP2JobStatus;

            LP1WaferAssociation.JobID = LP1JobName;
            LP1WaferAssociation.JobStatus = LP1JobStatus;
            if (!string.IsNullOrEmpty(LP1JobName))
                LP1WaferAssociation.LotId = LP1JobLotName;

            LP2WaferAssociation.JobID = LP2JobName;
            LP2WaferAssociation.JobStatus = LP2JobStatus;
            if (!string.IsNullOrEmpty(LP2JobName))
                LP2WaferAssociation.LotId = LP2JobLotName;

            _lp1JobFinished.CLK = string.IsNullOrEmpty(LP1JobName);
            if (_lp1JobFinished.Q)
            {
                var wafers = LP1WaferAssociation.ModuleData.WaferManager.Wafers;
                for (int i = 0; i < wafers.Count; i++)
                {
                    wafers[i].SequenceName = "";
                }

                LP1WaferAssociation.LotId = "";
                LP1WaferAssociation.SequenceName = "";
            }
            _lp2JobFinished.CLK = string.IsNullOrEmpty(LP2JobName);
            if (_lp2JobFinished.Q)
            {
                var wafers = LP2WaferAssociation.ModuleData.WaferManager.Wafers;
                for (int i = 0; i < wafers.Count; i++)
                {
                    wafers[i].SequenceName = "";
                }

                LP2WaferAssociation.LotId = "";
                LP2WaferAssociation.SequenceName = "";
            }


            if (!string.IsNullOrEmpty(LP1JobStatus) && LP1JobStatus == "Executing")
            {
                var wafers = LP1WaferAssociation.ModuleData.WaferManager.Wafers;
                for (int i = 0; i < wafers.Count; i++)
                {
                    wafers[i].SequenceName = LP1CurrentRecipeList[wafers[i].SlotID];
                }
            }
            if (!string.IsNullOrEmpty(LP2JobStatus) && LP2JobStatus == "Executing")
            {
                var wafers = LP2WaferAssociation.ModuleData.WaferManager.Wafers;
                for (int i = 0; i < wafers.Count; i++)
                {
                    wafers[i].SequenceName = LP2CurrentRecipeList[wafers[i].SlotID];
                }
            }

            _lp1Removed.CLK = (LP1CassetteState != LoadportCassetteState.Normal);
            if (_lp1Removed.Q)
            {
                LP1CarrierIDText = "";
            }
            _lp2Removed.CLK = (LP2CassetteState != LoadportCassetteState.Normal);
            if (_lp2Removed.Q)
            {
                LP2CarrierIDText = "";
            }

            if (LP1CassetteState != LoadportCassetteState.Normal)
            {
                foreach (var wafer in LP1WaferAssociation.ModuleData.WaferManager.Wafers)
                {
                    wafer.SequenceName = "";
                }
            }
            if (LP2CassetteState != LoadportCassetteState.Normal)
            {
                foreach (var wafer in LP2WaferAssociation.ModuleData.WaferManager.Wafers)
                {
                    wafer.SequenceName = "";
                }
            }

            FOUPA.IsJobDone = LP1JobDone;
            FOUPB.IsJobDone = LP2JobDone;
        }

        #region LP Operation

        public void SetThick(string moduleID)
        {
            //if (MenuPermission != 3) return;

            //LoadPortProvider.Instance.SetThick(moduleID);
        }

        public void SetThin(string moduleID)
        {
            //if (MenuPermission != 3) return;
            //LoadPortProvider.Instance.SetThin(moduleID);
        }

        public void MapLP(string moduleID)
        {
            //if (MenuPermission != 3) return;
            LoadPortProvider.Instance.MapLP(moduleID);
        }

        public void LoadLP(string moduleID)
        {
            InvokeClient.Instance.Service.DoOperation($"{moduleID}.Load");
        }

        public void UnloadLP(string moduleID)
        {
            InvokeClient.Instance.Service.DoOperation($"{moduleID}.Unload");
        }

        public void HomeAll()
        {
            //if (MenuPermission != 3) return;
            InvokeClient.Instance.Service.DoOperation("System.HomeAll");
        }

        public void ReturnAllWafer()
        {
            //if (MenuPermission != 3) return;
            WindowManager wm = new WindowManager();
            bool needCooling = false;
            int coolingTime = 0;
            bool needAligning = false;
            int alignAngle = 0;
            if (ModuleManager.ModuleInfos.ContainsKey("Cooling1") || ModuleManager.ModuleInfos.ContainsKey("Cooling2"))
            {
                WaferTransferDialogViewModel _transferVM = new WaferTransferDialogViewModel("Would the wafer need cooling?", false, true, "");
                bool? bret = wm.ShowDialogWithNoStyle(_transferVM);
                if ((bool)bret)
                {
                    //get and use transfer conditions
                    WaferTransferCondition conditions = _transferVM.DialogResult;
                    needCooling = conditions.IsPassCooling;
                    coolingTime = conditions.CoolingTime;

                    InvokeClient.Instance.Service.DoOperation("System.ReturnAllWafer", needCooling, coolingTime, needAligning, alignAngle);
                }
            }
            else if(ModuleManager.ModuleInfos.ContainsKey("Aligner1") || ModuleManager.ModuleInfos.ContainsKey("Aligner2"))
            {
                WaferTransferDialogViewModel _transferVM = new WaferTransferDialogViewModel("Would the wafer need aligning?", true, false, "");
                bool? bret = wm.ShowDialogWithNoStyle(_transferVM);
                if ((bool)bret)
                {
                    //get and use transfer conditions
                    WaferTransferCondition conditions = _transferVM.DialogResult;
                    needAligning = conditions.IsPassAligner;
                    alignAngle = conditions.AlignerAngle;

                    InvokeClient.Instance.Service.DoOperation("System.ReturnAllWafer", needCooling, coolingTime, needAligning, alignAngle);
                }
            }
        }

        public void PauseAllJob()
        {
            if (!string.IsNullOrEmpty(LP1WaferAssociation.JobID))
                WaferAssociationProvider.Instance.Pause(LP1WaferAssociation.JobID);
            if (!string.IsNullOrEmpty(LP2WaferAssociation.JobID))
                WaferAssociationProvider.Instance.Pause(LP2WaferAssociation.JobID);
        }
        public void Abort()
        {
            //if (MenuPermission != 3) return;
            InvokeClient.Instance.Service.DoOperation("System.Abort");
        }

        public void Auto()
        {
            //if (MenuPermission != 3) return;
            InvokeClient.Instance.Service.DoOperation("System.SetAutoMode");
        }

        public void Manual()
        {
            //if (MenuPermission != 3) return;
            InvokeClient.Instance.Service.DoOperation("System.SetManualMode");
        }

        #endregion LP Operation

        #region Sequence operation

        public void SelectSequence(WaferAssociationInfo info)
        {
            //if (MenuPermission != 3) return;
            SequenceDialogViewModel dialog = new SequenceDialogViewModel();
            dialog.DisplayName = "Select Sequence";

            dialog.Files = new ObservableCollection<FileNode>(RecipeSequenceTreeBuilder.GetFiles(
                RecipeClient.Instance.Service.GetSequenceNameList()
            ));

            WindowManager wm = new WindowManager();
            bool? bret = wm.ShowDialog(dialog);
            if ((bool)bret)
            {
                info.SequenceName = dialog.DialogResult;
            }
        }

        public void SetSlot(WaferAssociationInfo info)
        {
            if (InputSlotCheck(info.SlotFrom, info.SlotTo))
                AssociateSequence(info, true);
        }

        public void SkipSlot(WaferAssociationInfo info)
        {
            if (InputSlotCheck(info.SlotFrom, info.SlotTo))
                AssociateSequence(info, false);
        }

        public void SetAll(WaferAssociationInfo info)
        {
            //if (MenuPermission != 3) return;
            info.SlotFrom = 1;
            info.SlotTo = (int)QueryDataClient.Instance.Service.GetConfig($"EFEM.LoadPort.SlotNumber");
            AssociateSequence(info, true);
        }

        public void DeselectAll(WaferAssociationInfo info)
        {
            //if (MenuPermission != 3) return;
            info.SlotFrom = 1;
            info.SlotTo = (int)QueryDataClient.Instance.Service.GetConfig($"EFEM.LoadPort.SlotNumber");
            AssociateSequence(info, false);
        }

        public void SetSequence(WaferAssociationInfo info, int slotIndex, string seqName)
        {
            bool flag = string.IsNullOrEmpty(seqName);
            AssociateSequence(info, flag, slotIndex - 1);
        }

        private bool InputSlotCheck(int from, int to)
        {
            if (from > to)
            {
                DialogBox.ShowInfo("This index of from slot should be large than the index of to slot.");
                return false;
            }
            if (from < 1 || to > (int)QueryDataClient.Instance.Service.GetConfig($"EFEM.LoadPort.SlotNumber"))
            {
                DialogBox.ShowInfo($"This input value for from should be between 1 and {(int)QueryDataClient.Instance.Service.GetConfig($"EFEM.LoadPort.SlotNumber")}.");
                return false;
            }
            return true;
        }

        private void AssociateSequence(WaferAssociationInfo info, bool flag, int slot = -1)
        {
             List<WaferInfo> wafers = info.ModuleData.WaferManager.Wafers;

            var fromBottom = QueryDataClient.Instance.Service.GetConfig($"EFEM.LoadPort.SlotFromBottom");
            int parityFlag = (int)QueryDataClient.Instance.Service.GetConfig("EFEM.LoadPort.WaferPlacementParityFlag");
            if (slot >= 0) //by wafer
            {
                // Wafer Placement Parity Checking
                
                if(parityFlag != 0 && slot % 2 == parityFlag % 2)
                {
                    string slotParity = parityFlag == 2 ? "Odd" : "Even";
                    DialogBox.ShowWarning($"Cannot process {slotParity} slot wafer.");
                    return;
                }

                int index = wafers.Count - slot - 1;
                if (fromBottom != null && !((bool)fromBottom))
                {
                    index = slot;
                }
                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 (fromBottom != null && !((bool)fromBottom))
                    {
                        index = i;
                    }


                    if (index < wafers.Count)
                    {
                        if (flag && HasWaferOnSlot(wafers, index) && (parityFlag == 0 || wafers[index].SlotID % 2 != parityFlag % 2))
                            wafers[index].SequenceName = info.SequenceName;
                        else
                            wafers[index].SequenceName = string.Empty;
                    }
                }
            }
        }

        private bool HasWaferOnSlot(List<WaferInfo> wafers, int index)
        {
            if (wafers[index].WaferStatus == 0)
                return false;

            return true;
        }

        public int LP1WaferCount
        {
            get
            {
                int iWaferCount = 0;
                foreach (var Wafers in ModuleManager.ModuleInfos["LP1"].WaferManager.Wafers)
                {
                    if (Wafers.WaferStatus != 0)
                    {
                        iWaferCount++;
                    }
                }
                return iWaferCount;
            }
        }

        public string LP1WaferCountInfo
        {
            get
            {
                return $"Wafer Count：{LP1WaferCount}";
            }
        }

        public int LP2WaferCount
        {
            get
            {
                int iWaferCount = 0;
                foreach (var Wafers in ModuleManager.ModuleInfos["LP2"].WaferManager.Wafers)
                {
                    if (Wafers.WaferStatus != 0)
                    {
                        iWaferCount++;
                    }
                }
                return iWaferCount;
            }
        }

        public string LP2WaferCountInfo
        {
            get
            {
                return $"Wafer数量：{LP2WaferCount}";
            }
        }

        #region barcode

        private void LP1CarrierIDInputChanged(object param)
        {
            string barcode = param as string;
            if (string.IsNullOrEmpty(barcode.Trim()))
            {
                return;
            }
            InvokeClient.Instance.Service.DoOperation($"LP1.CarrierIDScanned", barcode.Trim());
        }

        private void LP2CarrierIDInputChanged(object param)
        {
            string barcode = param as string;
            if (string.IsNullOrEmpty(barcode.Trim()))
            {
                return;
            }
            InvokeClient.Instance.Service.DoOperation($"LP2.CarrierIDScanned", barcode.Trim());
        }




        #endregion barcode




        #endregion Sequence operation

        #region Job operation

        private bool JobCheck(string jobID)
        {
            if (jobID.Length == 0)
            {
                DialogBox.ShowWarning("Please create job first.");
                return false;
            }
            else
                return true;
        }

        public void CreateJob(WaferAssociationInfo info)
        {
            // Parity Check
            int parityFlag = (int)QueryDataClient.Instance.Service.GetConfig("EFEM.LoadPort.WaferPlacementParityFlag");
            if(parityFlag != 0)
            {
                foreach (var wafer in info.ModuleData.WaferManager.Wafers)
                {
                    if (wafer.WaferStatus != 0 && wafer.SlotID % 2 == parityFlag % 2)
                    {
                        string slotParity = parityFlag == 2 ? "Odd" : "Even";
                        DialogBox.ShowWarning($"Cannot create job as {slotParity} slots have wafers.");
                        return;
                    }
                }
            }
            
            //if (MenuPermission != 3) return;
            List<string> slotSequence = new List<string>();

            var fromBottom = QueryDataClient.Instance.Service.GetConfig($"EFEM.LoadPort.SlotFromBottom");

            if (fromBottom != null && !((bool)fromBottom))
            {
                info.ModuleData.WaferManager.Wafers.ForEach(key => { slotSequence.Add(key.SequenceName); });
            }
            else
            {
                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.LotIdSaved = true;

            WaferAssociationProvider.Instance.CreateJob(jobId, info.ModuleData.ModuleID, slotSequence, true);
        }

        public void AbortJob(string jobID)
        {
            //if (MenuPermission != 3) return;
            if (JobCheck(jobID))
                WaferAssociationProvider.Instance.AbortJob(jobID);
        }

        public void Start(string jobID)
        {
            //if (MenuPermission != 3) return;
            if (JobCheck(jobID))
                WaferAssociationProvider.Instance.Start(jobID);
        }

        public void Pause(string jobID)
        {
            //if (MenuPermission != 3) return;
            if (JobCheck(jobID))
                WaferAssociationProvider.Instance.Pause(jobID);
        }

        public void Resume(string jobID)
        {
            //if (MenuPermission != 3) return;
            if (JobCheck(jobID))
                WaferAssociationProvider.Instance.Resume(jobID);
        }

        public void Stop(string jobID)
        {
            //if (MenuPermission != 3) return;
            if (JobCheck(jobID))
                WaferAssociationProvider.Instance.Stop(jobID);
        }

        #endregion Job operation
    }
}