ZZ-EFEM/Jet/Jet_001_2P_Jet/EfemUI/ViewModels/OperationViewModel2LP.cs

using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
using Aitex.Core.Common;
using Aitex.Core.UI.MVVM;
using Aitex.Sorter.UI.Controls;
using System.Windows.Input;
using Aitex.Core.Util;
using Aitex.Core.Utilities;
using Aitex.Sorter.Common;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.CommonData;
using System;
using EfemUI.Views.CarrierList;
using MECF.Framework.Common.Equipment;
using System.Collections.ObjectModel;
using System.Linq;
using Aitex.Sorter.UI.Controls.Common;

namespace Aitex.Sorter.UI.ViewModel
{
    class OperationViewModel2LP : OperationMultiLPViewModel
    {
        public ICommand StartCycleCommand { get; set; }
        public ICommand SetWaferSize3 { get; set; }
        public ICommand SetWaferSize4 { get; set; }
        public ICommand SetWaferSize6 { get; set; }
        public ICommand SetWaferSize8 { get; set; }

        public ICommand SetWaferThick { get; set; }

        public ICommand SetWaferThin { get; set; }

        public ICommand SetLPSlot13 { get; set; }
        public ICommand SetLPSlot25 { get; set; }

        public ICommand SetFFUCommand { get; set; }

        public ICommand SetTransCarrierTypeCommand { get; set; }
        public ICommand MapCommand { get; set; }
        public ObservableCollection<FoupListItem> BufferList { get; set; }
       
        public bool EnablePageControl
        {
            get { return !IsOnlineMode; }
        }
        [Subscription("System.Robot.CurrentReadSpeedData")]
        public int CurrentReadSpeedData { get; set; }


        [Subscription("FFU.FFU1Speed")]
        public int FFU1Speed { get; set; }

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

        [Subscription("LP1.WaferSizeInfo")]
        public string WaferSize1 { get; set; }

        [Subscription("LP2.WaferSizeInfo")]
        public string WaferSize2 { get; set; }

        [Subscription("Aligner1.Aligner1.WaferSizeByWafer")]
        public string WaferSizeAligner1 { get; set; }

        [Subscription("Aligner2.Aligner2.WaferSizeByWafer")]
        public string WaferSizeAligner2 { get; set; }

        [Subscription("CoolingBuffer1.CoolingBuffer1.WaferSizeByWafer")]
        public string WaferSizeCoolingBuffer1 { get; set; }

        [Subscription("CoolingBuffer2.CoolingBuffer2.WaferSizeByWafer")]
        public string WaferSizeCoolingBuffer2 { get; set; }

        [Subscription("Buffer1.WaferSizeByWafer")]
        public string WaferSizeBuffer1 { get; set; }
        [Subscription("Buffer2.WaferSizeByWafer")]
        public string WaferSizeBuffer2 { get; set; }

        [Subscription("LL1.WaferSize")]
        public string WaferSizeLL1 { get; set; }

        [Subscription("LL2.WaferSize")]
        public string WaferSizeLL2 { get; set; }

        //[Subscription("Buffer1.WaferSize")]
        //public string WaferSizeBuffer1 { get; set; }

        //[Subscription("Buffer2.WaferSize")]
        //public string WaferSizeBuffer2 { get; set; }


        [Subscription("Robot.Blade1WaferSize")]
        public string WaferSizeRobot1 { get; set; }

        [Subscription("Robot.Blade2WaferSize")]
        public string WaferSizeRobot2 { get; set; }

        [Subscription("Robot.WaferSize")]
        public string WaferSizeRobot { get; set; }

        [Subscription("LP1.WaferThickness")]
        public string LP1WaferThickness { get; set; }

        [Subscription("LP2.WaferThickness")]
        public string LP2WaferThickness { get; set; }

        [Subscription("Cooling1.WaferThickness")]
        public string Cooling1WaferThickness { get; set; }

        [Subscription("Cooling2.WaferThickness")]
        public string Cooling2WaferThickness { get; set; }

