using Aitex.Core.UI.MVVM;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
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.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using MECF.Framework.Common.Equipment;

namespace Aitex.Sorter.UI.ViewModel.Maintenance
{
	public class LoadPortBaseViewModel : UIViewModelBase
	{
		public ObservableCollection<LoadPortState> LoadPortStates { get; set; }

		public LoadPortBaseViewModel(int loadportCount) : base("LoadPortView")
		{
			OperationCommand = new DelegateCommand<DependencyObject>(Operation, x => !IsMaintenanceMode && !IsAutoMode);
			Command = new DelegateCommand<DependencyObject>(DoCommand, x => !IsMaintenanceMode && !IsAutoMode);

			LoadPortStates = new ObservableCollection<LoadPortState>();
		    var loadportSet = new ModuleName[] { ModuleName.LP1, ModuleName.LP2, ModuleName.LP3, ModuleName.LP4, ModuleName.LP5, ModuleName.LP6, ModuleName.LP7, ModuleName.LP8, ModuleName.LP9, ModuleName.LP10 };
			var rfReader = new string[] { DeviceName.RFIDReaderA, DeviceName.RFIDReaderB, DeviceName.RFIDReaderC, DeviceName.RFIDReaderD, DeviceName.RFIDReaderE, DeviceName.RFIDReaderF, DeviceName.RFIDReaderG, 
				DeviceName.RFIDReaderH, DeviceName.RFIDReaderI, DeviceName.RFIDReaderJ ,DeviceName.RFIDReaderK,DeviceName.RFIDReaderL};
			for (int i = 0; i < loadportCount; i++)
			{
				LoadPortStates.Add(new LoadPortState("LoadPort " + (i + 1).ToString(), loadportSet[i], rfReader[i]));
			}
		}

		[Subscription(ParamName.RTStatus, SystemStateModule)]
		public int RoutManagerState
		{
			get;
			set;
		}

		public bool IsMaintenanceMode
		{
			get => RoutManagerState == (int)RtState.Maintenance;
		}

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

		public ICommand OperationCommand
		{
			get;
			private set;
		}

		public ICommand Command
		{
			get;
			private set;
		}

		void Operation(DependencyObject sender)
		{
			var command = CommandHelper.GetCommandItem(sender);
			InvokeClient.Instance.Service.DoOperation(command.CommandName, command.Parameters);
		}

		private void DoCommand(DependencyObject sender)
		{
			var command = CommandHelper.GetCommandItem(sender);
			var lstParameter = new List<object>(command.Parameters);
			lstParameter.Insert(0, command.Target);
			lstParameter.Insert(1, command.CommandName);
			InvokeClient.Instance.Service.DoOperation(OperationName.DeviceOperation, lstParameter.ToArray());
		}

		[Subscription(ParamName.IndicatiorLoad, DeviceName.LoadportA)]
		public IndicatorState LPAIndicatiorLoad
		{
			get => LoadPortStates[0].IndicatiorLoad;
			set => LoadPortStates[0].IndicatiorLoad = value;
		}

		[Subscription(ParamName.IndicatiorLoad, DeviceName.LoadportB)]
		public IndicatorState LPBIndicatiorLoad
		{
			get => LoadPortStates[1].IndicatiorLoad;
			set => LoadPortStates[1].IndicatiorLoad = value;
		}

		[Subscription(ParamName.IndicatiorLoad, DeviceName.LoadportC)]
		public IndicatorState LPCIndicatiorLoad
		{
			get => LoadPortStates[2].IndicatiorLoad;
			set => LoadPortStates[2].IndicatiorLoad = value;
		}

		[Subscription(ParamName.IndicatiorLoad, DeviceName.LoadportD)]
		public IndicatorState LPDIndicatiorLoad
		{
			get => LoadPortStates[3].IndicatiorLoad;
			set => LoadPortStates[3].IndicatiorLoad = value;
		}

		[Subscription(ParamName.IndicatiorLoad, DeviceName.LoadportE)]
		public IndicatorState LPEIndicatiorLoad
		{
			get => LoadPortStates[4].IndicatiorLoad;
			set => LoadPortStates[4].IndicatiorLoad = value;
		}

		[Subscription(ParamName.IndicatiorLoad, DeviceName.LoadportF)]
		public IndicatorState LPFIndicatiorLoad
		{
			get => LoadPortStates[5].IndicatiorLoad;
			set => LoadPortStates[5].IndicatiorLoad = value;
		}

		[Subscription(ParamName.IndicatiorLoad, DeviceName.LoadportG)]
		public IndicatorState LPGIndicatiorLoad
		{
			get => LoadPortStates[6].IndicatiorLoad;
			set => LoadPortStates[6].IndicatiorLoad = value;
		}

