using Aitex.Core.Common;
using Aitex.Core.UI.MVVM;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using Aitex.Sorter.UI.Controls;
using Aitex.Sorter.UI.Controls.Common;
using MECF.Framework.Common.OperationCenter;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using System.Windows.Input;
using System.Windows.Threading;
using Aitex.Core.RT.Log;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Equipment;
using System.Windows.Controls;

namespace Aitex.Sorter.UI.ViewModel
{
    public class FoupListViewModelBase : UIViewModelBase
    {
        public ObservableCollection<FoupListItem> FoupList { get; set; }

        public virtual void UpdateWafers(WaferInfo[] sourceWaferInfos, int index)
        {
            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]);
                }
            }
        }

        [Subscription(ParamName.IsAutoMode, SystemStateModule)]
        public bool IsAutoMode { get; set; }

        [Subscription("IsOnlineRemote", SystemStateModule)]
        public bool IsOnlineRemote { get; set; }



        [Subscription(ParamName.ModuleWaferList, "LP1")]
        public WaferInfo[] FoupAWaferInfo
        {
            get
            {
                return FoupList[0].WaferInfos;
            }
            set
            {
                UpdateWafers(value, 0);
            }
        }



        [Subscription(ParamName.ModuleWaferList, "LP2")]
        public WaferInfo[] FoupBWaferInfo
        {
            get
            {
                return FoupList[1].WaferInfos;
            }
            set
            {
                UpdateWafers(value, 1);
            }
        }

        [Subscription(ParamName.ModuleWaferList, "LP3")]
        public WaferInfo[] FoupCWaferInfo
        {
            get
            {
                return FoupList[2].WaferInfos;
            }
            set
            {
                UpdateWafers(value, 2);
            }
        }

        [Subscription(ParamName.ModuleWaferList, "LP4")]
        public WaferInfo[] FoupDWaferInfo
        {
            get
            {
                return FoupList[3].WaferInfos;
            }
            set
            {
                UpdateWafers(value, 3);
            }
        }

        [Subscription(ParamName.ModuleWaferList, "LP5")]
        public WaferInfo[] FoupEWaferInfo
        {
            get
            {
                return FoupList[4].WaferInfos;
            }
            set
            {
                UpdateWafers(value, 4);
            }
        }

        [Subscription(ParamName.ModuleWaferList, "LP6")]
        public WaferInfo[] FoupFWaferInfo
        {
            get
            {
                return FoupList[5].WaferInfos;
            }
            set
            {
                UpdateWafers(value, 5);
            }
        }

        [Subscription(ParamName.ModuleWaferList, "LP7")]
        public WaferInfo[] FoupGWaferInfo
        {
            get
            {
                return FoupList[6].WaferInfos;
            }
            set
            {
                UpdateWafers(value, 6);
            }
        }

        [Subscription(ParamName.ModuleWaferList, "LP8")]
        public WaferInfo[] FoupHWaferInfo
        {
            get
            {
                return FoupList[7].WaferInfos;
            }
            set
            {
                UpdateWafers(value, 7);
            }
        }

        [Subscription(ParamName.ModuleWaferList, "LP9")]
        public WaferInfo[] FoupIWaferInfo
        {
            get
            {
                return FoupList[8].WaferInfos;
            }
            set
            {
                UpdateWafers(value, 8);
            }
        }

        [Subscription(ParamName.ModuleWaferList, "LP10")]
        public WaferInfo[] FoupJWaferInfo
        {
            get
            {
                return FoupList[9].WaferInfos;
            }
            set
            {
                UpdateWafers(value, 9);
            }
        }

        [Subscription(ParamName.CarrierId, DeviceName.LP1)]
        public string FoupID1
        {
            get
            {
                return FoupList[0].FoupID;
            }
            set
            {
                FoupList[0].FoupID = value;
            }
        }

        [Subscription(ParamName.CarrierId, DeviceName.LP2)]
        public string FoupID2
        {
            get
            {
                return FoupList[1].FoupID;
            }
            set
            {
                FoupList[1].FoupID = value;
            }
        }

        [Subscription(ParamName.CarrierId, DeviceName.LP3)]
        public string FoupID3
        {
            get
            {
                return FoupList[2].FoupID;
            }
            set
            {
                FoupList[2].FoupID = value;
            }
        }

        [Subscription(ParamName.CarrierId, DeviceName.LP4)]
        public string FoupID4
        {
            get
            {
                return FoupList[3].FoupID;
            }
            set
            {
                FoupList[3].FoupID = value;
            }
        }

        [Subscription(ParamName.CarrierId, DeviceName.LP5)]
        public string FoupID5
        {
            get
            {
                return FoupList[4].FoupID;
            }
            set
            {
                FoupList[4].FoupID = value;
            }
        }

        [Subscription(ParamName.CarrierId, DeviceName.LP6)]
        public string FoupID6
        {
            get
            {
                return FoupList[5].FoupID;
            }
            set
            {
                FoupList[5].FoupID = value;
            }
        }

        [Subscription(ParamName.CarrierId, DeviceName.LP7)]
        public string FoupID7
        {
            get
            {
                return FoupList[6].FoupID;
            }
            set
            {
                FoupList[6].FoupID = value;
            }
        }

        [Subscription(ParamName.CarrierId, DeviceName.LP8)]
        public string FoupID8
        {
            get => FoupList[7].FoupID;
            set => FoupList[7].FoupID = value;
        }

        [Subscription(ParamName.CarrierId, DeviceName.LP9)]
        public string FoupID9
        {
            get => FoupList[8].FoupID;
            set => FoupList[8].FoupID = value;
        }

        [Subscription(ParamName.CarrierId, DeviceName.LP10)]
        public string FoupID10
        {
            get => FoupList[9].FoupID;
            set => FoupList[9].FoupID = value;
        }

        [Subscription("IsWaferProtrude", DeviceName.LP1)]
        public bool IsWaferProtrude1
        {
            get => FoupList[0].IsWaferProtrude;
            set => FoupList[0].IsWaferProtrude = value;
        }

        [Subscription("IsWaferProtrude", DeviceName.LP2)]
        public bool IsWaferProtrude2
        {
            get => FoupList[1].IsWaferProtrude;
            set => FoupList[1].IsWaferProtrude = value;
        }


        [Subscription(ParamName.IsPresent, DeviceName.LP1)]
        public bool Present1
        {
            get => FoupList[0].Present;
            set => FoupList[0].Present = value;
        }

        [Subscription(ParamName.IsPresent, DeviceName.LP2)]
        public bool Present2
        {
            get => FoupList[1].Present;
            set => FoupList[1].Present = value;
        }

        [Subscription(ParamName.IsPresent, DeviceName.LP3)]
        public bool Present3
        {
            get => FoupList[2].Present;
            set => FoupList[2].Present = value;
        }

        [Subscription(ParamName.IsPresent, DeviceName.LP4)]
        public bool Present4
        {
            get => FoupList[3].Present;
            set => FoupList[3].Present = value;
        }

        [Subscription(ParamName.IsPresent, DeviceName.LP5)]
        public bool Present5
        {
            get => FoupList[4].Present;
            set => FoupList[4].Present = value;
        }

        [Subscription(ParamName.IsPresent, DeviceName.LP6)]
        public bool Present6
        {
            get => FoupList[5].Present;
            set => FoupList[5].Present = value;
        }

        [Subscription(ParamName.IsPresent, DeviceName.LP7)]
        public bool Present7
        {
            get => FoupList[6].Present;
            set => FoupList[6].Present = value;
        }

        [Subscription(ParamName.IsPresent, DeviceName.LP8)]
        public bool Present8
        {
            get => FoupList[7].Present;
            set => FoupList[7].Present = value;
        }

        [Subscription(ParamName.IsPresent, DeviceName.LP9)]
        public bool Present9
        {
            get => FoupList[8].Present;
            set => FoupList[8].Present = value;
        }

        [Subscription(ParamName.IsPresent, DeviceName.LP10)]
        public bool Present10
        {
            get => FoupList[9].Present;
            set => FoupList[9].Present = value;
        }

        [Subscription(ParamName.IsPlaced, DeviceName.LP1)]
        public bool Placement1
        {
            get => FoupList[0].Placement;
            set => FoupList[0].Placement = value;
        }

        [Subscription(ParamName.IsPlaced, DeviceName.LP2)]
        public bool Placement2
        {
            get => FoupList[1].Placement;
            set => FoupList[1].Placement = value;
        }

        [Subscription(ParamName.IsPlaced, DeviceName.LP3)]
        public bool Placement3
        {
            get => FoupList[2].Placement;
            set => FoupList[2].Placement = value;
        }

        [Subscription(ParamName.IsPlaced, DeviceName.LP4)]
        public bool Placement4
        {
            get => FoupList[3].Placement;
            set => FoupList[3].Placement = value;
        }

        [Subscription(ParamName.IsPlaced, DeviceName.LP5)]
        public bool Placement5
        {
            get => FoupList[4].Placement;
            set => FoupList[4].Placement = value;
        }

        [Subscription(ParamName.IsPlaced, DeviceName.LP6)]
        public bool Placement6
        {
            get => FoupList[5].Placement;
            set => FoupList[5].Placement = value;
        }

        [Subscription(ParamName.IsPlaced, DeviceName.LP7)]
        public bool Placement7
        {
            get => FoupList[6].Placement;
            set => FoupList[6].Placement = value;
        }

        [Subscription(ParamName.IsPlaced, DeviceName.LP8)]
        public bool Placement8
        {
            get => FoupList[7].Placement;
            set => FoupList[7].Placement = value;
        }

        [Subscription(ParamName.IsPlaced, DeviceName.LP9)]
        public bool Placement9
        {
            get => FoupList[8].Placement;
            set => FoupList[8].Placement = value;
        }

        [Subscription(ParamName.IsPlaced, DeviceName.LP10)]
        public bool Placement10
        {
            get => FoupList[9].Placement;
            set => FoupList[9].Placement = value;
        }

        [Subscription("IsCarrierEnabled", DeviceName.LP1)]
        public bool IsCarrierEnabled1
        {
            get => FoupList[0].IsCarrierEnabled;
            set => FoupList[0].IsCarrierEnabled = value;
        }

        [Subscription("IsCarrierEnabled", DeviceName.LP2)]
        public bool IsCarrierEnabled2
        {
            get => FoupList[1].IsCarrierEnabled;
            set => FoupList[1].IsCarrierEnabled = value;
        }
        [Subscription("IsCarrierEnabled", DeviceName.LP3)]
        public bool IsCarrierEnabled3
        {
            get => FoupList[2].IsCarrierEnabled;
            set => FoupList[2].IsCarrierEnabled = value;
        }

        [Subscription("IsCarrierEnabled", DeviceName.LP4)]
        public bool IsCarrierEnabled4
        {
            get => FoupList[3].IsCarrierEnabled;
            set => FoupList[3].IsCarrierEnabled = value;
        }
        [Subscription("IsCarrierEnabled", DeviceName.LP5)]
        public bool IsCarrierEnabled5
        {
            get => FoupList[4].IsCarrierEnabled;
            set => FoupList[4].IsCarrierEnabled = value;
        }
        [Subscription("IsCarrierEnabled", DeviceName.LP6)]
        public bool IsCarrierEnabled6
        {
            get => FoupList[5].IsCarrierEnabled;
            set => FoupList[5].IsCarrierEnabled = value;
        }
        [Subscription("IsCarrierEnabled", DeviceName.LP7)]
        public bool IsCarrierEnabled7
        {
            get => FoupList[6].IsCarrierEnabled;
            set => FoupList[6].IsCarrierEnabled = value;
        }
        [Subscription("IsCarrierEnabled", DeviceName.LP8)]
        public bool IsCarrierEnabled8
        {
            get => FoupList[7].IsCarrierEnabled;
            set => FoupList[7].IsCarrierEnabled = value;
        }
        [Subscription("IsCarrierEnabled", DeviceName.LP9)]
        public bool IsCarrierEnabled9
        {
            get => FoupList[8].IsCarrierEnabled;
            set => FoupList[8].IsCarrierEnabled = value;
        }
        [Subscription("IsCarrierEnabled", DeviceName.LP10)]
        public bool IsCarrierEnabled10
        {
            get => FoupList[9].IsCarrierEnabled;
            set => FoupList[9].IsCarrierEnabled = value;
        }
        [Subscription(ParamName.LoadportState, DeviceName.LoadportA)]
        public string LoadportAState
        {
            get
            {
                return FoupList[0].LoadportState;
            }
            set
            {
                FoupList[0].LoadportState = value;
            }
        }

        [Subscription(ParamName.LoadportState, DeviceName.LoadportB)]
        public string LoadportBState
        {
            get
            {
                return FoupList[1].LoadportState;
            }
            set
            {
                FoupList[1].LoadportState = value;
            }
        }

        [Subscription(ParamName.LoadportState, DeviceName.LoadportC)]
        public string LoadportCState
        {
            get
            {
                return FoupList[2].LoadportState;
            }
            set
            {
                FoupList[2].LoadportState = value;
            }
        }

        [Subscription(ParamName.LoadportState, DeviceName.LoadportD)]
        public string LoadportDState
        {
            get
            {
                return FoupList[3].LoadportState;
            }
            set
            {
                FoupList[3].LoadportState = value;
            }
        }

        [Subscription(ParamName.CassetteState, DeviceName.LP1)]
        public LoadportCassetteState CassetteState1
        {
            get => FoupList[0].CassetteState;
            set => FoupList[0].CassetteState = value;
        }

        [Subscription(ParamName.CassetteState, DeviceName.LP2)]
        public LoadportCassetteState CassetteState2
        {
            get => FoupList[1].CassetteState;
            set => FoupList[1].CassetteState = value;
        }

        [Subscription(ParamName.CassetteState, DeviceName.LP3)]
        public LoadportCassetteState CassetteState3
        {
            get => FoupList[2].CassetteState;
            set => FoupList[2].CassetteState = value;
        }

        [Subscription(ParamName.CassetteState, DeviceName.LP4)]
        public LoadportCassetteState CassetteState4
        {
            get => FoupList[3].CassetteState;
            set => FoupList[3].CassetteState = value;
        }

        [Subscription(ParamName.CassetteState, DeviceName.LP5)]
        public LoadportCassetteState CassetteState5
        {
            get => FoupList[4].CassetteState;
            set => FoupList[4].CassetteState = value;
        }

        [Subscription(ParamName.CassetteState, DeviceName.LP6)]
        public LoadportCassetteState CassetteState6
        {
            get => FoupList[5].CassetteState;
            set => FoupList[5].CassetteState = value;
        }

        [Subscription(ParamName.CassetteState, DeviceName.LP7)]
        public LoadportCassetteState CassetteState7
        {
            get => FoupList[6].CassetteState;
            set => FoupList[6].CassetteState = value;
        }

        [Subscription(ParamName.CassetteState, DeviceName.LP8)]
        public LoadportCassetteState CassetteState8
        {
            get => FoupList[7].CassetteState;
            set => FoupList[7].CassetteState = value;
        }

        [Subscription(ParamName.CassetteState, DeviceName.LP9)]
        public LoadportCassetteState CassetteState9
        {
            get => FoupList[8].CassetteState;
            set => FoupList[8].CassetteState = value;
        }

        [Subscription(ParamName.CassetteState, DeviceName.LP10)]
        public LoadportCassetteState CassetteState10
        {
            get => FoupList[9].CassetteState;
            set => FoupList[9].CassetteState = value;
        }

        [Subscription(ParamName.IndicatiorLoad, DeviceName.LP1)]
        public IndicatorState IndicatiorLoad1
        {
            get => FoupList[0].IndicatiorLoad;
            set => FoupList[0].IndicatiorLoad = value;
        }

        [Subscription(ParamName.IndicatiorLoad, DeviceName.LP2)]
        public IndicatorState IndicatiorLoad2
        {
            get => FoupList[1].IndicatiorLoad;
            set => FoupList[1].IndicatiorLoad = value;
        }

        [Subscription(ParamName.IndicatiorLoad, DeviceName.LP3)]
        public IndicatorState IndicatiorLoad3
        {
            get => FoupList[2].IndicatiorLoad;
            set => FoupList[2].IndicatiorLoad = value;
        }

        [Subscription(ParamName.IndicatiorLoad, DeviceName.LP4)]
        public IndicatorState IndicatiorLoad4
        {
            get => FoupList[3].IndicatiorLoad;
            set => FoupList[3].IndicatiorLoad = value;
        }

        [Subscription(ParamName.IndicatiorLoad, DeviceName.LP5)]
        public IndicatorState IndicatiorLoad5
        {
            get => FoupList[4].IndicatiorLoad;
            set => FoupList[4].IndicatiorLoad = value;
        }

        [Subscription(ParamName.IndicatiorLoad, DeviceName.LP6)]
        public IndicatorState IndicatiorLoad6
        {
            get => FoupList[5].IndicatiorLoad;
            set => FoupList[5].IndicatiorLoad = value;
        }

        [Subscription(ParamName.IndicatiorLoad, DeviceName.LP7)]
        public IndicatorState IndicatiorLoad7
        {
            get => FoupList[6].IndicatiorLoad;
            set => FoupList[6].IndicatiorLoad = value;
        }

        [Subscription(ParamName.IndicatiorLoad, DeviceName.LP8)]
        public IndicatorState IndicatiorLoad8
        {
            get => FoupList[7].IndicatiorLoad;
            set => FoupList[7].IndicatiorLoad = value;
        }

        [Subscription(ParamName.IndicatiorLoad, DeviceName.LP9)]
        public IndicatorState IndicatiorLoad9
        {
            get => FoupList[8].IndicatiorLoad;
            set => FoupList[8].IndicatiorLoad = value;
        }

        [Subscription(ParamName.IndicatiorLoad, DeviceName.LP10)]
        public IndicatorState IndicatiorLoad10
        {
            get => FoupList[9].IndicatiorLoad;
            set => FoupList[9].IndicatiorLoad = value;
        }

        [Subscription(ParamName.IndicatiorUnload, DeviceName.LP1)]
        public IndicatorState IndicatiorUnload1
        {
            get => FoupList[0].IndicatiorUnload;
            set => FoupList[0].IndicatiorUnload = value;
        }

        [Subscription(ParamName.IndicatiorUnload, DeviceName.LP2)]
        public IndicatorState IndicatiorUnload2
        {
            get => FoupList[1].IndicatiorUnload;
            set => FoupList[1].IndicatiorUnload = value;
        }

        [Subscription(ParamName.IndicatiorUnload, DeviceName.LP3)]
        public IndicatorState IndicatiorUnload3
        {
            get => FoupList[2].IndicatiorUnload;
            set => FoupList[2].IndicatiorUnload = value;
        }

        [Subscription(ParamName.IndicatiorUnload, DeviceName.LP4)]
        public IndicatorState IndicatiorUnload4
        {
            get => FoupList[3].IndicatiorUnload;
            set => FoupList[3].IndicatiorUnload = value;
        }

        [Subscription(ParamName.IndicatiorUnload, DeviceName.LP5)]
        public IndicatorState IndicatiorUnload5
        {
            get => FoupList[4].IndicatiorUnload;
            set => FoupList[4].IndicatiorUnload = value;
        }

        [Subscription(ParamName.IndicatiorUnload, DeviceName.LP6)]
        public IndicatorState IndicatiorUnload6
        {
            get => FoupList[5].IndicatiorUnload;
            set => FoupList[5].IndicatiorUnload = value;
        }

        [Subscription(ParamName.IndicatiorUnload, DeviceName.LP7)]
        public IndicatorState IndicatiorUnload7
        {
            get => FoupList[6].IndicatiorUnload;
            set => FoupList[6].IndicatiorUnload = value;
        }

        [Subscription(ParamName.IndicatiorUnload, DeviceName.LP8)]
        public IndicatorState IndicatiorUnload8
        {
            get => FoupList[7].IndicatiorUnload;
            set => FoupList[7].IndicatiorUnload = value;
        }

        [Subscription(ParamName.IndicatiorUnload, DeviceName.LP9)]
        public IndicatorState IndicatiorUnload9
        {
            get => FoupList[8].IndicatiorUnload;
            set => FoupList[8].IndicatiorUnload = value;
        }

        [Subscription(ParamName.IndicatiorUnload, DeviceName.LP10)]
        public IndicatorState IndicatiorUnload10
        {
            get => FoupList[9].IndicatiorUnload;
            set => FoupList[9].IndicatiorUnload = value;
        }

        [Subscription(ParamName.IndicatiorPresence, DeviceName.LP1)]
        public IndicatorState IndicatiorPresence1
        {
            get => FoupList[0].IndicatiorPresence;
            set => FoupList[0].IndicatiorPresence = value;
        }

        [Subscription(ParamName.IndicatiorPresence, DeviceName.LP2)]
        public IndicatorState IndicatiorPresence2
        {
            get => FoupList[1].IndicatiorPresence;
            set => FoupList[1].IndicatiorPresence = value;
        }

        [Subscription(ParamName.IndicatiorPresence, DeviceName.LP3)]
        public IndicatorState IndicatiorPresence3
        {
            get => FoupList[2].IndicatiorPresence;
            set => FoupList[2].IndicatiorPresence = value;
        }

        [Subscription(ParamName.IndicatiorPresence, DeviceName.LP4)]
        public IndicatorState IndicatiorPresence4
        {
            get => FoupList[3].IndicatiorPresence;
            set => FoupList[3].IndicatiorPresence = value;
        }

        [Subscription(ParamName.IndicatiorPresence, DeviceName.LP5)]
        public IndicatorState IndicatiorPresence5
        {
            get => FoupList[4].IndicatiorPresence;
            set => FoupList[4].IndicatiorPresence = value;
        }

        [Subscription(ParamName.IndicatiorPresence, DeviceName.LP6)]
        public IndicatorState IndicatiorPresence6
        {
            get => FoupList[5].IndicatiorPresence;
            set => FoupList[5].IndicatiorPresence = value;
        }

        [Subscription(ParamName.IndicatiorPresence, DeviceName.LP7)]
        public IndicatorState IndicatiorPresence7
        {
            get => FoupList[6].IndicatiorPresence;
            set => FoupList[6].IndicatiorPresence = value;
        }

        [Subscription(ParamName.IndicatiorPresence, DeviceName.LP8)]
        public IndicatorState IndicatiorPresence8
        {
            get => FoupList[7].IndicatiorPresence;
            set => FoupList[7].IndicatiorPresence = value;
        }

        [Subscription(ParamName.IndicatiorPresence, DeviceName.LP9)]
        public IndicatorState IndicatiorPresence9
        {
            get => FoupList[8].IndicatiorPresence;
            set => FoupList[8].IndicatiorPresence = value;
        }

        [Subscription(ParamName.IndicatiorPresence, DeviceName.LP10)]
        public IndicatorState IndicatiorPresence10
        {
            get => FoupList[9].IndicatiorPresence;
            set => FoupList[9].IndicatiorPresence = value;
        }

        [Subscription(ParamName.IndicatiorPlacement, DeviceName.LP1)]
        public IndicatorState IndicatiorPlacement1
        {
            get => FoupList[0].IndicatiorPlacement;
            set => FoupList[0].IndicatiorPlacement = value;
        }

        [Subscription(ParamName.IndicatiorPlacement, DeviceName.LP2)]
        public IndicatorState IndicatiorPlacement2
        {
            get => FoupList[1].IndicatiorPlacement;
            set => FoupList[1].IndicatiorPlacement = value;
        }

        [Subscription(ParamName.IndicatiorPlacement, DeviceName.LP3)]
        public IndicatorState IndicatiorPlacement3
        {
            get => FoupList[2].IndicatiorPlacement;
            set => FoupList[2].IndicatiorPlacement = value;
        }

        [Subscription(ParamName.IndicatiorPlacement, DeviceName.LP4)]
        public IndicatorState IndicatiorPlacement4
        {
            get => FoupList[3].IndicatiorPlacement;
            set => FoupList[3].IndicatiorPlacement = value;
        }

        [Subscription(ParamName.IndicatiorPlacement, DeviceName.LP5)]
        public IndicatorState IndicatiorPlacement5
        {
            get => FoupList[4].IndicatiorPlacement;
            set => FoupList[4].IndicatiorPlacement = value;
        }

        [Subscription(ParamName.IndicatiorPlacement, DeviceName.LP6)]
        public IndicatorState IndicatiorPlacement6
        {
            get => FoupList[5].IndicatiorPlacement;
            set => FoupList[5].IndicatiorPlacement = value;
        }

        [Subscription(ParamName.IndicatiorPlacement, DeviceName.LP7)]
        public IndicatorState IndicatiorPlacement7
        {
            get => FoupList[6].IndicatiorPlacement;
            set => FoupList[6].IndicatiorPlacement = value;
        }

        [Subscription(ParamName.IndicatiorPlacement, DeviceName.LP8)]
        public IndicatorState IndicatiorPlacement8
        {
            get => FoupList[7].IndicatiorPlacement;
            set => FoupList[7].IndicatiorPlacement = value;
        }

        [Subscription(ParamName.IndicatiorPlacement, DeviceName.LP9)]
        public IndicatorState IndicatiorPlacement9
        {
            get => FoupList[8].IndicatiorPlacement;
            set => FoupList[8].IndicatiorPlacement = value;
        }

        [Subscription(ParamName.IndicatiorPlacement, DeviceName.LP10)]
        public IndicatorState IndicatiorPlacement10
        {
            get => FoupList[9].IndicatiorPlacement;
            set => FoupList[9].IndicatiorPlacement = value;
        }

        [Subscription(ParamName.IndicatiorOpAccess, DeviceName.LP1)]
        public IndicatorState IndicatiorOpAccess1
        {
            get => FoupList[0].IndicatiorOpAccess;
            set => FoupList[0].IndicatiorOpAccess = value;
        }

        [Subscription(ParamName.IndicatiorOpAccess, DeviceName.LP2)]
        public IndicatorState IndicatiorOpAccess2
        {
            get => FoupList[1].IndicatiorOpAccess;
            set => FoupList[1].IndicatiorOpAccess = value;
        }

        [Subscription(ParamName.IndicatiorOpAccess, DeviceName.LP3)]
        public IndicatorState IndicatiorOpAccess3
        {
            get => FoupList[2].IndicatiorOpAccess;
            set => FoupList[2].IndicatiorOpAccess = value;
        }

        [Subscription(ParamName.IndicatiorOpAccess, DeviceName.LP4)]
        public IndicatorState IndicatiorOpAccess4
        {
            get => FoupList[3].IndicatiorOpAccess;
            set => FoupList[3].IndicatiorOpAccess = value;
        }

        [Subscription(ParamName.IndicatiorOpAccess, DeviceName.LP5)]
        public IndicatorState IndicatiorOpAccess5
        {
            get => FoupList[4].IndicatiorOpAccess;
            set => FoupList[4].IndicatiorOpAccess = value;
        }

        [Subscription(ParamName.IndicatiorOpAccess, DeviceName.LP6)]
        public IndicatorState IndicatiorOpAccess6
        {
            get => FoupList[5].IndicatiorOpAccess;
            set => FoupList[5].IndicatiorOpAccess = value;
        }

        [Subscription(ParamName.IndicatiorOpAccess, DeviceName.LP7)]
        public IndicatorState IndicatiorOpAccess7
        {
            get => FoupList[6].IndicatiorOpAccess;
            set => FoupList[6].IndicatiorOpAccess = value;
        }

        [Subscription(ParamName.IndicatiorOpAccess, DeviceName.LP8)]
        public IndicatorState IndicatiorOpAccess8
        {
            get => FoupList[7].IndicatiorOpAccess;
            set => FoupList[7].IndicatiorOpAccess = value;
        }

        [Subscription(ParamName.IndicatiorOpAccess, DeviceName.LP9)]
        public IndicatorState IndicatiorOpAccess9
        {
            get => FoupList[8].IndicatiorOpAccess;
            set => FoupList[8].IndicatiorOpAccess = value;
        }

        [Subscription(ParamName.IndicatiorOpAccess, DeviceName.LP10)]
        public IndicatorState IndicatiorOpAccess10
        {
            get => FoupList[9].IndicatiorOpAccess;
            set => FoupList[9].IndicatiorOpAccess = value;
        }

        [Subscription(ParamName.IndicatiorAlarm, DeviceName.LP1)]
        public IndicatorState IndicatiorAlarm1
        {
            get => FoupList[0].IndicatiorAlarm;
            set => FoupList[0].IndicatiorAlarm = value;
        }

        [Subscription(ParamName.IndicatiorAlarm, DeviceName.LP2)]
        public IndicatorState IndicatiorAlarm2
        {
            get => FoupList[1].IndicatiorAlarm;
            set => FoupList[1].IndicatiorAlarm = value;
        }

        [Subscription(ParamName.IndicatiorAlarm, DeviceName.LP3)]
        public IndicatorState IndicatiorAlarm3
        {
            get => FoupList[2].IndicatiorAlarm;
            set => FoupList[2].IndicatiorAlarm = value;
        }

        [Subscription(ParamName.IndicatiorAlarm, DeviceName.LP4)]
        public IndicatorState IndicatiorAlarm4
        {
            get => FoupList[3].IndicatiorAlarm;
            set => FoupList[3].IndicatiorAlarm = value;
        }

        [Subscription(ParamName.IndicatiorAlarm, DeviceName.LP5)]
        public IndicatorState IndicatiorAlarm5
        {
            get => FoupList[4].IndicatiorAlarm;
            set => FoupList[4].IndicatiorAlarm = value;
        }

        [Subscription(ParamName.IndicatiorAlarm, DeviceName.LP6)]
        public IndicatorState IndicatiorAlarm6
        {
            get => FoupList[5].IndicatiorAlarm;
            set => FoupList[5].IndicatiorAlarm = value;
        }

        [Subscription(ParamName.IndicatiorAlarm, DeviceName.LP7)]
        public IndicatorState IndicatiorAlarm7
        {
            get => FoupList[6].IndicatiorAlarm;
            set => FoupList[6].IndicatiorAlarm = value;
        }

        [Subscription(ParamName.IndicatiorAlarm, DeviceName.LP8)]
        public IndicatorState IndicatiorAlarm8
        {
            get => FoupList[7].IndicatiorAlarm;
            set => FoupList[7].IndicatiorAlarm = value;
        }

        [Subscription(ParamName.IndicatiorAlarm, DeviceName.LP9)]
        public IndicatorState IndicatiorAlarm9
        {
            get => FoupList[8].IndicatiorAlarm;
            set => FoupList[8].IndicatiorAlarm = value;
        }

        [Subscription(ParamName.IndicatiorAlarm, DeviceName.LP10)]
        public IndicatorState IndicatiorAlarm10
        {
            get => FoupList[9].IndicatiorAlarm;
            set => FoupList[9].IndicatiorAlarm = value;
        }

        [Subscription(ParamName.IndicatiorAccessAuto, DeviceName.LP1)]
        public IndicatorState IndicatiorAccessAuto1
        {
            get => FoupList[0].IndicatiorAccessAuto;
            set => FoupList[0].IndicatiorAccessAuto = value;
        }

        [Subscription(ParamName.IndicatiorAccessAuto, DeviceName.LP2)]
        public IndicatorState IndicatiorAccessAuto2
        {
            get => FoupList[1].IndicatiorAccessAuto;
            set => FoupList[1].IndicatiorAccessAuto = value;
        }

        [Subscription(ParamName.IndicatiorAccessAuto, DeviceName.LP3)]
        public IndicatorState IndicatiorAccessAuto3
        {
            get => FoupList[2].IndicatiorAccessAuto;
            set => FoupList[2].IndicatiorAccessAuto = value;
        }

        [Subscription(ParamName.IndicatiorAccessAuto, DeviceName.LP4)]
        public IndicatorState IndicatiorAccessAuto4
        {
            get => FoupList[3].IndicatiorAccessAuto;
            set => FoupList[3].IndicatiorAccessAuto = value;
        }

        [Subscription(ParamName.IndicatiorAccessAuto, DeviceName.LP5)]
        public IndicatorState IndicatiorAccessAuto5
        {
            get => FoupList[4].IndicatiorAccessAuto;
            set => FoupList[4].IndicatiorAccessAuto = value;
        }

        [Subscription(ParamName.IndicatiorAccessAuto, DeviceName.LP6)]
        public IndicatorState IndicatiorAccessAuto6
        {
            get => FoupList[5].IndicatiorAccessAuto;
            set => FoupList[5].IndicatiorAccessAuto = value;
        }

        [Subscription(ParamName.IndicatiorAccessAuto, DeviceName.LP7)]
        public IndicatorState IndicatiorAccessAuto7
        {
            get => FoupList[6].IndicatiorAccessAuto;
            set => FoupList[6].IndicatiorAccessAuto = value;
        }

        [Subscription(ParamName.IndicatiorAccessAuto, DeviceName.LP8)]
        public IndicatorState IndicatiorAccessAuto8
        {
            get => FoupList[7].IndicatiorAccessAuto;
            set => FoupList[7].IndicatiorAccessAuto = value;
        }

        [Subscription(ParamName.IndicatiorAccessAuto, DeviceName.LP9)]
        public IndicatorState IndicatiorAccessAuto9
        {
            get => FoupList[8].IndicatiorAccessAuto;
            set => FoupList[8].IndicatiorAccessAuto = value;
        }

        [Subscription(ParamName.IndicatiorAccessAuto, DeviceName.LP10)]
        public IndicatorState IndicatiorAccessAuto10
        {
            get => FoupList[9].IndicatiorAccessAuto;
            set => FoupList[9].IndicatiorAccessAuto = value;
        }

        [Subscription(ParamName.IndicatiorAccessManual, DeviceName.LP1)]
        public IndicatorState IndicatiorAccessManual1
        {
            get => FoupList[0].IndicatiorAccessManual;
            set => FoupList[0].IndicatiorAccessManual = value;
        }

        [Subscription(ParamName.IndicatiorAccessManual, DeviceName.LP2)]
        public IndicatorState IndicatiorAccessManual2
        {
            get => FoupList[1].IndicatiorAccessManual;
            set => FoupList[1].IndicatiorAccessManual = value;
        }

        [Subscription(ParamName.IndicatiorAccessManual, DeviceName.LP3)]
        public IndicatorState IndicatiorAccessManual3
        {
            get => FoupList[2].IndicatiorAccessManual;
            set => FoupList[2].IndicatiorAccessManual = value;
        }

        [Subscription(ParamName.IndicatiorAccessManual, DeviceName.LP4)]
        public IndicatorState IndicatiorAccessManual4
        {
            get => FoupList[3].IndicatiorAccessManual;
            set => FoupList[3].IndicatiorAccessManual = value;
        }

        [Subscription(ParamName.IndicatiorAccessManual, DeviceName.LP5)]
        public IndicatorState IndicatiorAccessManual5
        {
            get => FoupList[4].IndicatiorAccessManual;
            set => FoupList[4].IndicatiorAccessManual = value;
        }

        [Subscription(ParamName.IndicatiorAccessManual, DeviceName.LP6)]
        public IndicatorState IndicatiorAccessManual6
        {
            get => FoupList[5].IndicatiorAccessManual;
            set => FoupList[5].IndicatiorAccessManual = value;
        }

        [Subscription(ParamName.IndicatiorAccessManual, DeviceName.LP7)]
        public IndicatorState IndicatiorAccessManual7
        {
            get => FoupList[6].IndicatiorAccessManual;
            set => FoupList[6].IndicatiorAccessManual = value;
        }

        [Subscription(ParamName.IndicatiorAccessManual, DeviceName.LP8)]
        public IndicatorState IndicatiorAccessManual8
        {
            get => FoupList[7].IndicatiorAccessManual;
            set => FoupList[7].IndicatiorAccessManual = value;
        }

        [Subscription(ParamName.IndicatiorAccessManual, DeviceName.LP9)]
        public IndicatorState IndicatiorAccessManual9
        {
            get => FoupList[8].IndicatiorAccessManual;
            set => FoupList[8].IndicatiorAccessManual = value;
        }

        [Subscription(ParamName.IndicatiorAccessManual, DeviceName.LP10)]
        public IndicatorState IndicatiorAccessManual10
        {
            get => FoupList[9].IndicatiorAccessManual;
            set => FoupList[9].IndicatiorAccessManual = value;
        }

        [Subscription(ParamName.LoadportState, DeviceName.LP1)]
        public string Status1
        {
            get => FoupList[0].Status;
            set => FoupList[0].Status = value;
        }

        [Subscription(ParamName.LoadportState, DeviceName.LP2)]
        public string Status2
        {
            get => FoupList[1].Status;
            set => FoupList[1].Status = value;
        }

        [Subscription(ParamName.LoadportState, DeviceName.LP3)]
        public string Status3
        {
            get => FoupList[2].Status;
            set => FoupList[2].Status = value;
        }

        [Subscription(ParamName.LoadportState, DeviceName.LP4)]
        public string Status4
        {
            get => FoupList[3].Status;
            set => FoupList[3].Status = value;
        }

        [Subscription(ParamName.LoadportState, DeviceName.LP5)]
        public string Status5
        {
            get => FoupList[4].Status;
            set => FoupList[4].Status = value;
        }

        [Subscription(ParamName.LoadportState, DeviceName.LP6)]
        public string Status6
        {
            get => FoupList[5].Status;
            set => FoupList[5].Status = value;
        }

        [Subscription(ParamName.LoadportState, DeviceName.LP7)]
        public string Status7
        {
            get => FoupList[6].Status;
            set => FoupList[6].Status = value;
        }

        [Subscription(ParamName.LoadportState, DeviceName.LP8)]
        public string Status8
        {
            get => FoupList[7].Status;
            set => FoupList[7].Status = value;
        }

        [Subscription(ParamName.LoadportState, DeviceName.LP9)]
        public string Status9
        {
            get => FoupList[8].Status;
            set => FoupList[8].Status = value;
        }

        [Subscription(ParamName.LoadportState, DeviceName.LP10)]
        public string Status10
        {
            get => FoupList[9].Status;
            set => FoupList[9].Status = value;
        }

        [Subscription(ParamName.FoupClampState, DeviceName.LP1)]
        public FoupClampState ClampState1
        {
            get => FoupList[0].ClampState;
            set => FoupList[0].ClampState = value;
        }

        [Subscription(ParamName.FoupClampState, DeviceName.LP2)]
        public FoupClampState ClampState2
        {
            get => FoupList[1].ClampState;
            set => FoupList[1].ClampState = value;
        }

        [Subscription(ParamName.FoupClampState, DeviceName.LP3)]
        public FoupClampState ClampState3
        {
            get => FoupList[2].ClampState;
            set => FoupList[2].ClampState = value;
        }

        [Subscription(ParamName.FoupClampState, DeviceName.LP4)]
        public FoupClampState ClampState4
        {
            get => FoupList[3].ClampState;
            set => FoupList[3].ClampState = value;
        }

        [Subscription(ParamName.FoupClampState, DeviceName.LP5)]
        public FoupClampState ClampState5
        {
            get => FoupList[4].ClampState;
            set => FoupList[4].ClampState = value;
        }

        [Subscription(ParamName.FoupClampState, DeviceName.LP6)]
        public FoupClampState ClampState6
        {
            get => FoupList[5].ClampState;
            set => FoupList[5].ClampState = value;
        }

        [Subscription(ParamName.FoupClampState, DeviceName.LP7)]
        public FoupClampState ClampState7
        {
            get => FoupList[6].ClampState;
            set => FoupList[6].ClampState = value;
        }

        [Subscription(ParamName.FoupClampState, DeviceName.LP8)]
        public FoupClampState ClampState8
        {
            get => FoupList[7].ClampState;
            set => FoupList[7].ClampState = value;
        }

        [Subscription(ParamName.FoupClampState, DeviceName.LP9)]
        public FoupClampState ClampState9
        {
            get => FoupList[8].ClampState;
            set => FoupList[8].ClampState = value;
        }

        [Subscription(ParamName.FoupClampState, DeviceName.LP10)]
        public FoupClampState ClampState10
        {
            get => FoupList[9].ClampState;
            set => FoupList[9].ClampState = value;
        }

        [Subscription(ParamName.FoupDoorState, DeviceName.LP1)]
        public FoupDoorState DoorState1
        {
            get => FoupList[0].DoorState;
            set => FoupList[0].DoorState = value;
        }

        [Subscription(ParamName.FoupDoorState, DeviceName.LP2)]
        public FoupDoorState DoorState2
        {
            get => FoupList[1].DoorState;
            set => FoupList[1].DoorState = value;
        }

        [Subscription(ParamName.FoupDoorState, DeviceName.LP3)]
        public FoupDoorState DoorState3
        {
            get => FoupList[2].DoorState;
            set => FoupList[2].DoorState = value;
        }

        [Subscription(ParamName.FoupDoorState, DeviceName.LP4)]
        public FoupDoorState DoorState4
        {
            get => FoupList[3].DoorState;
            set => FoupList[3].DoorState = value;
        }

        [Subscription(ParamName.FoupDoorState, DeviceName.LP5)]
        public FoupDoorState DoorState5
        {
            get => FoupList[4].DoorState;
            set => FoupList[4].DoorState = value;
        }

        [Subscription(ParamName.FoupDoorState, DeviceName.LP6)]
        public FoupDoorState DoorState6
        {
            get => FoupList[5].DoorState;
            set => FoupList[5].DoorState = value;
        }

        [Subscription(ParamName.FoupDoorState, DeviceName.LP7)]
        public FoupDoorState DoorState7
        {
            get => FoupList[6].DoorState;
            set => FoupList[6].DoorState = value;
        }

        [Subscription(ParamName.FoupDoorState, DeviceName.LP8)]
        public FoupDoorState DoorState8
        {
            get => FoupList[7].DoorState;
            set => FoupList[7].DoorState = value;
        }

        [Subscription(ParamName.FoupDoorState, DeviceName.LP9)]
        public FoupDoorState DoorState9
        {
            get => FoupList[8].DoorState;
            set => FoupList[8].DoorState = value;
        }

        [Subscription(ParamName.FoupDoorState, DeviceName.LP10)]
        public FoupDoorState DoorState10
        {
            get => FoupList[9].DoorState;
            set => FoupList[9].DoorState = value;
        }







        [Subscription("ValidSlotsNumber", DeviceName.LP1)]
        public int ValidSlotsNumber1
        {
            get => FoupList[0].SlotCount;
            set => FoupList[0].SlotCount = value;
        }

        [Subscription("ValidSlotsNumber", DeviceName.LP2)]
        public int ValidSlotsNumber2
        {
            get => FoupList[1].SlotCount;
            set => FoupList[1].SlotCount = value;
        }

        [Subscription("ValidSlotsNumber", DeviceName.LP3)]
        public int ValidSlotsNumber3
        {
            get => FoupList[2].SlotCount;
            set => FoupList[2].SlotCount = value;
        }

        [Subscription("ValidSlotsNumber", DeviceName.LP4)]
        public int ValidSlotsNumber4
        {
            get => FoupList[3].SlotCount;
            set => FoupList[3].SlotCount = value;
        }

        [Subscription("ValidSlotsNumber", DeviceName.LP5)]
        public int ValidSlotsNumber5
        {
            get => FoupList[4].SlotCount;
            set => FoupList[4].SlotCount = value;
        }

        [Subscription("ValidSlotsNumber", DeviceName.LP6)]
        public int ValidSlotsNumber6
        {
            get => FoupList[5].SlotCount;
            set => FoupList[5].SlotCount = value;
        }

        [Subscription("ValidSlotsNumber", DeviceName.LP7)]
        public int ValidSlotsNumber7
        {
            get => FoupList[6].SlotCount;
            set => FoupList[6].SlotCount = value;
        }

        [Subscription("ValidSlotsNumber", DeviceName.LP8)]
        public int ValidSlotsNumber8
        {
            get => FoupList[7].SlotCount;
            set => FoupList[7].SlotCount = value;
        }

        [Subscription("ValidSlotsNumber", DeviceName.LP9)]
        public int ValidSlotsNumber9
        {
            get => FoupList[8].SlotCount;
            set => FoupList[8].SlotCount = value;
        }

        [Subscription("ValidSlotsNumber", DeviceName.LP10)]
        public int ValidSlotsNumber10
        {
            get => FoupList[9].SlotCount;
            set => FoupList[9].SlotCount = value;
        }















        public ICommand LoadPortCommand
        {
            get; set;
        }

        private WaferInfo[] bufferWafers;
        [Subscription(ParamName.ModuleWaferList, DeviceName.Buffer)]
        public WaferInfo[] BufferWafers
        {
            get
            {
                return bufferWafers?.Reverse().ToArray();
            }
            set
            {
                bufferWafers = value;
            }
        }

        public WaferInfo[] ll1wafers;
        [Subscription(ParamName.ModuleWaferList, DeviceName.LL1)]
        public WaferInfo[] LL1Wafers
        {
            get
            {
                return ll1wafers;
            }
            set
            {
                ll1wafers = value;
                LL1Wafer = ll1wafers?[0];
            }
        }

        public WaferInfo[] ll2wafers;
        [Subscription(ParamName.ModuleWaferList, DeviceName.LL2)]
        public WaferInfo[] LL2Wafers
        {
            get
            {
                return ll2wafers;
            }
            set
            {
                ll2wafers = value;
                LL2Wafer = ll2wafers?[0];
            }
        }

        public WaferInfo[] ll3wafers;
        [Subscription(ParamName.ModuleWaferList, DeviceName.LL3)]
        public WaferInfo[] LL3Wafers
        {
            get
            {
                return ll3wafers;
            }
            set
            {
                ll3wafers = value;
                LL3Wafer = ll3wafers?[0];
            }
        }

        public WaferInfo[] ll4wafers;
        [Subscription(ParamName.ModuleWaferList, DeviceName.LL4)]
        public WaferInfo[] LL4Wafers
        {
            get
            {
                return ll4wafers;
            }
            set
            {
                ll4wafers = value;
                LL4Wafer = ll4wafers?[0];
            }
        }

        public WaferInfo[] ll5wafers;
        [Subscription(ParamName.ModuleWaferList, DeviceName.LL5)]
        public WaferInfo[] LL5Wafers
        {
            get
            {
                return ll5wafers;
            }
            set
            {
                ll5wafers = value;
                LL5Wafer = ll5wafers?[0];
            }
        }

        public WaferInfo[] ll6wafers;
        [Subscription(ParamName.ModuleWaferList, DeviceName.LL6)]
        public WaferInfo[] LL6Wafers
        {
            get
            {
                return ll6wafers;
            }
            set
            {
                ll6wafers = value;
                LL6Wafer = ll6wafers?[0];
            }
        }

        public WaferInfo[] ll7wafers;
        [Subscription(ParamName.ModuleWaferList, DeviceName.LL7)]
        public WaferInfo[] LL7Wafers
        {
            get
            {
                return ll7wafers;
            }
            set
            {
                ll7wafers = value;
                LL7Wafer = ll7wafers?[0];
            }
        }

        public WaferInfo[] ll8wafers;
        [Subscription(ParamName.ModuleWaferList, DeviceName.LL8)]
        public WaferInfo[] LL8Wafers
        {
            get
            {
                return ll8wafers;
            }
            set
            {
                ll8wafers = value;
                LL8Wafer = ll8wafers?[0];
            }
        }

        [Subscription(ParamName.RIDReaderState, DeviceName.RFIDReaderA)]
        public DeviceState RFIDReader1Status
        {
            get => FoupList[0 % FoupList.Count].RfidReaderStatus;
            set => FoupList[0 % FoupList.Count].RfidReaderStatus = value;
        }

        [Subscription(ParamName.RIDReaderState, DeviceName.RFIDReaderB)]
        public DeviceState RFIDReader2Status
        {
            get => FoupList[1 % FoupList.Count].RfidReaderStatus;
            set => FoupList[1 % FoupList.Count].RfidReaderStatus = value;
        }

        [Subscription(ParamName.RIDReaderState, DeviceName.RFIDReaderC)]
        public DeviceState RFIDReader3Status
        {
            get => FoupList[2 % FoupList.Count].RfidReaderStatus;
            set => FoupList[2 % FoupList.Count].RfidReaderStatus = value;
        }

        [Subscription(ParamName.RIDReaderState, DeviceName.RFIDReaderD)]
        public DeviceState RFIDReader4Status
        {
            get => FoupList[3 % FoupList.Count].RfidReaderStatus;
            set => FoupList[3 % FoupList.Count].RfidReaderStatus = value;
        }

        [Subscription(ParamName.RIDReaderState, DeviceName.RFIDReaderE)]
        public DeviceState RFIDReader5Status
        {
            get => FoupList[4 % FoupList.Count].RfidReaderStatus;
            set => FoupList[4 % FoupList.Count].RfidReaderStatus = value;
        }

        [Subscription(ParamName.RIDReaderState, DeviceName.RFIDReaderF)]
        public DeviceState RFIDReader6Status
        {
            get => FoupList[5 % FoupList.Count].RfidReaderStatus;
            set => FoupList[5 % FoupList.Count].RfidReaderStatus = value;
        }

        [Subscription(ParamName.RIDReaderState, DeviceName.RFIDReaderG)]
        public DeviceState RFIDReader7Status
        {
            get => FoupList[6 % FoupList.Count].RfidReaderStatus;
            set => FoupList[6 % FoupList.Count].RfidReaderStatus = value;
        }

        [Subscription(ParamName.RIDReaderState, DeviceName.RFIDReaderH)]
        public DeviceState RFIDReader8Status
        {
            get => FoupList[7 % FoupList.Count].RfidReaderStatus;
            set => FoupList[7 % FoupList.Count].RfidReaderStatus = value;
        }

        [Subscription(ParamName.RIDReaderState, DeviceName.RFIDReaderI)]
        public DeviceState RFIDReader9Status
        {
            get => FoupList[8 % FoupList.Count].RfidReaderStatus;
            set => FoupList[8 % FoupList.Count].RfidReaderStatus = value;
        }

        [Subscription(ParamName.RIDReaderState, DeviceName.RFIDReaderJ)]
        public DeviceState RFIDReader10Status
        {
            get => FoupList[9 % FoupList.Count].RfidReaderStatus;
            set => FoupList[9 % FoupList.Count].RfidReaderStatus = value;
        }
        public WaferInfo LL1Wafer
        {
            get;
            set;
        }

        public WaferInfo LL2Wafer
        {
            get;
            set;
        }

        public WaferInfo LL3Wafer
        {
            get;
            set;
        }

        public WaferInfo LL4Wafer
        {
            get;
            set;
        }
        public WaferInfo LL5Wafer
        {
            get;
            set;
        }

        public WaferInfo LL6Wafer
        {
            get;
            set;
        }

        public WaferInfo LL7Wafer
        {
            get;
            set;
        }

        public WaferInfo LL8Wafer
        {
            get;
            set;
        }

        protected readonly ModuleName[] loadportSet;
        protected Dictionary<string, object> labelSCs;
        protected Dictionary<string, object> modeSCs;
        protected readonly string[] labelSCIDs;
        protected readonly string[] modeSCIDs;
        protected readonly int foupCount;

        public FoupListViewModelBase(string vmName, int foupCount) : base(vmName)
        {
            this.foupCount = foupCount;

            loadportSet = new ModuleName[] { ModuleName.LP1, ModuleName.LP2, ModuleName.LP3, ModuleName.LP4, ModuleName.LP5, ModuleName.LP6, ModuleName.LP7, ModuleName.LP8, ModuleName.LP9, ModuleName.LP10 };
            //labelSCIDs = new string[] {
            //    SorterCommon.ScPathName.LoadPort_LoadPort1CarrierLabel,
            //    SorterCommon.ScPathName.LoadPort_LoadPort2CarrierLabel,
            //    SorterCommon.ScPathName.LoadPort_LoadPort3CarrierLabel,
            //    SorterCommon.ScPathName.LoadPort_LoadPort4CarrierLabel,
            //    SorterCommon.ScPathName.LoadPort_LoadPort5CarrierLabel,
            //    SorterCommon.ScPathName.LoadPort_LoadPort6CarrierLabel,
            //    SorterCommon.ScPathName.LoadPort_LoadPort7CarrierLabel,
            //    SorterCommon.ScPathName.LoadPort_LoadPort8CarrierLabel,
            //    SorterCommon.ScPathName.LoadPort_LoadPort9CarrierLabel,
            //    SorterCommon.ScPathName.LoadPort_LoadPort10CarrierLabel
            //};
            //labelSCs = QueryDataClient.Instance.Service.PollConfig(labelSCIDs);

            //modeSCIDs = new string[] {
            //    SorterCommon.ScPathName.LoadPort_LoadPort1CarrierMode,
            //    SorterCommon.ScPathName.LoadPort_LoadPort2CarrierMode,
            //    SorterCommon.ScPathName.LoadPort_LoadPort3CarrierMode,
            //    SorterCommon.ScPathName.LoadPort_LoadPort4CarrierMode,
            //    SorterCommon.ScPathName.LoadPort_LoadPort5CarrierMode,
            //    SorterCommon.ScPathName.LoadPort_LoadPort6CarrierMode,
            //    SorterCommon.ScPathName.LoadPort_LoadPort7CarrierMode,
            //    SorterCommon.ScPathName.LoadPort_LoadPort8CarrierMode,
            //    SorterCommon.ScPathName.LoadPort_LoadPort9CarrierMode,
            //    SorterCommon.ScPathName.LoadPort_LoadPort10CarrierMode,
            //};
            //modeSCs = QueryDataClient.Instance.Service.PollConfig(modeSCIDs);

            InitFoupList();

            LoadPortCommand = new DelegateCommand<DependencyObject>(DoLoadPortCmd, x =>
            {

                if (x != null)
                {

                    var target = CommandHelper.GetTarget(x);
                    if (target != null)
                    {
                        var loadport = FoupList.Single(l => l.DeviceName == target.ToString());
                        string cmdname = CommandHelper.GetCommandName(x);
                        //if (cmdname == "Scan")
                        //    return loadport.Present && loadport.Placement;
                        if (x is TextBox)
                        {
                            return loadport.Present && loadport.Placement;
                        }
                        else
                        {
                            return loadport.Present && loadport.Placement && (!IsAutoMode || !IsOnlineRemote) && loadport.IsCarrierEnabled;
                        }
                    }
                }
                return false;
            });

            var timer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(1) };
            timer.Start();
            timer.Tick += TimerOnTick;
        }

        private void TimerOnTick(object sender, EventArgs e)
        {
            try
            {
                //labelSCs = QueryDataClient.Instance.Service.PollConfig(labelSCIDs);
                //modeSCs = QueryDataClient.Instance.Service.PollConfig(modeSCIDs);
                for (int i = 0; i < foupCount; i++)
                {
                    FoupList[i].CarrierName = $"LP{i + 1}";


                    //    string.IsNullOrEmpty((string)labelSCs[labelSCIDs[i]])
                    //    ? "Carrier " + (i + 1)
                    //    : (string)labelSCs[labelSCIDs[i]];
                    //FoupList[i].CarrierMode = (LoadPortCarrierMode)modeSCs[modeSCIDs[i]];
                }
            }
            catch (Exception)
            {
                LOG.Write("Can't connect to RT");
            }
        }

        protected virtual void InitFoupList()
        {
            FoupList = new ObservableCollection<FoupListItem>();
            bool lp1Enable = !(bool)QueryDataClient.Instance.Service.GetConfig("LoadPort.LP1.Disable");
            bool lp2Enable = !(bool)QueryDataClient.Instance.Service.GetConfig("LoadPort.LP2.Disable");
            int foupCount = (lp1Enable ? 1 : 0) + (lp2Enable ? 1 : 0);
            for (int i = 0; i < foupCount; i++)
            {
                var foupListItem = new FoupListItem
                {
                    DeviceName = "LP" + (i + 1),
                    CarrierName = "LP" + (i + 1),  //string.IsNullOrEmpty((string)labelSCs[labelSCIDs[i]]) ? "Carrier " + (i + 1) : (string)labelSCs[labelSCIDs[i]],
                    CarrierMode = LoadPortCarrierMode.Loader,//  (LoadPortCarrierMode)modeSCs[modeSCIDs[i]],
                    Station = loadportSet[i]
                };
                FoupList.Add(foupListItem);
            }
        }

        protected virtual WaferInfo[] UpdateWaferInfo(WaferInfo[] waferInfos)
        {
            return waferInfos;
        }

        protected virtual void DoLoadPortCmd(DependencyObject sender)
        {
            var command = CommandHelper.GetCommandItem(sender);
            var lstParameter = new List<object>
            {
                command.Target
            };
            if (sender is TextBox)
            { ((TextBox)sender).Text = ""; }
            lstParameter.AddRange(command.Parameters);
            InvokeClient.Instance.Service.DoOperation(command.CommandName, lstParameter.ToArray());
        }
    }

}