        [Subscription("LL1.WaferThickness")]
        public string PMAWaferThickness { get; set; }

        [Subscription("LL2.WaferThickness")]
        public string PMBWaferThickness { get; set; }

        [Subscription("Buffer1.WaferThickness")]
        public string Buffer1WaferThickness { get; set; }

        [Subscription("Buffer2.WaferThickness")]
        public string Buffer2WaferThickness { get; set; }

        [Subscription("Aligner1.WaferThickness")]
        public string Aligner1WaferThickness { get; set; }

        [Subscription("Aligner2.WaferThickness")]
        public string Aligner2WaferThickness { get; set; }

        [Subscription("Upper.WaferThickness")]
        public string UpperWaferThickness { get; set; }

        [Subscription("Lower.WaferThickness")]
        public string LowerWaferThickness { get; set; }

        [Subscription("LP1.ValidSlotsNumber")]
        public int LP1ValidSlotsNumber { get; set; }

        [Subscription("LP2.ValidSlotsNumber")]
        public int LP2ValidSlotsNumber { get; set; }
      
        [Subscription("CoolingBuffer1Disable", "System")]
        public bool CoolingBuffer1Disable
        {
            get;
            set;
        }
        public bool CoolingBuffer1Enable => !CoolingBuffer1Disable;
        [Subscription("CoolingBuffer2Disable", "System")]
        public bool CoolingBuffer2Disable
        {
            get;
            set;
        }
        public bool CoolingBuffer2Enable => !CoolingBuffer2Disable;

        [Subscription("Aligner1Disable", "System")]
        public bool Aligner1Disable
        {
            get;
            set;
        }
        public bool Aligner1Enable => !Aligner1Disable;
        [Subscription("Aligner2Disable", "System")]
        public bool Aligner2Disable
        {
            get;
            set;
        }
        public bool Aligner2Enable => !Aligner2Disable;

        [Subscription("System.IsEnableBufferMap")]
        public bool IsBufferMapEnable { get; set; }
        [Subscription("System.IsEnableIdentifyThickness")]
        public bool IsEnableIdentifyThickness { get; set; }

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

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

        public Visibility SlotShow2 => IsSlotShowOpposite ? Visibility.Hidden : Visibility.Visible;
        public Visibility SlotShow1 => !IsSlotShowOpposite ? Visibility.Hidden : Visibility.Visible;


        public ObservableCollection<FoupListItem> _foupLists;
      

        public Visibility EnableIdentifyThickness
        {
            get 
            {
                if (IsEnableIdentifyThickness)
                    return Visibility.Visible;
                return Visibility.Hidden;
            }
        }

        public Visibility EnableMultiWaferSize
        {
            get
            {
                if (IsEnableMultiWaferSize && IsEnableMultiWaferSizeShow)
                    return Visibility.Visible;
                return Visibility.Hidden;
            }
        }

        [Subscription(ParamName.ModuleWaferList, DeviceName.CoolingBuffer1)]
        public WaferInfo[] CoolingBuffer1Wafers
        {
            get;
            set;
        }

        public WaferInfo CoolingBuffer1Wafer
        {
            get => CoolingBuffer1Wafers != null ? CoolingBuffer1Wafers[0] : null;
        }
        
        [Subscription(ParamName.ModuleWaferList, DeviceName.CoolingBuffer2)]
        public WaferInfo[] CoolingBuffer2Wafers
        {
            get;
            set;
        }
        
        public WaferInfo CoolingBuffer2Wafer
        {
            get => CoolingBuffer2Wafers != null ? CoolingBuffer2Wafers[0] : null;
        }
        
        [Subscription(ParamName.ModuleWaferList, DeviceName.Aligner1)]
        public WaferInfo[] Aligner1Wafers
        {
            get;
            set;
        }

        public WaferInfo Aligner1Wafer
        {
            get => Aligner1Wafers != null ? Aligner1Wafers[0] : null;
        }
        