		[Subscription(ParamName.IndicatiorLoad, DeviceName.LoadportH)]
		public IndicatorState LPHIndicatiorLoad
		{
			get => LoadPortStates[7].IndicatiorLoad;
			set => LoadPortStates[7].IndicatiorLoad = value;
		}

		[Subscription(ParamName.IndicatiorLoad, DeviceName.LoadportI)]
		public IndicatorState LPIIndicatiorLoad
		{
			get => LoadPortStates[8].IndicatiorLoad;
			set => LoadPortStates[8].IndicatiorLoad = value;
		}

		[Subscription(ParamName.IndicatiorLoad, DeviceName.LoadportJ)]
		public IndicatorState LPJIndicatiorLoad
		{
			get => LoadPortStates[9].IndicatiorLoad;
			set => LoadPortStates[9].IndicatiorLoad = value;
		}

		[Subscription(ParamName.IndicatiorUnload, DeviceName.LoadportA)]
		public IndicatorState LPAIndicatiorUnload
		{
			get => LoadPortStates[0].IndicatiorUnload;
			set => LoadPortStates[0].IndicatiorUnload = value;
		}

		[Subscription(ParamName.IndicatiorUnload, DeviceName.LoadportB)]
		public IndicatorState LPBIndicatiorUnload
		{
			get => LoadPortStates[1].IndicatiorUnload;
			set => LoadPortStates[1].IndicatiorUnload = value;
		}

		[Subscription(ParamName.IndicatiorUnload, DeviceName.LoadportC)]
		public IndicatorState LPCIndicatiorUnload
		{
			get => LoadPortStates[2].IndicatiorUnload;
			set => LoadPortStates[2].IndicatiorUnload = value;
		}

		[Subscription(ParamName.IndicatiorUnload, DeviceName.LoadportD)]
		public IndicatorState LPDIndicatiorUnload
		{
			get => LoadPortStates[3].IndicatiorUnload;
			set => LoadPortStates[3].IndicatiorUnload = value;
		}

		[Subscription(ParamName.IndicatiorUnload, DeviceName.LoadportE)]
		public IndicatorState LPEIndicatiorUnload
		{
			get => LoadPortStates[4].IndicatiorUnload;
			set => LoadPortStates[4].IndicatiorUnload = value;
		}

		[Subscription(ParamName.IndicatiorUnload, DeviceName.LoadportF)]
		public IndicatorState LPFIndicatiorUnload
		{
			get => LoadPortStates[5].IndicatiorUnload;
			set => LoadPortStates[5].IndicatiorUnload = value;
		}

		[Subscription(ParamName.IndicatiorUnload, DeviceName.LoadportG)]
		public IndicatorState LPGIndicatiorUnload
		{
			get => LoadPortStates[6].IndicatiorUnload;
			set => LoadPortStates[6].IndicatiorUnload = value;
		}

		[Subscription(ParamName.IndicatiorUnload, DeviceName.LoadportH)]
		public IndicatorState LPHIndicatiorUnload
		{
			get => LoadPortStates[7].IndicatiorUnload;
			set => LoadPortStates[7].IndicatiorUnload = value;
		}

		[Subscription(ParamName.IndicatiorUnload, DeviceName.LoadportI)]
		public IndicatorState LPIIndicatiorUnload
		{
			get => LoadPortStates[8].IndicatiorUnload;
			set => LoadPortStates[8].IndicatiorUnload = value;
		}

		[Subscription(ParamName.IndicatiorUnload, DeviceName.LoadportJ)]
		public IndicatorState LPJIndicatiorUnload
		{
			get => LoadPortStates[9].IndicatiorUnload;
			set => LoadPortStates[9].IndicatiorUnload = value;
		}

		[Subscription(ParamName.IndicatiorPresence, DeviceName.LoadportA)]
		public IndicatorState LPAIndicatiorPresence
		{
			get => LoadPortStates[0].IndicatiorPresence;
			set => LoadPortStates[0].IndicatiorPresence = value;
		}

		[Subscription(ParamName.IndicatiorPresence, DeviceName.LoadportB)]
		public IndicatorState LPBIndicatiorPresence
		{
			get => LoadPortStates[1].IndicatiorPresence;
			set => LoadPortStates[1].IndicatiorPresence = value;
		}

		[Subscription(ParamName.IndicatiorPresence, DeviceName.LoadportC)]
		public IndicatorState LPCIndicatiorPresence
		{
			get => LoadPortStates[2].IndicatiorPresence;
			set => LoadPortStates[2].IndicatiorPresence = value;
		}

		[Subscription(ParamName.IndicatiorPresence, DeviceName.LoadportD)]
		public IndicatorState LPDIndicatiorPresence
		{
			get => LoadPortStates[3].IndicatiorPresence;
			set => LoadPortStates[3].IndicatiorPresence = value;
		}

