ELK/Furnace/FurnaceUI/Views/Operations/TransferMain/SelfCheckInitViewModel.cs

using Aitex.Core.Util;
using MECF.Framework.Common.OperationCenter;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using FurnaceUI.Models;

namespace FurnaceUI.Views.Operations
{
    public class SelfCheckInitViewModel : FurnaceUIViewModelBase
    {
        [Subscription("Rt.Status")]
        public string RtStatus { get; set; }
        [Subscription("System.IsInitialized")]
        public bool SystemIsInitialized { get; set; }
        [Subscription("CarrierRobot.Status")]
        public string CarrierRobotStatus { get; set; }
        [Subscription("WaferRobot.Status")]
        public string WaferRobotStatus { get; set; }
        [Subscription("LP1.Status")]
        public string LP1Status { get; set; }
        [Subscription("LP2.Status")]
        public string LP2Status { get; set; }

        [Subscription("LP3.Status")]
        public string LP3Status { get; set; }


        [Subscription("LP4.Status")]
        public string LP4Status { get; set; }
        [Subscription("FIMS1.Status")]
        public string FIMS1Status { get; set; }
        [Subscription("FIMS2.Status")]
        public string FIMS2Status { get; set; }
        [Subscription("Boat.Status")]
        public string BoatStatus { get; set; }


        public bool IsRtInitialized
        {
            get
            {
                return RtStatus != "Init" && RtStatus != "Initializing";
            }
        }
        public bool IsRtRunning
        {
            get
            {
                return RtStatus != "Init" && RtStatus != "Idle" && RtStatus != "AutoIdle";
            }
        }

        public bool IsRtError
        {
            get
            {
                return RtStatus == "Error";
            }
        }
        public bool IsEnableInitialize
        {
            get { return (RtStatus == "Init" || RtStatus == "Idle") && AllInitializeEnable; }
        }
        public bool IsAuto
        {
            get { return RtStatus == "AutoRunning" || RtStatus == "AutoIdle"; }
        }
        public bool IsCarrierRobotInitialized
        {
            get
            {
                return CarrierRobotStatus != "Init" && CarrierRobotStatus != "Homing";
            }
        }
        public bool IsWaferRobotInitialized
        {
            get
            {
                return WaferRobotStatus != "Init" && WaferRobotStatus != "Homing";
            }
        }
        public bool IsLP1Initialized
        {
            get
            {
                return LP1Status != "Init" && LP1Status != "Homing";
            }
        }
        public bool IsLP2Initialized
        {
            get
            {
                return LP2Status != "Init" && LP2Status != "Homing";
            }
        }
        public bool IsBoatInitialized
        {
            get
            {
                return BoatStatus != "Init" && BoatStatus != "Homing";
            }
        }
        public bool IsFIMS1Initialized
        {
            get
            {
                return FIMS1Status != "Init" && FIMS1Status != "Homing";
            }
        }
        public bool IsFIMS2Initialized
        {
            get
            {
                return FIMS1Status != "Init" && FIMS1Status != "Homing";
            }
        }

        public int AllInitializeCount { get; set; }
        public int CarrierRobotInitializeCount { get; set; }
        public int WaferRobotInitializeCount { get; set; }
        public int LP1InitializeCount { get; set; }
        public int LP2InitializeCount { get; set; }
        public int LP3InitializeCount { get; set; }
        public int LP4InitializeCount { get; set; }
        public int BoatInitializeCount { get; set; }
        private int _FIMS1InitializeCount;
        private int _FIMS2InitializeCount;
        private bool _FIMS1InitializeEnable;
        private bool _FIMS2InitializeEnable;


        //public bool AllInitializeEnable { get; set; } = false;
        //public bool CarrierRobotInitializeEnable { get; set; } = false;
        //public bool WaferRobotInitializeEnable { get; set; } = false;
        //public bool SMIFAInitializeEnable { get; set; } = false;
        //public bool SMIFBInitializeEnable { get; set; } = false;
        //public bool BoatInitializeEnable { get; set; } = false;

        private bool _AllInitializeEnable;
        public bool AllInitializeEnable
        {
            get => _AllInitializeEnable;
            set
            {
                _AllInitializeEnable = value;
                NotifyOfPropertyChange("AllInitializeEnable");
            }
        }