        [Subscription(ParamName.ModuleWaferList, DeviceName.Aligner2)]
        public WaferInfo[] Aligner2Wafers
        {
            get;
            set;
        }

        public WaferInfo Aligner2Wafer
        {
            get => Aligner2Wafers != null ? Aligner2Wafers[0] : null;
        }
        
        [Subscription(ParamName.ModuleWaferList, DeviceName.Buffer1)]
        public WaferInfo[] LlbWaferInfo
        { 
            get
            {
                return BufferList[0].WaferInfos;
            }
            set => UpdateBufferWafers(value, 0);
        }
        [Subscription(ParamName.ModuleWaferList, DeviceName.Buffer2)]
        public WaferInfo[] LlbWaferInfo2
        {
            get
            {
                return BufferList[1].WaferInfos;
            }
            set => UpdateBufferWafers(value, 1);
        }
        
        [Subscription("ValidSlotsNumber", DeviceName.Buffer1)]
        public int ValidSlotsNum1
        {
            get => BufferList[0].SlotCount;
            set => BufferList[0].SlotCount = value;
        }

        [Subscription("ValidSlotsNumber", DeviceName.Buffer2)]
        public int ValidSlotsNum2
        {
            get => BufferList[1].SlotCount;
            set => BufferList[1].SlotCount = value;
        }
        private void UpdateBufferWafers(WaferInfo[] sourceWaferInfos, int index)
        {
            var wafers = UpdateWaferInfo(sourceWaferInfos.Reverse().ToArray());
            if (BufferList[index].WaferInfos == null)
            {
                BufferList[index].WaferInfos = wafers;
            }
            else
            {
                for (int i = 0; i < BufferList[index].WaferInfos.Length; i++)
                {
                    BufferList[index].WaferInfos[i].Update(wafers[i]);
                }
            }
        }

        [IgnorePropertyChange]
        public ComboBoxItem CycleFrom { get; set; }

        [IgnorePropertyChange]
        public ComboBoxItem CycleTo { get; set; }

        [IgnorePropertyChange]
        public bool Ll1IsChecked { get; set; }
        [IgnorePropertyChange]
        public bool Ll2IsChecked { get; set; }
        [IgnorePropertyChange]
        public bool Ll3IsChecked { get; set; }
        [IgnorePropertyChange]
        public bool Ll4IsChecked { get; set; }
        [IgnorePropertyChange]
        public bool Ll5IsChecked { get; set; }
        [IgnorePropertyChange]
        public bool Ll6IsChecked { get; set; }
        [IgnorePropertyChange]
        public bool Ll7IsChecked { get; set; }
        [IgnorePropertyChange]
        public bool Ll8IsChecked { get; set; }
        [IgnorePropertyChange]
        public bool CoolingBuffer1IsChecked { get; set; }
        [IgnorePropertyChange]
        public bool CoolingBuffer2IsChecked { get; set; }

        [IgnorePropertyChange]
        public bool Aligner1IsChecked { get; set; }
        [IgnorePropertyChange]
        public bool Aligner2IsChecked { get; set; }

        [IgnorePropertyChange]
        public bool Buffer1IsChecked { get; set; }
        [IgnorePropertyChange]
        public bool Buffer2IsChecked { get; set; }

        public Visibility ServerVisibility { get; set; }

        [Subscription("System.Robot.IsLeftArmPressureSensorON")]
        public bool IsLeftArmPressureSensorON
        {
            get; set;
        }
        [Subscription("System.Robot.IsRightArmPressureSensorON")]
        public bool IsRightArmPressureSensorON
        {
            get; set;
        }
        [Subscription("LP1.InfoPadCarrierTypeInformation")]
        public string LP1CarrierType
        {
            get => _lp1CarrierType;
            set => _lp1CarrierType = value;
        }
        private string _lp1CarrierType;