		[Subscription(ParamName.IndicatiorPresence, DeviceName.LoadportE)]
		public IndicatorState LPEIndicatiorPresence
		{
			get => LoadPortStates[4].IndicatiorPresence;
			set => LoadPortStates[4].IndicatiorPresence = value;
		}

		[Subscription(ParamName.IndicatiorPresence, DeviceName.LoadportF)]
		public IndicatorState LPFIndicatiorPresence
		{
			get => LoadPortStates[5].IndicatiorPresence;
			set => LoadPortStates[5].IndicatiorPresence = value;
		}

		[Subscription(ParamName.IndicatiorPresence, DeviceName.LoadportG)]
		public IndicatorState LPGIndicatiorPresence
		{
			get => LoadPortStates[6].IndicatiorPresence;
			set => LoadPortStates[6].IndicatiorPresence = value;
		}

		[Subscription(ParamName.IndicatiorPresence, DeviceName.LoadportH)]
		public IndicatorState LPHIndicatiorPresence
		{
			get => LoadPortStates[7].IndicatiorPresence;
			set => LoadPortStates[7].IndicatiorPresence = value;
		}

		[Subscription(ParamName.IndicatiorPresence, DeviceName.LoadportI)]
		public IndicatorState LPIIndicatiorPresence
		{
			get => LoadPortStates[8].IndicatiorPresence;
			set => LoadPortStates[8].IndicatiorPresence = value;
		}

		[Subscription(ParamName.IndicatiorPresence, DeviceName.LoadportJ)]
		public IndicatorState LPJIndicatiorPresence
		{
			get => LoadPortStates[9].IndicatiorPresence;
			set => LoadPortStates[9].IndicatiorPresence = value;
		}

		[Subscription(ParamName.IndicatiorPlacement, DeviceName.LoadportA)]
		public IndicatorState LPAIndicatiorPlacement
		{
			get => LoadPortStates[0].IndicatiorPlacement;
			set => LoadPortStates[0].IndicatiorPlacement = value;
		}

		[Subscription(ParamName.IndicatiorPlacement, DeviceName.LoadportB)]
		public IndicatorState LPBIndicatiorPlacement
		{
			get => LoadPortStates[1].IndicatiorPlacement;
			set => LoadPortStates[1].IndicatiorPlacement = value;
		}

		[Subscription(ParamName.IndicatiorPlacement, DeviceName.LoadportC)]
		public IndicatorState LPCIndicatiorPlacement
		{
			get => LoadPortStates[2].IndicatiorPlacement;
			set => LoadPortStates[2].IndicatiorPlacement = value;
		}

		[Subscription(ParamName.IndicatiorPlacement, DeviceName.LoadportD)]
		public IndicatorState LPDIndicatiorPlacement
		{
			get => LoadPortStates[3].IndicatiorPlacement;
			set => LoadPortStates[3].IndicatiorPlacement = value;
		}

		[Subscription(ParamName.IndicatiorPlacement, DeviceName.LoadportE)]
		public IndicatorState LPEIndicatiorPlacement
		{
			get => LoadPortStates[4].IndicatiorPlacement;
			set => LoadPortStates[4].IndicatiorPlacement = value;
		}

		[Subscription(ParamName.IndicatiorPlacement, DeviceName.LoadportF)]
		public IndicatorState LPFIndicatiorPlacement
		{
			get => LoadPortStates[5].IndicatiorPlacement;
			set => LoadPortStates[5].IndicatiorPlacement = value;
		}

		[Subscription(ParamName.IndicatiorPlacement, DeviceName.LoadportG)]
		public IndicatorState LPGIndicatiorPlacement
		{
			get => LoadPortStates[6].IndicatiorPlacement;
			set => LoadPortStates[6].IndicatiorPlacement = value;
		}

		[Subscription(ParamName.IndicatiorPlacement, DeviceName.LoadportH)]
		public IndicatorState LPHIndicatiorPlacement
		{
			get => LoadPortStates[7].IndicatiorPlacement;
			set => LoadPortStates[7].IndicatiorPlacement = value;
		}

		[Subscription(ParamName.IndicatiorPlacement, DeviceName.LoadportI)]
		public IndicatorState LPIIndicatiorPlacement
		{
			get => LoadPortStates[8].IndicatiorPlacement;
			set => LoadPortStates[8].IndicatiorPlacement = value;
		}

		[Subscription(ParamName.IndicatiorPlacement, DeviceName.LoadportJ)]
		public IndicatorState LPJIndicatiorPlacement
		{
			get => LoadPortStates[9].IndicatiorPlacement;
			set => LoadPortStates[9].IndicatiorPlacement = value;
		}

		[Subscription(ParamName.IndicatiorOpAccess, DeviceName.LoadportA)]
		public IndicatorState LPAIndicatiorOpAccess
		{
			get => LoadPortStates[0].IndicatiorOpAccess;
			set => LoadPortStates[0].IndicatiorOpAccess = value;
		}