        private bool _CarrierRobotInitializeEnable;
        public bool CarrierRobotInitializeEnable
        {
            get => _CarrierRobotInitializeEnable;
            set
            {
                _CarrierRobotInitializeEnable = value;
                NotifyOfPropertyChange("CarrierRobotInitializeEnable");
            }
        }

        private bool _WaferRobotInitializeEnable;
        public bool WaferRobotInitializeEnable
        {
            get => _WaferRobotInitializeEnable;
            set
            {
                _WaferRobotInitializeEnable = value;
                NotifyOfPropertyChange("WaferRobotInitializeEnable");
            }
        }

        private bool _LP1InitializeEnable;
        public bool LP1InitializeEnable
        {
            get => _LP1InitializeEnable;
            set
            {
                _LP1InitializeEnable = value;
                NotifyOfPropertyChange("LP1InitializeEnable");
            }
        }

        private bool _LP2InitializeEnable;
        public bool LP2InitializeEnable
        {
            get => _LP2InitializeEnable;
            set
            {
                _LP2InitializeEnable = value;
                NotifyOfPropertyChange("LP2InitializeEnable");
            }
        }


        private bool _LP3InitializeEnable;
        public bool LP3InitializeEnable
        {
            get => _LP3InitializeEnable;
            set
            {
                _LP3InitializeEnable = value;
                NotifyOfPropertyChange("LP3InitializeEnable");
            }
        }


        private bool _LP4InitializeEnable;
        public bool LP4InitializeEnable
        {
            get => _LP4InitializeEnable;
            set
            {
                _LP4InitializeEnable = value;
                NotifyOfPropertyChange("LP4InitializeEnable");
            }
        }


        private bool _BoatInitializeEnable;
        public bool BoatInitializeEnable
        {
            get => _BoatInitializeEnable;
            set
            {
                _BoatInitializeEnable = value;
                NotifyOfPropertyChange("BoatInitializeEnable");
            }
        }
        #region UI Logic
        public bool IsEnableCarrierRobotInitialized => (CarrierRobotStatus == "Idle" || CarrierRobotStatus == "Init" || CarrierRobotStatus == "Error" || IsSystemStaus && CarrierRobotStatus != "Homing") && CarrierRobotInitializeEnable && RtStatus != "AutoRunning";
        public bool IsEnableWaferRobotInitialized => (WaferRobotStatus == "Idle" || WaferRobotStatus == "Init" || WaferRobotStatus == "Error" || IsSystemStaus && WaferRobotStatus != "Homing") && WaferRobotInitializeEnable && RtStatus != "AutoRunning";
        public bool IsEnableLP1Initialized => (LP1Status == "Idle" || LP1Status == "Init" || LP1Status == "Error" || IsSystemStaus && LP1Status != "Homing") && LP1InitializeEnable && RtStatus != "AutoRunning";
        public bool IsEnableLP2Initialized => (LP2Status == "Idle" || LP2Status == "Init" || LP2Status == "Error" || IsSystemStaus && LP2Status != "Homing") && LP2InitializeEnable && RtStatus != "AutoRunning";

        public bool IsEnableLP3Initialized => (LP3Status == "Idle" || LP3Status == "Init" || LP3Status == "Error" || IsSystemStaus && LP3Status != "Homing") && LP3InitializeEnable && RtStatus != "AutoRunning";

        public bool IsEnableLP4Initialized => (LP4Status == "Idle" || LP4Status == "Init" || LP4Status == "Error" || IsSystemStaus && LP4Status != "Homing") && LP4InitializeEnable && RtStatus != "AutoRunning";
        public bool IsEnableBoatInitialized => (BoatStatus == "Idle" || BoatStatus == "Init" || BoatStatus == "Error" || IsSystemStaus && BoatStatus != "Homing") && BoatInitializeEnable && RtStatus != "AutoRunning";
        public bool IsEnableFIMS1Initialized => (FIMS1Status == "Idle" || FIMS1Status == "Init" || FIMS1Status == "Error") && IsSystemStaus && _FIMS1InitializeEnable && RtStatus != "AutoRunning";
        public bool IsEnableFIMS2Initialized => (FIMS2Status == "Idle" || FIMS2Status == "Init" || FIMS2Status == "Error") && IsSystemStaus && _FIMS2InitializeEnable && RtStatus != "AutoRunning";
        public bool IsAbortAllInitialized => AllInitializeEnable;
        public bool IsAbortCarrierRobotInitialized => CarrierRobotInitializeEnable;
        public bool IsAbortWaferRobotInitialized => WaferRobotInitializeEnable;
        public bool IsAbortLP1Initialized => LP1InitializeEnable;
        public bool IsAbortLP2Initialized => LP2InitializeEnable;