        [Subscription("LP2.InfoPadCarrierTypeInformation")]
        public string LP2CarrierType
        {
            get => _lp2CarrierType;
            set => _lp2CarrierType = value;
        }
        private string _lp2CarrierType;

        [Subscription("LP3.InfoPadCarrierTypeInformation")]
        public string LP3CarrierType
        {
            get => _lp3CarrierType;
            set => _lp3CarrierType = value;
        }
        private string _lp3CarrierType;

        [Subscription("LP1.IsAutoDetectCarrierType")]
        public bool LP1IsAutoDetectCarrierType { get; set; }
        [Subscription("LP2.IsAutoDetectCarrierType")]
        public bool LP2IsAutoDetectCarrierType { get; set; }
        [Subscription("LP3.IsAutoDetectCarrierType")]
        public bool LP3IsAutoDetectCarrierType { get; set; }

        [Subscription("LP1.ValidCarrierTypeList")]
        public Tuple<int, string>[] LP1ValidCarrierTypeList { get; set; }

        [Subscription("LP2.ValidCarrierTypeList")]
        public Tuple<int, string>[] LP2ValidCarrierTypeList { get; set; }

        [Subscription("LP3.ValidCarrierTypeList")]
        public Tuple<int, string>[] LP3ValidCarrierTypeList { get; set; }

        public bool IsShowLP1CarrierType
        {
            get
            { return !LP1IsAutoDetectCarrierType; }
        }

        public bool IsShowLP2CarrierType
        {
            get
            { return !LP2IsAutoDetectCarrierType; }
        }

        public bool IsShowLP3CarrierType
        {
            get
            { return !LP3IsAutoDetectCarrierType; }
        }