		[Subscription(ParamName.IndicatiorOpAccess, DeviceName.LoadportB)]
		public IndicatorState LPBIndicatiorOpAccess
		{
			get => LoadPortStates[1].IndicatiorOpAccess;
			set => LoadPortStates[1].IndicatiorOpAccess = value;
		}

		[Subscription(ParamName.IndicatiorOpAccess, DeviceName.LoadportC)]
		public IndicatorState LPCIndicatiorOpAccess
		{
			get => LoadPortStates[2].IndicatiorOpAccess;
			set => LoadPortStates[2].IndicatiorOpAccess = value;
		}

		[Subscription(ParamName.IndicatiorOpAccess, DeviceName.LoadportD)]
		public IndicatorState LPDIndicatiorOpAccess
		{
			get => LoadPortStates[3].IndicatiorOpAccess;
			set => LoadPortStates[3].IndicatiorOpAccess = value;
		}

		[Subscription(ParamName.IndicatiorOpAccess, DeviceName.LoadportE)]
		public IndicatorState LPEIndicatiorOpAccess
		{
			get => LoadPortStates[4].IndicatiorOpAccess;
			set => LoadPortStates[4].IndicatiorOpAccess = value;
		}

		[Subscription(ParamName.IndicatiorOpAccess, DeviceName.LoadportF)]
		public IndicatorState LPFIndicatiorOpAccess
		{
			get => LoadPortStates[5].IndicatiorOpAccess;
			set => LoadPortStates[5].IndicatiorOpAccess = value;
		}

		[Subscription(ParamName.IndicatiorOpAccess, DeviceName.LoadportG)]
		public IndicatorState LPGIndicatiorOpAccess
		{
			get => LoadPortStates[6].IndicatiorOpAccess;
			set => LoadPortStates[6].IndicatiorOpAccess = value;
		}

		[Subscription(ParamName.IndicatiorOpAccess, DeviceName.LoadportH)]
		public IndicatorState LPHIndicatiorOpAccess
		{
			get => LoadPortStates[7].IndicatiorOpAccess;
			set => LoadPortStates[7].IndicatiorOpAccess = value;
		}

		[Subscription(ParamName.IndicatiorOpAccess, DeviceName.LoadportI)]
		public IndicatorState LPIIndicatiorOpAccess
		{
			get => LoadPortStates[8].IndicatiorOpAccess;
			set => LoadPortStates[8].IndicatiorOpAccess = value;
		}

		[Subscription(ParamName.IndicatiorOpAccess, DeviceName.LoadportJ)]
		public IndicatorState LPJIndicatiorOpAccess
		{
			get => LoadPortStates[9].IndicatiorOpAccess;
			set => LoadPortStates[9].IndicatiorOpAccess = value;
		}

		[Subscription(ParamName.IndicatiorAlarm, DeviceName.LoadportA)]
		public IndicatorState LPAIndicatiorAlarm
		{
			get => LoadPortStates[0].IndicatiorAlarm;
			set => LoadPortStates[0].IndicatiorAlarm = value;
		}

		[Subscription(ParamName.IndicatiorAlarm, DeviceName.LoadportB)]
		public IndicatorState LPBIndicatiorAlarm
		{
			get => LoadPortStates[1].IndicatiorAlarm;
			set => LoadPortStates[1].IndicatiorAlarm = value;
		}

		[Subscription(ParamName.IndicatiorAlarm, DeviceName.LoadportC)]
		public IndicatorState LPCIndicatiorAlarm
		{
			get => LoadPortStates[2].IndicatiorAlarm;
			set => LoadPortStates[2].IndicatiorAlarm = value;
		}

		[Subscription(ParamName.IndicatiorAlarm, DeviceName.LoadportD)]
		public IndicatorState LPDIndicatiorAlarm
		{
			get => LoadPortStates[3].IndicatiorAlarm;
			set => LoadPortStates[3].IndicatiorAlarm = value;
		}

		[Subscription(ParamName.IndicatiorAlarm, DeviceName.LoadportE)]
		public IndicatorState LPEIndicatiorAlarm
		{
			get => LoadPortStates[4].IndicatiorAlarm;
			set => LoadPortStates[4].IndicatiorAlarm = value;
		}

		[Subscription(ParamName.IndicatiorAlarm, DeviceName.LoadportF)]
		public IndicatorState LPFIndicatiorAlarm
		{
			get => LoadPortStates[5].IndicatiorAlarm;
			set => LoadPortStates[5].IndicatiorAlarm = value;
		}

		[Subscription(ParamName.IndicatiorAlarm, DeviceName.LoadportG)]
		public IndicatorState LPGIndicatiorAlarm
		{
			get => LoadPortStates[6].IndicatiorAlarm;
			set => LoadPortStates[6].IndicatiorAlarm = value;
		}

