#define TRACE
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Reflection;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Discovery;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using ArchestrAServices.ASBContract;
using ArchestrAServices.ASBIDataContract;
using ArchestrAServices.ASBIDataV2Adapter;
using ArchestrAServices.ASBIDataV2Contract;
using ArchestrAServices.Common;
using ArchestrAServices.Contract;

namespace ArchestrAServices.Proxy;

public class ASBDataV1Proxy : IDataV2toV1, IDisposable
{
	public class ConnectionDelegate
	{
		private IASBIDataV2 dataClientField;

		private ConnectionDelegate()
		{
			dataClientField = null;
		}

		public ConnectionDelegate(IASBIDataV2 browseClient)
		{
			dataClientField = browseClient;
		}

		public ConnectResponse CallConnect(ConnectRequest request)
		{
			if (dataClientField != null)
			{
				return dataClientField.Connect(request);
			}
			return new ConnectResponse
			{
				Result = ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0)
			};
		}

		public void CallAuthenticateMe(AuthenticateMe request)
		{
			if (dataClientField != null)
			{
				dataClientField.AuthenticateMe(request);
			}
		}

		public void CallDisconnect(Disconnect request)
		{
			if (dataClientField != null)
			{
				dataClientField.Disconnect(request);
			}
		}
	}

	private string accessName;

	private ChannelFactory<IASBIDataV2> dataProviderFactory;

	private IASBIDataV2 dataClient;

	public Guid connectionId = Guid.Empty;

	private object connectionLock;

	private ManualResetEvent connectionEstablishedEvent;

	private List<string> accumulatedErrorMsg;

	private object errorMsgLock;

	private string customSerializerSearchString = "/binding/customserializer/version2";

	private ConfiguredLogger aaLoggerConfig;

	public static TraceSource ASBDataProxyCustom = new TraceSource("ASBDataProxyLogs");

	public IASBIDataV2 DataClient => dataClient;

	public bool Connected
	{
		get
		{
			if (dataClient != null)
			{
				return ((IClientChannel)dataClient).State != CommunicationState.Faulted;
			}
			return false;
		}
	}

	public CommunicationState ChannelState
	{
		get
		{
			if (dataClient == null)
			{
				return CommunicationState.Faulted;
			}
			return ((IClientChannel)dataClient).State;
		}
	}

	public IAsbInterfaceSettings Settings { get; private set; }

	public ASBDataV1Proxy(string access, IAsbInterfaceSettings settings)
	{
		accessName = access;
		Settings = settings;
		Process currentProcess = Process.GetCurrentProcess();
		if (currentProcess != null)
		{
			aaLoggerConfig = new ConfiguredLogger(currentProcess.ProcessName);
			aaLoggerConfig.ChangeSourceLevel("DataFlowLogs", SourceLevels.All);
			aaLoggerConfig.ChangeSourceLevel("ControlFlowLogs", SourceLevels.All);
			aaLoggerConfig.ChangeSourceLevel("CommandLogs", SourceLevels.All);
			aaLoggerConfig.ChangeSourceLevel("ExceptionLogs", SourceLevels.All);
			aaLoggerConfig.ChangeSourceLevel("DiagnosticsLogs", SourceLevels.All);
			aaLoggerConfig.AddCustomTraceSource("ASBDataProxyLogs", ASBDataV2Proxy.ASBDataProxyCustom, "ASBDataV1Proxy");
			aaLoggerConfig.ChangeSourceLevel("ASBDataProxyLogs", SourceLevels.All);
		}
		Reset();
	}

	private void Reset()
	{
		if (dataClient != null)
		{
			((IClientChannel)dataClient).Abort();
		}
		dataProviderFactory = null;
		dataClient = null;
		connectionId = Guid.Empty;
		connectionLock = new object();
	}

	public bool Connect(out string errorMessage)
	{
		try
		{
			Reset();
		}
		catch (Exception ex)
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Warning, 0, "Connection reset failed : {0} \n Stack: {1}", ex.Message, ex.StackTrace);
		}
		errorMessage = string.Empty;
		bool result = false;
		bool useCustomSerializer = false;
		string SolutionName = string.Empty;
		EndpointDiscoveryMetadata endpointDiscoveryMetadata = null;
		FindResponse findResponse = FindIDataEndpoint(accessName);
		if (findResponse != null && findResponse.Endpoints != null && findResponse.Endpoints.Count != 0)
		{
			endpointDiscoveryMetadata = SelectEndpointToConnectTo(findResponse, ref useCustomSerializer);
			if (endpointDiscoveryMetadata != null)
			{
				ASBSolutionManager aSBSolutionManager = new ASBSolutionManager();
				SolutionName = aSBSolutionManager.GetASBSolutionName(endpointDiscoveryMetadata, out errorMessage);
				if (string.IsNullOrEmpty(errorMessage))
				{
					aSBSolutionManager.GetASBSolutionPassphrase(SolutionName, out errorMessage);
				}
			}
			else
			{
				SvcTrace.DiagException.TraceEvent(TraceEventType.Warning, 0, "Connect found no endpoints for access name {0} that were configured correctly", accessName);
			}
		}
		else if (findResponse != null)
		{
			if (findResponse.Endpoints != null)
			{
				if (findResponse.Endpoints.Count == 0)
				{
					SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "Connect found no endpoints for IDataV2 with access name {0}", accessName);
				}
			}
			else
			{
				SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "Connect FindResponse has a null Endpoints member finding IDataV2 with access name {0}", accessName);
			}
		}
		else
		{
			SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "Connect null FindResponse finding IDataV2 with access name {0}", accessName);
		}
		if (string.IsNullOrEmpty(errorMessage))
		{
			if (endpointDiscoveryMetadata != null)
			{
				lock (connectionLock)
				{
					dataProviderFactory = null;
					dataClient = null;
					connectionId = Guid.Empty;
				}
				connectionEstablishedEvent = new ManualResetEvent(initialState: false);
				accumulatedErrorMsg = new List<string>();
				errorMsgLock = new object();
				foreach (Uri listenUri in endpointDiscoveryMetadata.ListenUris)
				{
					string SelectedEndpointUri = listenUri.ToString();
					Task.Factory.StartNew(delegate
					{
						EndpointAddress dataProviderEndpoint = new EndpointAddress(SelectedEndpointUri);
						Binding binding = SvcUtilities.GetBinding(SelectedEndpointUri);
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Information, 0, "Try connecting with IDataV2 endpoint {0}", SelectedEndpointUri);
						if (InternalConnect(dataProviderEndpoint, binding, SolutionName, out var errorMessage2, useCustomSerializer))
						{
							SvcTrace.DiagControl.TraceEvent(TraceEventType.Information, 0, "Connected to IDataV2 endpoint {0}", SelectedEndpointUri);
						}
						else if (errorMessage2 != null)
						{
							lock (errorMsgLock)
							{
								accumulatedErrorMsg.Add(errorMessage2);
							}
						}
					});
				}
				connectionEstablishedEvent.WaitOne(20000);
				connectionEstablishedEvent.Close();
				connectionEstablishedEvent = null;
				lock (connectionLock)
				{
					result = true;
					if (dataProviderFactory == null)
					{
						foreach (string item in accumulatedErrorMsg)
						{
							SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, item);
						}
						result = false;
					}
				}
			}
			else
			{
				string text = $"There are no endpoints selected for the namespace: '{accessName}'. Confirm that \r";
				string text2 = $"a) local galaxy and remote galaxy {accessName} specify the same UDS \r";
				string text3 = $"b) local galaxy has been paired with remote galaxy {accessName} \r";
				string text4 = $"c) MxDataProvider service has been deployed on galaxy {accessName}.";
				errorMessage = $"{text}{text2}{text3}{text4}";
			}
		}
		return result;
	}

	public EndpointDiscoveryMetadata SelectEndpointToConnectTo(FindResponse findResponse, ref bool useCustomSerializer)
	{
		EndpointDiscoveryMetadata result = null;
		List<EndpointDiscoveryMetadata> list = new List<EndpointDiscoveryMetadata>();
		List<EndpointDiscoveryMetadata> list2 = new List<EndpointDiscoveryMetadata>();
		bool flag = true;
		foreach (EndpointDiscoveryMetadata endpoint in findResponse.Endpoints)
		{
			if (flag)
			{
				list2.Add(endpoint);
			}
			else
			{
				list.Add(endpoint);
			}
			flag = false;
		}
		Random random = new Random(DateTime.Now.Millisecond);
		if (list2.Count != 0)
		{
			useCustomSerializer = true;
			result = list2[random.Next(list2.Count)];
		}
		else if (list.Count != 0)
		{
			useCustomSerializer = false;
			result = list[random.Next(list.Count)];
		}
		return result;
	}

	public bool Connect(EndpointDiscoveryMetadata SelectedMetadata, out string errorMessage)
	{
		errorMessage = string.Empty;
		bool useCustomSerializer = false;
		foreach (Uri scope in SelectedMetadata.Scopes)
		{
			if (scope.AbsolutePath.Contains(customSerializerSearchString))
			{
				useCustomSerializer = true;
				break;
			}
		}
		string text = SelectedMetadata.Address.Uri.ToString();
		EndpointAddress dataProviderEndpoint = new EndpointAddress(text);
		Binding binding = SvcUtilities.GetBinding(text);
		ASBSolutionManager aSBSolutionManager = new ASBSolutionManager();
		string aSBSolutionName = aSBSolutionManager.GetASBSolutionName(SelectedMetadata, out errorMessage);
		if (string.IsNullOrEmpty(errorMessage))
		{
			aSBSolutionManager.GetASBSolutionPassphrase(aSBSolutionName, out errorMessage);
		}
		if (string.IsNullOrEmpty(errorMessage))
		{
			bool num = InternalConnect(dataProviderEndpoint, binding, aSBSolutionName, out errorMessage, useCustomSerializer);
			if (!num && errorMessage != null)
			{
				SvcTrace.DiagControl.TraceEvent(TraceEventType.Error, 0, errorMessage);
			}
			return num;
		}
		return false;
	}

	private bool InternalConnect(EndpointAddress dataProviderEndpoint, Binding binding, string SolutionName, out string errorMessage, bool useCustomSerializer)
	{
		bool flag = false;
		errorMessage = string.Empty;
		if (dataProviderEndpoint != null && binding != null)
		{
			try
			{
				ChannelFactory<IASBIDataV2> channelFactory = new ChannelFactory<IASBIDataV2>(binding, dataProviderEndpoint);
				channelFactory.Open();
				IASBIDataV2 iASBIDataV = channelFactory.CreateChannel();
				Guid empty = Guid.Empty;
				if (iASBIDataV != null)
				{
					((IClientChannel)iASBIDataV).Open();
					if (iASBIDataV != null && ((IClientChannel)iASBIDataV).State != CommunicationState.Faulted)
					{
						ConnectionDelegate connectionDelegate = new ConnectionDelegate(iASBIDataV);
						flag = SysAuthClientAuthentication.EstablishSecureSession(Process.GetCurrentProcess().ProcessName, "localdomain", Environment.MachineName, SolutionName, new WeakReference(this), connectionDelegate.CallConnect, connectionDelegate.CallAuthenticateMe, out empty, out errorMessage);
						Thread.Sleep(250);
						if (flag)
						{
							Stopwatch stopwatch = new Stopwatch();
							stopwatch.Start();
							bool flag2;
							do
							{
								flag2 = PublishWriteComplete(out var _).ErrorCode != ArchestrAServices.ASBContract.EnumASBFactory.ArchestrAErrorToInt(ArchestrAServices.ASBContract.ArchestrAError.InvalidConnectionId);
								if (flag2)
								{
									SvcTrace.DiagControl.TraceEvent(TraceEventType.Information, 0, "Ping PublishWriteComplete() successful with service using ConnectionId {0}", empty);
								}
								if (!flag2)
								{
									Thread.Sleep(250);
								}
							}
							while (!flag2 && stopwatch.ElapsedMilliseconds < 2500);
							flag = flag2;
						}
						if (flag)
						{
							bool flag3 = false;
							lock (connectionLock)
							{
								if (dataProviderFactory == null)
								{
									flag3 = true;
									dataProviderFactory = channelFactory;
									dataClient = iASBIDataV;
									connectionId = empty;
									if (connectionEstablishedEvent != null)
									{
										connectionEstablishedEvent.Set();
									}
								}
							}
							if (!flag3)
							{
								SysAuthClientAuthentication.DisconnectSecureSession(empty, connectionDelegate.CallDisconnect);
								if (iASBIDataV != null)
								{
									((IClientChannel)iASBIDataV).Close();
									((IClientChannel)iASBIDataV).Dispose();
								}
							}
						}
						else
						{
							if (iASBIDataV != null)
							{
								((IClientChannel)iASBIDataV).Abort();
								((IClientChannel)iASBIDataV).Dispose();
							}
							if (string.IsNullOrEmpty(errorMessage))
							{
								errorMessage = "ASBDataV1Proxy could not connect with service: EstablishSecureSession failed";
							}
						}
					}
					else
					{
						errorMessage = "ASBDataV1Proxy could not connect with service: communicaton channel in faulted state";
						flag = false;
					}
				}
				else
				{
					errorMessage = $"ASBDataV1Proxy not able to create a channel for the endpoint {dataProviderEndpoint.Uri.ToString()}";
				}
			}
			catch (CommunicationException ex)
			{
				errorMessage = "ASBDataV1Proxy caught CommunicationException opening channel: " + ex.Message;
				if (ex.InnerException != null)
				{
					errorMessage += ex.InnerException.Message;
				}
			}
			catch (TimeoutException ex2)
			{
				errorMessage = "ASBDataV1Proxy caught TimeoutException opening channel: " + ex2.Message;
				if (ex2.InnerException != null)
				{
					errorMessage += ex2.InnerException.Message;
				}
			}
			catch (Exception ex3)
			{
				errorMessage = "ASBDataV1Proxy caught exception opening channel: " + ex3.Message;
				flag = false;
			}
		}
		else
		{
			if (dataProviderEndpoint == null)
			{
				errorMessage += "ASBDataV1Proxy cannot proceed to connect: No provider endpoint provided by caller";
				flag = false;
			}
			if (binding == null)
			{
				errorMessage += "ASBDataV1Proxy cannot proceed to connect: No binding provided by caller";
				flag = false;
			}
		}
		return flag;
	}

	public void Disconnect()
	{
		SysAuthClientAuthentication.DisconnectSecureSession(connectionId, CallDisconnect);
	}

	public void Abort()
	{
		Reset();
	}

	private void CallDisconnect(Disconnect request)
	{
		if (dataClient != null && ((IClientChannel)dataClient).State != CommunicationState.Faulted)
		{
			dataClient.Disconnect(request);
		}
	}

	public ArchestrAServices.ASBContract.ArchestrAResult KeepAlive(ArchestrAServices.ASBContract.ConnectionId Id)
	{
		return KeepAlive();
	}

	public ArchestrAServices.ASBContract.ArchestrAResult KeepAlive()
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				KeepAlive keepAlive = new KeepAlive();
				keepAlive.ConnectionValidator.ConnectionId = connectionId;
				clientAuthenticator.Sign(keepAlive);
				dataClient.KeepAlive(keepAlive);
				return ArchestrAServices.ASBContract.ResultFactory.MakeGoodResult();
			}
		}
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult ActivateUser(ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.UserToken UserToken)
	{
		return ActivateUser(UserToken);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult ActivateUser(ArchestrAServices.ASBContract.UserToken UserToken)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ActivateUserRequest activateUserRequest = new ActivateUserRequest();
				activateUserRequest.ConnectionValidator.ConnectionId = connectionId;
				activateUserRequest.UserToken = UserToken.ToV2UserToken();
				clientAuthenticator.Sign(activateUserRequest);
				ActivateUserResponse activateUserResponse = dataClient.ActivateUser(activateUserRequest);
				if (activateUserResponse != null)
				{
					return activateUserResponse.Result;
				}
			}
		}
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult ExchangeCapabilities(out string ServiceCapabilities, ArchestrAServices.ASBContract.ConnectionId Id, string ClientCapabilities)
	{
		return ExchangeCapabilities(out ServiceCapabilities, ClientCapabilities);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult ExchangeCapabilities(out string ServiceCapabilities, string ClientCapabilities)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ExchangeCapabilitiesRequest exchangeCapabilitiesRequest = new ExchangeCapabilitiesRequest();
				exchangeCapabilitiesRequest.ConnectionValidator.ConnectionId = connectionId;
				exchangeCapabilitiesRequest.ClientCapabilities = ClientCapabilities;
				clientAuthenticator.Sign(exchangeCapabilitiesRequest);
				ExchangeCapabilitiesResponse exchangeCapabilitiesResponse = dataClient.ExchangeCapabilities(exchangeCapabilitiesRequest);
				if (exchangeCapabilitiesResponse != null)
				{
					ServiceCapabilities = exchangeCapabilitiesResponse.ServiceCapabilities;
					return exchangeCapabilitiesResponse.Result;
				}
			}
		}
		ServiceCapabilities = string.Empty;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult Read(out ItemStatusV2[] Status, out ArchestrAServices.ASBContract.RuntimeValue[] Values, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity[] Items)
	{
		return Read(out Status, out Values, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult Read(out ItemStatusV2[] Status, out ArchestrAServices.ASBContract.RuntimeValue[] Values, ArchestrAServices.ASBContract.ItemIdentity[] Items)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.ReadRequest readRequest = new ArchestrAServices.ASBIDataV2Contract.ReadRequest();
				readRequest.ConnectionValidator.ConnectionId = connectionId;
				readRequest.Items = Items.ToV2ItemIdentityArray();
				clientAuthenticator.Sign(readRequest);
				ArchestrAServices.ASBIDataV2Contract.ReadResponse readResponse = dataClient.Read(readRequest);
				if (readResponse != null)
				{
					Status = readResponse.Status.ToMirroredV2ItemStatusArray();
					Values = readResponse.Values.ToV1RuntimeValueArray();
					return readResponse.Result;
				}
			}
		}
		Status = null;
		Values = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult Write(out ItemStatusV2[] Status, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity[] Items, WriteValueV2[] Values, uint WriteHandle)
	{
		return Write(out Status, Items, Values, WriteHandle);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult Write(out ItemStatusV2[] Status, ArchestrAServices.ASBContract.ItemIdentity[] Items, WriteValueV2[] Values, uint WriteHandle)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.WriteBasicRequest writeBasicRequest = new ArchestrAServices.ASBIDataV2Contract.WriteBasicRequest();
				writeBasicRequest.ConnectionValidator.ConnectionId = connectionId;
				writeBasicRequest.Items = Items.ToV2ItemIdentityArray();
				if (Settings != null)
				{
					int setting = Settings.GetSetting("ArrayBase", 0);
					if (setting != 0)
					{
						for (int i = 0; i < Values.Length; i++)
						{
							Values[i].ArrayElementIndex -= setting;
						}
					}
				}
				writeBasicRequest.Values = Values.ToTrueV2WriteValueArray();
				writeBasicRequest.WriteHandle = WriteHandle;
				clientAuthenticator.Sign(writeBasicRequest);
				ArchestrAServices.ASBIDataV2Contract.WriteResponse writeResponse = dataClient.Write(writeBasicRequest);
				if (writeResponse != null)
				{
					Status = writeResponse.Status.ToMirroredV2ItemStatusArray();
					return writeResponse.Result;
				}
			}
		}
		Status = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteUser(out ItemStatusV2[] Status, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity[] Items, WriteValueV2[] Values, ArchestrAServices.ASBContract.UserToken User, uint WriteHandle)
	{
		return WriteUser(out Status, Items, Values, User, WriteHandle);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteUser(out ItemStatusV2[] Status, ArchestrAServices.ASBContract.ItemIdentity[] Items, WriteValueV2[] Values, ArchestrAServices.ASBContract.UserToken User, uint WriteHandle)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.WriteUserRequest writeUserRequest = new ArchestrAServices.ASBIDataV2Contract.WriteUserRequest();
				writeUserRequest.ConnectionValidator.ConnectionId = connectionId;
				writeUserRequest.Items = Items.ToV2ItemIdentityArray();
				if (Settings != null)
				{
					int setting = Settings.GetSetting("ArrayBase", 0);
					if (setting != 0)
					{
						for (int i = 0; i < Values.Length; i++)
						{
							Values[i].ArrayElementIndex -= setting;
						}
					}
				}
				writeUserRequest.Values = Values.ToTrueV2WriteValueArray();
				writeUserRequest.User = User.ToV2UserToken();
				writeUserRequest.WriteHandle = WriteHandle;
				clientAuthenticator.Sign(writeUserRequest);
				ArchestrAServices.ASBIDataV2Contract.WriteUserResponse writeUserResponse = dataClient.WriteUser(writeUserRequest);
				if (writeUserResponse != null)
				{
					Status = writeUserResponse.Status.ToMirroredV2ItemStatusArray();
					return writeUserResponse.Result;
				}
			}
		}
		Status = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteVerified(out ItemStatusV2[] Status, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity[] Items, WriteValueV2[] Values, ArchestrAServices.ASBContract.UserToken User, ArchestrAServices.ASBContract.UserToken Supervisor, uint WriteHandle)
	{
		return WriteVerified(out Status, Items, Values, User, Supervisor, WriteHandle);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteVerified(out ItemStatusV2[] Status, ArchestrAServices.ASBContract.ItemIdentity[] Items, WriteValueV2[] Values, ArchestrAServices.ASBContract.UserToken User, ArchestrAServices.ASBContract.UserToken Supervisor, uint WriteHandle)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.WriteVerifiedRequest writeVerifiedRequest = new ArchestrAServices.ASBIDataV2Contract.WriteVerifiedRequest();
				writeVerifiedRequest.ConnectionValidator.ConnectionId = connectionId;
				writeVerifiedRequest.Items = Items.ToV2ItemIdentityArray();
				if (Settings != null)
				{
					int setting = Settings.GetSetting("ArrayBase", 0);
					if (setting != 0)
					{
						for (int i = 0; i < Values.Length; i++)
						{
							Values[i].ArrayElementIndex -= setting;
						}
					}
				}
				writeVerifiedRequest.Values = Values.ToTrueV2WriteValueArray();
				writeVerifiedRequest.User = User.ToV2UserToken();
				writeVerifiedRequest.Supervisor = Supervisor.ToV2UserToken();
				writeVerifiedRequest.WriteHandle = WriteHandle;
				clientAuthenticator.Sign(writeVerifiedRequest);
				ArchestrAServices.ASBIDataV2Contract.WriteVerifiedResponse writeVerifiedResponse = dataClient.WriteVerified(writeVerifiedRequest);
				if (writeVerifiedResponse != null)
				{
					Status = writeVerifiedResponse.Status.ToMirroredV2ItemStatusArray();
					return writeVerifiedResponse.Result;
				}
			}
		}
		Status = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteSecured(out ItemStatusV2[] Status, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity[] Items, WriteValueV2[] Values, ArchestrAServices.ASBContract.UserToken User, uint WriteHandle)
	{
		return WriteSecured(out Status, Items, Values, User, WriteHandle);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteSecured(out ItemStatusV2[] Status, ArchestrAServices.ASBContract.ItemIdentity[] Items, WriteValueV2[] Values, ArchestrAServices.ASBContract.UserToken User, uint WriteHandle)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.WriteSecuredRequest writeSecuredRequest = new ArchestrAServices.ASBIDataV2Contract.WriteSecuredRequest();
				writeSecuredRequest.ConnectionValidator.ConnectionId = connectionId;
				writeSecuredRequest.Items = Items.ToV2ItemIdentityArray();
				if (Settings != null)
				{
					int setting = Settings.GetSetting("ArrayBase", 0);
					if (setting != 0)
					{
						for (int i = 0; i < Values.Length; i++)
						{
							Values[i].ArrayElementIndex -= setting;
						}
					}
				}
				writeSecuredRequest.Values = Values.ToTrueV2WriteValueArray();
				writeSecuredRequest.User = User.ToV2UserToken();
				writeSecuredRequest.WriteHandle = WriteHandle;
				clientAuthenticator.Sign(writeSecuredRequest);
				ArchestrAServices.ASBIDataV2Contract.WriteSecuredResponse writeSecuredResponse = dataClient.WriteSecured(writeSecuredRequest);
				if (writeSecuredResponse != null)
				{
					Status = writeSecuredResponse.Status.ToMirroredV2ItemStatusArray();
					return writeSecuredResponse.Result;
				}
			}
		}
		Status = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteConfirmed(out WriteValueV2 ValueReceived, out long WriteToken, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity Item, WriteValueV2 Value, ArchestrAServices.ASBContract.UserToken User, ArchestrAServices.ASBContract.UserToken Supervisor)
	{
		return WriteConfirmed(out ValueReceived, out WriteToken, Item, Value, User, Supervisor);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult WriteConfirmed(out WriteValueV2 ValueReceived, out long WriteToken, ArchestrAServices.ASBContract.ItemIdentity Item, WriteValueV2 Value, ArchestrAServices.ASBContract.UserToken User, ArchestrAServices.ASBContract.UserToken Supervisor)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.WriteConfirmedRequest writeConfirmedRequest = new ArchestrAServices.ASBIDataV2Contract.WriteConfirmedRequest();
				writeConfirmedRequest.ConnectionValidator.ConnectionId = connectionId;
				writeConfirmedRequest.Item = Item.ToV2ItemIdentity();
				if (Settings != null)
				{
					int setting = Settings.GetSetting("ArrayBase", 0);
					if (setting != 0)
					{
						Value.ArrayElementIndex -= setting;
					}
				}
				writeConfirmedRequest.Value = Value.ToTrueV2WriteValue();
				writeConfirmedRequest.User = User.ToV2UserToken();
				writeConfirmedRequest.Supervisor = Supervisor.ToV2UserToken();
				clientAuthenticator.Sign(writeConfirmedRequest);
				ArchestrAServices.ASBIDataV2Contract.WriteConfirmedResponse writeConfirmedResponse = dataClient.WriteConfirmed(writeConfirmedRequest);
				if (writeConfirmedResponse != null)
				{
					if (Settings != null)
					{
						int setting2 = Settings.GetSetting("ArrayBase", 0);
						if (setting2 != 0)
						{
							writeConfirmedResponse.ValueReceived.ArrayElementIndex += setting2;
						}
					}
					ValueReceived = writeConfirmedResponse.ValueReceived.ToMirroredV2WriteValue();
					WriteToken = writeConfirmedResponse.WriteToken;
					return writeConfirmedResponse.Result;
				}
			}
		}
		ValueReceived = default(WriteValueV2);
		WriteToken = long.MaxValue;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult ConfirmWrite(ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity Item, long WriteToken, WriteValueV2 Value, ArchestrAServices.ASBContract.UserToken User, ArchestrAServices.ASBContract.UserToken Supervisor, uint WriteHandle)
	{
		return ConfirmWrite(Item, WriteToken, Value, User, Supervisor, WriteHandle);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult ConfirmWrite(ArchestrAServices.ASBContract.ItemIdentity Item, long WriteToken, WriteValueV2 Value, ArchestrAServices.ASBContract.UserToken User, ArchestrAServices.ASBContract.UserToken Supervisor, uint WriteHandle)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.ConfirmWriteRequest confirmWriteRequest = new ArchestrAServices.ASBIDataV2Contract.ConfirmWriteRequest();
				confirmWriteRequest.ConnectionValidator.ConnectionId = connectionId;
				confirmWriteRequest.Item = Item.ToV2ItemIdentity();
				confirmWriteRequest.WriteToken = WriteToken;
				if (Settings != null)
				{
					int setting = Settings.GetSetting("ArrayBase", 0);
					if (setting != 0)
					{
						Value.ArrayElementIndex -= setting;
					}
				}
				confirmWriteRequest.Value = Value.ToTrueV2WriteValue();
				confirmWriteRequest.User = User.ToV2UserToken();
				confirmWriteRequest.Supervisor = Supervisor.ToV2UserToken();
				confirmWriteRequest.WriteHandle = WriteHandle;
				clientAuthenticator.Sign(confirmWriteRequest);
				ArchestrAServices.ASBIDataV2Contract.ConfirmWriteResponse confirmWriteResponse = dataClient.ConfirmWrite(confirmWriteRequest);
				if (confirmWriteResponse != null)
				{
					return confirmWriteResponse.Result;
				}
			}
		}
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult PublishWriteComplete(out ItemWriteCompleteV2[] CompleteWrites, ArchestrAServices.ASBContract.ConnectionId Id)
	{
		return PublishWriteComplete(out CompleteWrites);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult PublishWriteComplete(out ItemWriteCompleteV2[] CompleteWrites)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.PublishWriteCompleteRequest publishWriteCompleteRequest = new ArchestrAServices.ASBIDataV2Contract.PublishWriteCompleteRequest();
				publishWriteCompleteRequest.ConnectionValidator.ConnectionId = connectionId;
				clientAuthenticator.Sign(publishWriteCompleteRequest);
				ArchestrAServices.ASBIDataV2Contract.PublishWriteCompleteResponse publishWriteCompleteResponse = dataClient.PublishWriteComplete(publishWriteCompleteRequest);
				if (publishWriteCompleteResponse != null)
				{
					CompleteWrites = publishWriteCompleteResponse.CompleteWrites.ToMirroredV2ItemWriteCompleteArray();
					return publishWriteCompleteResponse.Result;
				}
			}
		}
		CompleteWrites = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult CreateSubscription(out long SubscriptionId, ArchestrAServices.ASBContract.ConnectionId Id, long MaxQueueSize, ulong SampleInterval)
	{
		return CreateSubscription(out SubscriptionId, MaxQueueSize, SampleInterval);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult CreateSubscription(out long SubscriptionId, long MaxQueueSize, ulong SampleInterval)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.CreateSubscriptionRequest createSubscriptionRequest = new ArchestrAServices.ASBIDataV2Contract.CreateSubscriptionRequest();
				createSubscriptionRequest.ConnectionValidator.ConnectionId = connectionId;
				createSubscriptionRequest.MaxQueueSize = MaxQueueSize;
				createSubscriptionRequest.SampleInterval = SampleInterval;
				clientAuthenticator.Sign(createSubscriptionRequest);
				ArchestrAServices.ASBIDataV2Contract.CreateSubscriptionResponse createSubscriptionResponse = dataClient.CreateSubscription(createSubscriptionRequest);
				if (createSubscriptionResponse != null)
				{
					SubscriptionId = createSubscriptionResponse.SubscriptionId;
					return createSubscriptionResponse.Result;
				}
			}
		}
		SubscriptionId = long.MaxValue;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult SetSubscriptionState(ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId, ArchestrAServices.ASBIDataContract.Variant NewState, ushort StateToChange)
	{
		return SetSubscriptionState(SubscriptionId, NewState, StateToChange);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult SetSubscriptionState(long SubscriptionId, ArchestrAServices.ASBIDataContract.Variant NewState, ushort StateToChange)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.SetSubscriptionStateRequest setSubscriptionStateRequest = new ArchestrAServices.ASBIDataV2Contract.SetSubscriptionStateRequest();
				setSubscriptionStateRequest.ConnectionValidator.ConnectionId = connectionId;
				setSubscriptionStateRequest.SubscriptionId = SubscriptionId;
				setSubscriptionStateRequest.NewStateProperty = NewState.ToV2Variant();
				setSubscriptionStateRequest.StateToChange = StateToChange;
				clientAuthenticator.Sign(setSubscriptionStateRequest);
				ArchestrAServices.ASBIDataV2Contract.SetSubscriptionStateResponse setSubscriptionStateResponse = dataClient.SetSubscriptionState(setSubscriptionStateRequest);
				if (setSubscriptionStateResponse != null)
				{
					return setSubscriptionStateResponse.Result;
				}
			}
		}
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult GetSubscriptionState(out ArchestrAServices.ASBIDataContract.Variant State, ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId, ushort StateToGet)
	{
		return GetSubscriptionState(out State, SubscriptionId, StateToGet);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult GetSubscriptionState(out ArchestrAServices.ASBIDataContract.Variant State, long SubscriptionId, ushort StateToGet)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.GetSubscriptionStateRequest getSubscriptionStateRequest = new ArchestrAServices.ASBIDataV2Contract.GetSubscriptionStateRequest();
				getSubscriptionStateRequest.ConnectionValidator.ConnectionId = connectionId;
				getSubscriptionStateRequest.SubscriptionId = SubscriptionId;
				getSubscriptionStateRequest.StateToGet = StateToGet;
				clientAuthenticator.Sign(getSubscriptionStateRequest);
				ArchestrAServices.ASBIDataV2Contract.GetSubscriptionStateResponse subscriptionState = dataClient.GetSubscriptionState(getSubscriptionStateRequest);
				if (subscriptionState != null)
				{
					State = subscriptionState.StateProperty.ToV1Variant();
					return subscriptionState.Result;
				}
			}
		}
		State = default(ArchestrAServices.ASBIDataContract.Variant);
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult DeleteSubscription(ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId)
	{
		return DeleteSubscription(SubscriptionId);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult DeleteSubscription(long SubscriptionId)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.DeleteSubscriptionRequest deleteSubscriptionRequest = new ArchestrAServices.ASBIDataV2Contract.DeleteSubscriptionRequest();
				deleteSubscriptionRequest.ConnectionValidator.ConnectionId = connectionId;
				deleteSubscriptionRequest.SubscriptionId = SubscriptionId;
				clientAuthenticator.Sign(deleteSubscriptionRequest);
				ArchestrAServices.ASBIDataV2Contract.DeleteSubscriptionResponse deleteSubscriptionResponse = dataClient.DeleteSubscription(deleteSubscriptionRequest);
				if (deleteSubscriptionResponse != null)
				{
					return deleteSubscriptionResponse.Result;
				}
			}
		}
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult AddMonitoredItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.ItemRegistration[] ItemCapabilities, ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId, ArchestrAServices.ASBContract.MonitoredItem[] Items, byte RequireId)
	{
		return AddMonitoredItems(out Status, out ItemCapabilities, SubscriptionId, RequireId != 0, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult AddMonitoredItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.ItemRegistration[] ItemCapabilities, long SubscriptionId, ArchestrAServices.ASBContract.MonitoredItem[] Items, byte RequireId)
	{
		return AddMonitoredItems(out Status, out ItemCapabilities, SubscriptionId, RequireId != 0, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult AddMonitoredItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.ItemRegistration[] ItemCapabilities, long SubscriptionId, bool RequireId, ArchestrAServices.ASBContract.MonitoredItem[] Items)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.AddMonitoredItemsRequest addMonitoredItemsRequest = new ArchestrAServices.ASBIDataV2Contract.AddMonitoredItemsRequest();
				addMonitoredItemsRequest.ConnectionValidator.ConnectionId = connectionId;
				addMonitoredItemsRequest.SubscriptionId = SubscriptionId;
				addMonitoredItemsRequest.Items = Items.ToV2MonitoredItemArray();
				addMonitoredItemsRequest.RequireId = RequireId;
				clientAuthenticator.Sign(addMonitoredItemsRequest);
				ArchestrAServices.ASBIDataV2Contract.AddMonitoredItemsResponse addMonitoredItemsResponse = dataClient.AddMonitoredItems(addMonitoredItemsRequest);
				if (addMonitoredItemsResponse != null)
				{
					Status = addMonitoredItemsResponse.Status.ToV1ItemStatusArray();
					ItemCapabilities = addMonitoredItemsResponse.ItemCapabilities.ToV1ItemRegistrationArray();
					return addMonitoredItemsResponse.Result;
				}
			}
		}
		Status = null;
		ItemCapabilities = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult DeleteMonitoredItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId, ArchestrAServices.ASBContract.MonitoredItem[] Items)
	{
		return DeleteMonitoredItems(out Status, SubscriptionId, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult DeleteMonitoredItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, long SubscriptionId, ArchestrAServices.ASBContract.MonitoredItem[] Items)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.DeleteMonitoredItemsRequest deleteMonitoredItemsRequest = new ArchestrAServices.ASBIDataV2Contract.DeleteMonitoredItemsRequest();
				deleteMonitoredItemsRequest.ConnectionValidator.ConnectionId = connectionId;
				deleteMonitoredItemsRequest.SubscriptionId = SubscriptionId;
				deleteMonitoredItemsRequest.Items = Items.ToV2MonitoredItemArray();
				clientAuthenticator.Sign(deleteMonitoredItemsRequest);
				ArchestrAServices.ASBIDataV2Contract.DeleteMonitoredItemsResponse deleteMonitoredItemsResponse = dataClient.DeleteMonitoredItems(deleteMonitoredItemsRequest);
				if (deleteMonitoredItemsResponse != null)
				{
					Status = deleteMonitoredItemsResponse.Status.ToV1ItemStatusArray();
					return deleteMonitoredItemsResponse.Result;
				}
			}
		}
		Status = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult GetMonitoredItems(out ArchestrAServices.ASBContract.MonitoredItem[] Items, ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId)
	{
		return GetMonitoredItems(out Items, SubscriptionId);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult GetMonitoredItems(out ArchestrAServices.ASBContract.MonitoredItem[] Items, long SubscriptionId)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.GetMonitoredItemsRequest getMonitoredItemsRequest = new ArchestrAServices.ASBIDataV2Contract.GetMonitoredItemsRequest();
				getMonitoredItemsRequest.ConnectionValidator.ConnectionId = connectionId;
				getMonitoredItemsRequest.SubscriptionId = SubscriptionId;
				clientAuthenticator.Sign(getMonitoredItemsRequest);
				ArchestrAServices.ASBIDataV2Contract.GetMonitoredItemsResponse monitoredItems = dataClient.GetMonitoredItems(getMonitoredItemsRequest);
				if (monitoredItems != null)
				{
					Items = monitoredItems.Items.ToV1MonitoredItemArray();
					return monitoredItems.Result;
				}
			}
		}
		Items = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult Publish(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.MonitoredItemValue[] Values, ArchestrAServices.ASBContract.ConnectionId Id, long SubscriptionId)
	{
		return Publish(out Status, out Values, SubscriptionId);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult Publish(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.MonitoredItemValue[] Values, long SubscriptionId)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.PublishRequest publishRequest = new ArchestrAServices.ASBIDataV2Contract.PublishRequest();
				publishRequest.ConnectionValidator.ConnectionId = connectionId;
				publishRequest.SubscriptionId = SubscriptionId;
				clientAuthenticator.Sign(publishRequest);
				ArchestrAServices.ASBIDataV2Contract.PublishResponse publishResponse = dataClient.Publish(publishRequest);
				if (publishResponse != null)
				{
					Status = publishResponse.Status.ToV1ItemStatusArray();
					Values = publishResponse.Values.ToV1MonitoredItemValueArray();
					return publishResponse.Result;
				}
			}
		}
		Status = null;
		Values = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult RegisterItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.ItemRegistration[] ItemCapabilities, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity[] Items, byte RequireId, byte RegisterOnly)
	{
		return RegisterItems(out Status, out ItemCapabilities, RequireId != 0, RegisterOnly != 0, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult RegisterItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.ItemRegistration[] ItemCapabilities, ArchestrAServices.ASBContract.ItemIdentity[] Items, byte RequireId, byte RegisterOnly)
	{
		return RegisterItems(out Status, out ItemCapabilities, RequireId != 0, RegisterOnly != 0, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult RegisterItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, out ArchestrAServices.ASBContract.ItemRegistration[] ItemCapabilities, bool RequireId, bool RegisterOnly, ArchestrAServices.ASBContract.ItemIdentity[] Items)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.RegisterItemsRequest registerItemsRequest = new ArchestrAServices.ASBIDataV2Contract.RegisterItemsRequest();
				registerItemsRequest.ConnectionValidator.ConnectionId = connectionId;
				registerItemsRequest.Items = Items.ToV2ItemIdentityArray();
				registerItemsRequest.RequireId = RequireId;
				registerItemsRequest.RegisterOnly = RegisterOnly;
				clientAuthenticator.Sign(registerItemsRequest);
				ArchestrAServices.ASBIDataV2Contract.RegisterItemsResponse registerItemsResponse = dataClient.RegisterItems(registerItemsRequest);
				if (registerItemsResponse != null)
				{
					Status = registerItemsResponse.Status.ToV1ItemStatusArray();
					ItemCapabilities = registerItemsResponse.ItemCapabilities.ToV1ItemRegistrationArray();
					return registerItemsResponse.Result;
				}
			}
		}
		Status = null;
		ItemCapabilities = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult UnregisterItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, ArchestrAServices.ASBContract.ConnectionId Id, ArchestrAServices.ASBContract.ItemIdentity[] Items)
	{
		return UnregisterItems(out Status, Items);
	}

	public ArchestrAServices.ASBContract.ArchestrAResult UnregisterItems(out ArchestrAServices.ASBContract.ItemStatus[] Status, ArchestrAServices.ASBContract.ItemIdentity[] Items)
	{
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null)
			{
				ArchestrAServices.ASBIDataV2Contract.UnregisterItemsRequest unregisterItemsRequest = new ArchestrAServices.ASBIDataV2Contract.UnregisterItemsRequest();
				unregisterItemsRequest.ConnectionValidator.ConnectionId = connectionId;
				unregisterItemsRequest.Items = Items.ToV2ItemIdentityArray();
				clientAuthenticator.Sign(unregisterItemsRequest);
				ArchestrAServices.ASBIDataV2Contract.UnregisterItemsResponse unregisterItemsResponse = dataClient.UnregisterItems(unregisterItemsRequest);
				if (unregisterItemsResponse != null)
				{
					Status = unregisterItemsResponse.Status.ToV1ItemStatusArray();
					return unregisterItemsResponse.Result;
				}
			}
		}
		Status = null;
		return ArchestrAServices.ASBContract.ResultFactory.MakeResult(ArchestrAServices.ASBContract.ArchestrAError.OperationFailed, 0);
	}

	public void OnConnect(ArchestrAServices.ASBContract.ConnectionId ConnectionId, ulong Timeout)
	{
	}

	public void OnDisconnect(ArchestrAServices.ASBContract.ConnectionId Id)
	{
	}

	public static FindResponse FindIDataEndpoint(string AccessName)
	{
		FindResponse result = null;
		try
		{
			Uri uri = RegistryHandler.MakeLDSProbeEndpointAddress(Environment.MachineName);
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "FindIDataEndpoint generated LDS endpoint for SR Node localhost: {0}", uri.AbsoluteUri);
			FindCriteria findCriteria = new FindCriteria();
			XmlQualifiedName xmlQualifiedName = new XmlQualifiedName("IASBIDataV2", "http://ASB.IDataV2");
			if (!string.IsNullOrEmpty(xmlQualifiedName.Name))
			{
				findCriteria.ContractTypeNames.Add(xmlQualifiedName);
			}
			List<string> list = new List<string>();
			list.Add("domainname/" + AccessName);
			Collection<Uri> collection = SvcUtilities.CreateFindScopes(string.Empty, string.Empty, string.Empty, list);
			findCriteria.Scopes.Clear();
			foreach (Uri item in collection)
			{
				findCriteria.Scopes.Add(item);
			}
			using DiscoveryClient discoveryClient = new DiscoveryClient(new DiscoveryEndpoint(SvcUtilities.GetBinding(uri.AbsoluteUri), new EndpointAddress(uri)));
			result = discoveryClient.Find(findCriteria);
		}
		catch (TargetInvocationException ex)
		{
			SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "FindIDataEndpoint({0}) TargetInvocationException: {1}", AccessName, ex.Message);
			if (ex.InnerException != null)
			{
				SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "   {0}", ex.InnerException.Message);
			}
			result = null;
		}
		catch (ObjectDisposedException ex2)
		{
			SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "FindIDataEndpoint({0}) ObjectDisposedException: {1}", AccessName, ex2.Message);
			if (ex2.InnerException != null)
			{
				SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "   {0}", ex2.InnerException.Message);
			}
			result = null;
		}
		catch (Exception ex3)
		{
			SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "FindIDataEndpoint({0}) Exception: {1}", AccessName, ex3.Message);
			if (ex3.InnerException != null)
			{
				SvcTrace.DiagException.TraceEvent(TraceEventType.Error, 0, "   {0}", ex3.InnerException.Message);
			}
			result = null;
		}
		return result;
	}

	protected virtual void Dispose(bool disposing)
	{
		if (!disposing)
		{
			return;
		}
		if (dataClient != null)
		{
			SysAuthClientAuthentication clientAuthenticator = SysAuthenticatorClientCache.GetClientAuthenticator(connectionId);
			if (clientAuthenticator != null && clientAuthenticator.SecureSessionEstablished)
			{
				Disconnect();
			}
			IClientChannel obj = dataClient as IClientChannel;
			obj?.Close();
			obj?.Dispose();
		}
		connectionEstablishedEvent?.Close();
		connectionEstablishedEvent = null;
	}

	public void Dispose()
	{
		Dispose(disposing: true);
		GC.SuppressFinalize(this);
	}
}