        public Thickness _PMThickness = new Thickness(0, 0, 0, 0);
        public Thickness PMThickness 
        {
            get
            {
                if (!IsEnableIdentifyThickness && !IsEnableMultiWaferSize)
                {
                    _PMThickness.Left = 0;
                    _PMThickness.Top = -100;
                    _PMThickness.Right = 0;
                    _PMThickness.Bottom = 0;

                }
                else if (!IsEnableIdentifyThickness&&IsEnableMultiWaferSize && !IsEnableMultiWaferSizeShow)
                {
                    _PMThickness.Left = 0;
                    _PMThickness.Top = -100;
                    _PMThickness.Right = 0;
                    _PMThickness.Bottom = 0;
                }
                else
                {
                    _PMThickness.Left = 680;
                    _PMThickness.Top = 645;
                    _PMThickness.Right = 0;
                    _PMThickness.Bottom = 50;
                }
                return _PMThickness;
            }
        }
        public Thickness _RobotThickness = new Thickness(0, 0, 0, 0);
        public Thickness RobotThickness
        {
            get
            {
                if (!IsEnableIdentifyThickness && !IsEnableMultiWaferSize)
                {
                    _RobotThickness.Left = 0;
                    _RobotThickness.Top = 300;
                    _RobotThickness.Right = 0;
                    _RobotThickness.Bottom = 0;

                }
                else if (!IsEnableIdentifyThickness && IsEnableMultiWaferSize && !IsEnableMultiWaferSizeShow)
                {
                    _RobotThickness.Left = 0;
                    _RobotThickness.Top = 300;
                    _RobotThickness.Right = 0;
                    _RobotThickness.Bottom = 0;
                }
                else
                {
                    _RobotThickness.Left = 10;
                    _RobotThickness.Top = 633;
                    _RobotThickness.Right = 0;
                    _RobotThickness.Bottom = 10;
                }
                return _RobotThickness;
            }
        }
        public override void UpdateWafers(WaferInfo[] sourceWaferInfos, int index)
        {
            if (IsSlotShowOpposite)
            {
                var wafers = UpdateWaferInfo(sourceWaferInfos);
                if (FoupList[index].WaferInfos == null)
                {
                    FoupList[index].WaferInfos = wafers;
                }
                else
                {
                    for (int i = 0; i < FoupList[index].WaferInfos.Length; i++)
                    {
                        FoupList[index].WaferInfos[i].Update(wafers[i]);
                    }
                }
            }
            else
            {
                var wafers = UpdateWaferInfo(sourceWaferInfos.Reverse().ToArray());
                if (FoupList[index].WaferInfos == null)
                {
                    FoupList[index].WaferInfos = wafers;
                }
                else
                {
                    for (int i = 0; i < FoupList[index].WaferInfos.Length; i++)
                    {
                        FoupList[index].WaferInfos[i].Update(wafers[i]);
                    }
                }
            }
        }
        public OperationViewModel2LP() : base(2)
        {
            WaferTransferOptionCommand = new DelegateCommand<WaferTransferOption>(BeforeTransfer);
            SetWaferSize3 = new DelegateCommand<string>(PerformSetWaferSize3);
            SetWaferSize4 = new DelegateCommand<string>(PerformSetWaferSize4);
            SetWaferSize6 = new DelegateCommand<string>(PerformSetWaferSize6);
            SetWaferSize8 = new DelegateCommand<string>(PerformSetWaferSize8);
            SetWaferThick =new DelegateCommand<string> (PerformSetWaferThick);
            SetWaferThin = new DelegateCommand<string>(PerformSetWaferThin);
            SetLPSlot13 = new DelegateCommand<string>(PerformSetSlot13);
            SetLPSlot25 = new DelegateCommand<string>(PerformSetSlot25);
            StartCycleCommand = new DelegateCommand<object>(StartCycle);
            SetFFUCommand = new DelegateCommand<string>(SetFFUSpeed);
            MapCommand = new DelegateCommand<DependencyObject>(DoMap);
            SetTransCarrierTypeCommand = new DelegateCommand<string>(SetTransCarrierType);
            _foupLists = new ObservableCollection<FoupListItem>();

        }
        protected void DoMap(DependencyObject sender)
        {
            var command = CommandHelper.GetCommandItem(sender);

            InvokeClient.Instance.Service.DoOperation(command.CommandName, command.Target);
        }
        private void SetTransCarrierType(string obj)
        {
            var LPName = obj;
            Tuple<int, string>[] input = null;
            switch (LPName)
            {
                case "LP1":
                    input = LP1ValidCarrierTypeList;
                    break;
                case "LP2":
                    input = LP2ValidCarrierTypeList;
                    break;
                case "LP3":
                    input = LP3ValidCarrierTypeList;
                    break;
                default:
                    break;
            }
            // Tuple<int, string>[] tempTuple = new Tuple<int, string>[] { Tuple.Create(0, "CarrierType0"), Tuple.Create(1, "CarrierType1") };
            if (input == null)
            {
                MessageBox.Show($"{LPName}ValidCarrierTypeList is null", "Value Null");
            }
            else
            {
                var SelectCarrierTypeDialog = new SelectCarrierTypeDialog(input);
                if ((bool)SelectCarrierTypeDialog.ShowDialog())
                {
                    InvokeClient.Instance.Service.DoOperation($"{LPName}.SetInfoPadIndex", SelectCarrierTypeDialog.SelectIndex);
                }
            }
        }
        private void SetFFUSpeed(string obj)
        {
            InvokeClient.Instance.Service.DoOperation($"FFU.SetSpeed", new object[] { obj });
        }
        private void PerformSetSlot13(string obj)
        {
            InvokeClient.Instance.Service.DoOperation("System.SetSlot13", obj);
        }
        private void PerformSetSlot25(string obj)
        {
            InvokeClient.Instance.Service.DoOperation("System.SetSlot25", obj);
        }
        private void PerformSetWaferSize8(string obj)
        {
            InvokeClient.Instance.Service.DoOperation("System.SetWaferSize8", obj);
        }
        private void PerformSetWaferSize6(string obj)
        {
            InvokeClient.Instance.Service.DoOperation("System.SetWaferSize6", obj);
        }

        private void PerformSetWaferSize4(string obj)
        {
            InvokeClient.Instance.Service.DoOperation("System.SetWaferSize4", obj);
        }