		[Subscription(ParamName.IndicatiorAlarm, DeviceName.LoadportH)]
		public IndicatorState LPHIndicatiorAlarm
		{
			get => LoadPortStates[7].IndicatiorAlarm;
			set => LoadPortStates[7].IndicatiorAlarm = value;
		}

		[Subscription(ParamName.IndicatiorAlarm, DeviceName.LoadportI)]
		public IndicatorState LPIIndicatiorAlarm
		{
			get => LoadPortStates[8].IndicatiorAlarm;
			set => LoadPortStates[8].IndicatiorAlarm = value;
		}

		[Subscription(ParamName.IndicatiorAlarm, DeviceName.LoadportJ)]
		public IndicatorState LPJIndicatiorAlarm
		{
			get => LoadPortStates[9].IndicatiorAlarm;
			set => LoadPortStates[9].IndicatiorAlarm = value;
		}

		[Subscription(ParamName.FoupID, DeviceName.LoadportA)]
		public string LPAFoupID
		{
			get => LoadPortStates[0].FoupID;
			set => LoadPortStates[0].FoupID = value;
		}

		[Subscription(ParamName.FoupID, DeviceName.LoadportB)]
		public string LPBFoupID
		{
			get => LoadPortStates[1].FoupID;
			set => LoadPortStates[1].FoupID = value;
		}

		[Subscription(ParamName.FoupID, DeviceName.LoadportC)]
		public string LPCFoupID
		{
			get => LoadPortStates[2].FoupID;
			set => LoadPortStates[2].FoupID = value;
		}

		[Subscription(ParamName.FoupID, DeviceName.LoadportD)]
		public string LPDFoupID
		{
			get => LoadPortStates[3].FoupID;
			set => LoadPortStates[3].FoupID = value;
		}

		[Subscription(ParamName.FoupID, DeviceName.LoadportE)]
		public string LPEFoupID
		{
			get => LoadPortStates[4].FoupID;
			set => LoadPortStates[4].FoupID = value;
		}

		[Subscription(ParamName.FoupID, DeviceName.LoadportF)]
		public string LPFFoupID
		{
			get => LoadPortStates[5].FoupID;
			set => LoadPortStates[5].FoupID = value;
		}

		[Subscription(ParamName.FoupID, DeviceName.LoadportG)]
		public string LPGFoupID
		{
			get => LoadPortStates[6].FoupID;
			set => LoadPortStates[6].FoupID = value;
		}

		[Subscription(ParamName.FoupID, DeviceName.LoadportH)]
		public string LPHFoupID
		{
			get => LoadPortStates[7].FoupID;
			set => LoadPortStates[7].FoupID = value;
		}

		[Subscription(ParamName.FoupID, DeviceName.LoadportI)]
		public string LPIFoupID
		{
			get => LoadPortStates[8].FoupID;
			set => LoadPortStates[8].FoupID = value;
		}

		[Subscription(ParamName.FoupID, DeviceName.LoadportJ)]
		public string LPJFoupID
		{
			get => LoadPortStates[9].FoupID;
			set => LoadPortStates[9].FoupID = value;
		}

		[Subscription(ParamName.CassetteState, DeviceName.LoadportA)]
		public LoadportCassetteState LPACassetteState
		{
			get => LoadPortStates[0].CassetteState;
			set => LoadPortStates[0].CassetteState = value;
		}

		[Subscription(ParamName.CassetteState, DeviceName.LoadportB)]
		public LoadportCassetteState LPBCassetteState
		{
			get => LoadPortStates[1].CassetteState;
			set => LoadPortStates[1].CassetteState = value;
		}

		[Subscription(ParamName.CassetteState, DeviceName.LoadportC)]
		public LoadportCassetteState LPCCassetteState
		{
			get => LoadPortStates[2].CassetteState;
			set => LoadPortStates[2].CassetteState = value;
		}

		[Subscription(ParamName.CassetteState, DeviceName.LoadportD)]
		public LoadportCassetteState LPDCassetteState
		{
			get => LoadPortStates[3].CassetteState;
			set => LoadPortStates[3].CassetteState = value;
		}

		[Subscription(ParamName.CassetteState, DeviceName.LoadportE)]
		public LoadportCassetteState LPECassetteState
		{
			get => LoadPortStates[4].CassetteState;
			set => LoadPortStates[4].CassetteState = value;
		}

		[Subscription(ParamName.CassetteState, DeviceName.LoadportF)]
		public LoadportCassetteState LPFCassetteState
		{
			get => LoadPortStates[5].CassetteState;
			set => LoadPortStates[5].CassetteState = value;
		}

		[Subscription(ParamName.CassetteState, DeviceName.LoadportG)]
		public LoadportCassetteState LPGCassetteState
		{
			get => LoadPortStates[6].CassetteState;
			set => LoadPortStates[6].CassetteState = value;
		}