        public bool IsAbortLP3Initialized => LP3InitializeEnable;
        public bool IsAbortLP4Initialized => LP4InitializeEnable;

        public bool IsAbortFIMS1Initialized => _FIMS1InitializeEnable;
        public bool IsAbortFIMS2Initialized => _FIMS2InitializeEnable;
        public bool IsAbortBoatInitialized => BoatInitializeEnable;

        public bool IsSystemStaus => (RtStatus == "Idle" || RtStatus == "Init" || RtStatus == "Error") ;
        #endregion

        public void HomeAll()
        {
            InvokeClient.Instance.Service.DoOperation("System.HomeAll");
        }

        public void Home(string module)
        {
            InvokeClient.Instance.Service.DoOperation($"{module}.Home");
        }

        public void Abort(string module)
        {
            InvokeClient.Instance.Service.DoOperation($"{module}.Abort");
        }

        public void Manual(string module)
        {
            switch (module)
            {
                case "All Initialize":
                    AllInitializeCount++;
                    if (AllInitializeCount % 2 == 0)
                        AllInitializeEnable = false;
                    else
                        AllInitializeEnable = true;
                    break;
                case "Carrier Robot Initialize":
                    CarrierRobotInitializeCount++;
                    if (CarrierRobotInitializeCount % 2 == 0)
                        CarrierRobotInitializeEnable = false;
                    else
                        CarrierRobotInitializeEnable = true;
                    break;
                case "Wafer Robot Initialize":
                    WaferRobotInitializeCount++;
                    if (WaferRobotInitializeCount % 2 == 0)
                        WaferRobotInitializeEnable = false;
                    else
                        WaferRobotInitializeEnable = true;
                    break;
                case "LP1 Initialize":
                    LP1InitializeCount++;
                    if (LP1InitializeCount % 2 == 0)
                        LP1InitializeEnable = false;
                    else
                        LP1InitializeEnable = true;
                    break;
                case "LP2 Initialize":
                    LP2InitializeCount++;
                    if (LP2InitializeCount % 2 == 0)
                        LP2InitializeEnable = false;
                    else
                        LP2InitializeEnable = true;
                    break;

                case "LP3 Initialize":
                    LP3InitializeCount++;
                    if (LP3InitializeCount % 2 == 0)
                        LP3InitializeEnable = false;
                    else
                        LP3InitializeEnable = true;
                    break;

                case "LP4 Initialize":
                    LP4InitializeCount++;
                    if (LP4InitializeCount % 2 == 0)
                        LP4InitializeEnable = false;
                    else
                        LP4InitializeEnable = true;
                    break;
                case "Boat Initialize":
                    BoatInitializeCount++;
                    if (BoatInitializeCount % 2 == 0)
                        BoatInitializeEnable = false;
                    else
                        BoatInitializeEnable = true;
                    break;
                case "FIMS1 Initialize":
                    _FIMS1InitializeCount++;
                    if (_FIMS1InitializeCount % 2 == 0)
                        _FIMS1InitializeEnable = false;
                    else
                        _FIMS1InitializeEnable = true;
                    break;
                case "FIMS2 Initialize":
                    _FIMS2InitializeCount++;
                    if (_FIMS2InitializeCount % 2 == 0)
                        _FIMS2InitializeEnable = false;
                    else
                        _FIMS2InitializeEnable = true;
                    break;
                default:
                    break;
            }
        }

        public void CloseCmd()
        {
            ((Window)GetView()).Close();
        }
    }
}