        private void PerformSetWaferSize3(string obj)
        {
            InvokeClient.Instance.Service.DoOperation("System.SetWaferSize3", obj);
        }
        private void PerformSetWaferThick(string obj)
        {   
            InvokeClient.Instance.Service.DoOperation("System.SetWaferThick", obj);
        }

        private void PerformSetWaferThin(string obj)
        {
            InvokeClient.Instance.Service.DoOperation("System.SetWaferThin", obj);
        }
        private void StartCycle(object obj)
        {
            if (CycleFrom == null || CycleTo == null)
                return;

            List<string> _lstPassThrough = new List<string>() { 
                
            };

            if (Aligner1IsChecked)
                _lstPassThrough.Add("Aligner1");

            if (Aligner2IsChecked)
                _lstPassThrough.Add("Aligner2");

            if (Ll1IsChecked)
                _lstPassThrough.Add("LL1");

            if (Ll2IsChecked)
                _lstPassThrough.Add("LL2");
            
            if (Buffer1IsChecked)
                _lstPassThrough.Add("Buffer1");

            if (Buffer2IsChecked)
                _lstPassThrough.Add("Buffer2");

            if (CoolingBuffer1IsChecked)
                _lstPassThrough.Add("CoolingBuffer1");

            if (CoolingBuffer2IsChecked)
                _lstPassThrough.Add("CoolingBuffer2");
           
            if (obj.ToString() == "Cycle")
            {
                InvokeClient.Instance.Service.DoOperation("System.StartCycle", new object[] {(string)CycleFrom.Content,
                (string)CycleTo.Content, _lstPassThrough.ToArray()
                }) ;
            }
            //else if (obj.ToString() == "Benchmark")
            //{
            //    InvokeClient.Instance.Service.DoOperation("Benchmark", paramsArgs);
            //}

        }

        public ICommand WaferTransferOptionCommand
        {
            get; set;
        }

        protected virtual void BeforeTransfer(WaferTransferOption option)
        {
            option.Setting.ShowAlign = false;
            option.Setting.ShowLaserMarker = false;
            option.Setting.ShowT7Code = false;
            //option.Setting.ShowBlade = false;
        }

        protected override void InitFoupList()
        {
            base.InitFoupList();
            //FoupList[0].FoupType = Controls.FoupType.OpenCassetteOnlyMap;
            //FoupList[1].FoupType = Controls.FoupType.OpenCassetteOnlyMap;
            FoupList[0].FoupType = Controls.FoupType.Loadport;
            FoupList[1].FoupType = Controls.FoupType.Loadport;

            InitBufferList(2);
            BufferList[0].FoupType = Controls.FoupType.Mapbuffer;
            BufferList[1].FoupType = Controls.FoupType.Mapbuffer;
        }
        protected readonly ModuleName[] bufferSet = new ModuleName[]
        {
            ModuleName.Buffer1,
            ModuleName.Buffer2,
        };

        public void InitBufferList(int loadLockCount)
        {
            BufferList = new ObservableCollection<FoupListItem>();
            for (var i = 0; i < loadLockCount; i++)
            {
                var foupListItem = new FoupListItem
                {
                    DeviceName = bufferSet[i].ToString(),
                    CarrierName = bufferSet[i].ToString(),
                    CarrierMode = LoadPortCarrierMode.Loader,
                    Station = bufferSet[i]
                };
                BufferList.Add(foupListItem);
            }
        }
        protected override void InvokeBeforeUpdateProperty(Dictionary<string, object> data)
        {
            //ServerVisibility = ((bool)QueryDataClient.Instance.Service.GetConfig("System.EfemServerEnable")) ? Visibility.Visible : Visibility.Hidden;
            //data[UIKey(UnitName.LoadportA.ToString(), ParamName.FoupDoorState)] = FoupDoorState.Close;

            base.InvokeBeforeUpdateProperty(data);
        }
    }



}