		[Subscription(ParamName.CassetteState, DeviceName.LoadportH)]
		public LoadportCassetteState LPHCassetteState
		{
			get => LoadPortStates[7].CassetteState;
			set => LoadPortStates[7].CassetteState = value;
		}

		[Subscription(ParamName.CassetteState, DeviceName.LoadportI)]
		public LoadportCassetteState LPICassetteState
		{
			get => LoadPortStates[8].CassetteState;
			set => LoadPortStates[8].CassetteState = value;
		}

		[Subscription(ParamName.CassetteState, DeviceName.LoadportJ)]
		public LoadportCassetteState LPJCassetteState
		{
			get => LoadPortStates[9].CassetteState;
			set => LoadPortStates[9].CassetteState = value;
		}

		[Subscription(ParamName.FoupClampState, DeviceName.LoadportA)]
		public FoupClampState LPAFoupClampState
		{
			get => LoadPortStates[0].FoupClampState;
			set => LoadPortStates[0].FoupClampState = value;
		}

		[Subscription(ParamName.FoupClampState, DeviceName.LoadportB)]
		public FoupClampState LPBFoupClampState
		{
			get => LoadPortStates[1].FoupClampState;
			set => LoadPortStates[1].FoupClampState = value;
		}

		[Subscription(ParamName.FoupClampState, DeviceName.LoadportC)]
		public FoupClampState LPCFoupClampState
		{
			get => LoadPortStates[2].FoupClampState;
			set => LoadPortStates[2].FoupClampState = value;
		}

		[Subscription(ParamName.FoupClampState, DeviceName.LoadportD)]
		public FoupClampState LPDFoupClampState
		{
			get => LoadPortStates[3].FoupClampState;
			set => LoadPortStates[3].FoupClampState = value;
		}

		[Subscription(ParamName.FoupClampState, DeviceName.LoadportE)]
		public FoupClampState LPEFoupClampState
		{
			get => LoadPortStates[4].FoupClampState;
			set => LoadPortStates[4].FoupClampState = value;
		}

		[Subscription(ParamName.FoupClampState, DeviceName.LoadportF)]
		public FoupClampState LPFFoupClampState
		{
			get => LoadPortStates[5].FoupClampState;
			set => LoadPortStates[5].FoupClampState = value;
		}

		[Subscription(ParamName.FoupClampState, DeviceName.LoadportG)]
		public FoupClampState LPGFoupClampState
		{
			get => LoadPortStates[6].FoupClampState;
			set => LoadPortStates[6].FoupClampState = value;
		}

		[Subscription(ParamName.FoupClampState, DeviceName.LoadportH)]
		public FoupClampState LPHFoupClampState
		{
			get => LoadPortStates[7].FoupClampState;
			set => LoadPortStates[7].FoupClampState = value;
		}

		[Subscription(ParamName.FoupClampState, DeviceName.LoadportI)]
		public FoupClampState LPIFoupClampState
		{
			get => LoadPortStates[8].FoupClampState;
			set => LoadPortStates[8].FoupClampState = value;
		}

		[Subscription(ParamName.FoupClampState, DeviceName.LoadportJ)]
		public FoupClampState LPJFoupClampState
		{
			get => LoadPortStates[9].FoupClampState;
			set => LoadPortStates[9].FoupClampState = value;
		}

		[Subscription(ParamName.FoupDoorState, DeviceName.LoadportA)]
		public FoupDoorState LPAFoupDoorState
		{
			get => LoadPortStates[0].FoupDoorState;
			set => LoadPortStates[0].FoupDoorState = value;
		}

		[Subscription(ParamName.FoupDoorState, DeviceName.LoadportB)]
		public FoupDoorState LPBFoupDoorState
		{
			get => LoadPortStates[1].FoupDoorState;
			set => LoadPortStates[1].FoupDoorState = value;
		}

		[Subscription(ParamName.FoupDoorState, DeviceName.LoadportC)]
		public FoupDoorState LPCFoupDoorState
		{
			get => LoadPortStates[2].FoupDoorState;
			set => LoadPortStates[2].FoupDoorState = value;
		}

		[Subscription(ParamName.FoupDoorState, DeviceName.LoadportD)]
		public FoupDoorState LPDFoupDoorState
		{
			get => LoadPortStates[3].FoupDoorState;
			set => LoadPortStates[3].FoupDoorState = value;
		}

		[Subscription(ParamName.FoupDoorState, DeviceName.LoadportE)]
		public FoupDoorState LPEFoupDoorState
		{
			get => LoadPortStates[4].FoupDoorState;
			set => LoadPortStates[4].FoupDoorState = value;
		}

		[Subscription(ParamName.FoupDoorState, DeviceName.LoadportF)]
		public FoupDoorState LPFFoupDoorState
		{
			get => LoadPortStates[5].FoupDoorState;
			set => LoadPortStates[5].FoupDoorState = value;
		}

		[Subscription(ParamName.FoupDoorState, DeviceName.LoadportG)]
		public FoupDoorState LPGFoupDoorState
		{
			get => LoadPortStates[6].FoupDoorState;
			set => LoadPortStates[6].FoupDoorState = value;
		}

		[Subscription(ParamName.FoupDoorState, DeviceName.LoadportH)]
		public FoupDoorState LPHFoupDoorState
		{
			get => LoadPortStates[7].FoupDoorState;
			set => LoadPortStates[7].FoupDoorState = value;
		}

		[Subscription(ParamName.FoupDoorState, DeviceName.LoadportI)]
		public FoupDoorState LPIFoupDoorState
		{
			get => LoadPortStates[8].FoupDoorState;
			set => LoadPortStates[8].FoupDoorState = value;
		}

		[Subscription(ParamName.FoupDoorState, DeviceName.LoadportJ)]
		public FoupDoorState LPJFoupDoorState
		{
			get => LoadPortStates[9].FoupDoorState;
			set => LoadPortStates[9].FoupDoorState = value;
		}

		[Subscription(ParamName.LoadportState, DeviceName.LoadportA)]
		public DeviceState LPALoadportState
		{
			get => LoadPortStates[0].LoadportState;
			set => LoadPortStates[0].LoadportState = value;
		}

		[Subscription(ParamName.LoadportState, DeviceName.LoadportB)]
		public DeviceState LPBLoadportState
		{
			get => LoadPortStates[1].LoadportState;
			set => LoadPortStates[1].LoadportState = value;
		}

		[Subscription(ParamName.LoadportState, DeviceName.LoadportC)]
		public DeviceState LPCLoadportState
		{
			get => LoadPortStates[2].LoadportState;
			set => LoadPortStates[2].LoadportState = value;
		}

		[Subscription(ParamName.LoadportState, DeviceName.LoadportD)]
		public DeviceState LPDLoadportState
		{
			get => LoadPortStates[3].LoadportState;
			set => LoadPortStates[3].LoadportState = value;
		}

		[Subscription(ParamName.LoadportState, DeviceName.LoadportE)]
		public DeviceState LPELoadportState
		{
			get => LoadPortStates[4].LoadportState;
			set => LoadPortStates[4].LoadportState = value;
		}

		[Subscription(ParamName.LoadportState, DeviceName.LoadportF)]
		public DeviceState LPFLoadportState
		{
			get => LoadPortStates[5].LoadportState;
			set => LoadPortStates[5].LoadportState = value;
		}

		[Subscription(ParamName.LoadportState, DeviceName.LoadportG)]
		public DeviceState LPGLoadportState
		{
			get => LoadPortStates[6].LoadportState;
			set => LoadPortStates[6].LoadportState = value;
		}

		[Subscription(ParamName.LoadportState, DeviceName.LoadportH)]
		public DeviceState LPHLoadportState
		{
			get => LoadPortStates[7].LoadportState;
			set => LoadPortStates[7].LoadportState = value;
		}

		[Subscription(ParamName.LoadportState, DeviceName.LoadportI)]
		public DeviceState LPILoadportState
		{
			get => LoadPortStates[8].LoadportState;
			set => LoadPortStates[8].LoadportState = value;
		}

		[Subscription(ParamName.LoadportState, DeviceName.LoadportJ)]
		public DeviceState LPJLoadportState
		{
			get => LoadPortStates[9].LoadportState;
			set => LoadPortStates[9].LoadportState = value;
		}

		[Subscription(ParamName.RIDReaderState, DeviceName.LoadportA)]
		public string LPARIDReaderState
		{
			get => LoadPortStates[0].RIDReaderState;
			set => LoadPortStates[0].RIDReaderState = value;
		}

		[Subscription(ParamName.RIDReaderState, DeviceName.LoadportB)]
		public string LPBRIDReaderState
		{
			get => LoadPortStates[1].RIDReaderState;
			set => LoadPortStates[1].RIDReaderState = value;
		}

		[Subscription(ParamName.RIDReaderState, DeviceName.LoadportC)]
		public string LPCRIDReaderState
		{
			get => LoadPortStates[2].RIDReaderState;
			set => LoadPortStates[2].RIDReaderState = value;
		}

		[Subscription(ParamName.RIDReaderState, DeviceName.LoadportD)]
		public string LPDRIDReaderState
		{
			get => LoadPortStates[3].RIDReaderState;
			set => LoadPortStates[3].RIDReaderState = value;
		}

		[Subscription(ParamName.RIDReaderState, DeviceName.LoadportE)]
		public string LPERIDReaderState
		{
			get => LoadPortStates[4].RIDReaderState;
			set => LoadPortStates[4].RIDReaderState = value;
		}

		[Subscription(ParamName.RIDReaderState, DeviceName.LoadportF)]
		public string LPFRIDReaderState
		{
			get => LoadPortStates[5].RIDReaderState;
			set => LoadPortStates[5].RIDReaderState = value;
		}

		[Subscription(ParamName.RIDReaderState, DeviceName.LoadportG)]
		public string LPGRIDReaderState
		{
			get => LoadPortStates[6].RIDReaderState;
			set => LoadPortStates[6].RIDReaderState = value;
		}

		[Subscription(ParamName.RIDReaderState, DeviceName.LoadportH)]
		public string LPHRIDReaderState
		{
			get => LoadPortStates[7].RIDReaderState;
			set => LoadPortStates[7].RIDReaderState = value;
		}

		[Subscription(ParamName.RIDReaderState, DeviceName.LoadportI)]
		public string LPIRIDReaderState
		{
			get => LoadPortStates[8].RIDReaderState;
			set => LoadPortStates[8].RIDReaderState = value;
		}

		[Subscription(ParamName.RIDReaderState, DeviceName.LoadportJ)]
		public string LPJRIDReaderState
		{
			get => LoadPortStates[9].RIDReaderState;
			set => LoadPortStates[9].RIDReaderState = value;
		}
	}

	public class LoadPortState : NotifyPropertyChangedBase
	{
		public LoadPortState(string name, ModuleName loadPortName, string rfReaderName)
		{
			Name = name;
			LoadPortName = loadPortName;
			RFReaderName = rfReaderName;
		}

		public ModuleName LoadPortName { get; private set; }

		public string RFReaderName { get; private set; }

		public string Name { get; private set; }

		private IndicatorState indicatiorLoad;
		public IndicatorState IndicatiorLoad
		{
			get => indicatiorLoad;
			set
			{
				indicatiorLoad = value;
				OnPropertyChanged("IndicatiorLoad");
			}
		}

		private IndicatorState indicatiorUnload;
		public IndicatorState IndicatiorUnload
		{
			get => indicatiorUnload;
			set
			{
				indicatiorUnload = value;
				OnPropertyChanged("IndicatiorUnload");
			}
		}

		private IndicatorState indicatiorPresence;
		public IndicatorState IndicatiorPresence
		{
			get => indicatiorPresence;
			set
			{
				indicatiorPresence = value;
				OnPropertyChanged("IndicatiorPresence");
			}
		}

		private IndicatorState indicatiorPlacement;
		public IndicatorState IndicatiorPlacement
		{
			get => indicatiorPlacement;
			set
			{
				indicatiorPlacement = value;
				OnPropertyChanged("IndicatiorPlacement");
			}
		}

		private IndicatorState indicatiorOpAccess;
		public IndicatorState IndicatiorOpAccess
		{
			get => indicatiorOpAccess;
			set
			{
				indicatiorOpAccess = value;
				OnPropertyChanged("IndicatiorOpAccess");
			}
		}

		private IndicatorState indicatiorAlarm;
		public IndicatorState IndicatiorAlarm
		{
			get => indicatiorAlarm;
			set
			{
				indicatiorAlarm = value;
				OnPropertyChanged("IndicatiorAlarm");
			}
		}

		private IndicatorState indicatiorAccessAuto;
		public IndicatorState IndicatiorAccessAuto
		{
			get => indicatiorAccessAuto;
			set
			{
				indicatiorAccessAuto = value;
				OnPropertyChanged("IndicatiorAccessAuto");
			}
		}

		private IndicatorState indicatiorAccessManual;
		public IndicatorState IndicatiorAccessManual
		{
			get => indicatiorAccessManual;
			set
			{
				indicatiorAccessManual = value;
				OnPropertyChanged("IndicatiorAccessManual");
			}
		}


		private string foupID;
		public string FoupID
		{
			get => foupID;
			set
			{
				foupID = value;
				OnPropertyChanged("FoupID");
			}
		}

		private LoadportCassetteState cassetteState;
		public LoadportCassetteState CassetteState
		{
			get => cassetteState;
			set
			{
				cassetteState = value;
				OnPropertyChanged("CassetteState");
			}
		}

		private FoupClampState clampState;
		public FoupClampState FoupClampState
		{
			get => clampState;
			set
			{
				clampState = value;
				OnPropertyChanged("FoupClampState");
			}
		}

		private FoupDoorState doorState;
		public FoupDoorState FoupDoorState
		{
			get => doorState;
			set
			{
				doorState = value;
				OnPropertyChanged("FoupDoorState");
			}
		}

		private DeviceState status;
		public DeviceState LoadportState
		{
			get => status;
			set
			{
				status = value;
				OnPropertyChanged("LoadportState");
			}
		}

		private string rfIDReaderStatus;
		public string RIDReaderState
		{
			get => rfIDReaderStatus;
			set
			{
				rfIDReaderStatus = value;
				OnPropertyChanged("RIDReaderState");
			}
		}
	}
}