#define TRACE
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.ServiceModel;
using System.Threading;
using ArchestrAServices.ASBIDataV2Adapter;
using ArchestrAServices.ASBIDataV2Contract;
using ArchestrAServices.Common;

namespace ArchestrAServices.ASBContract;

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Multiple)]
public abstract class ASBIDataV1Shim : IASBIDataV2, IAuthenticateASB
{
	private class ConnectionContext
	{
		public IContextChannel ConnectionChannel;

		public IDataV2toV1 ConnectionImplementation;

		public Timer ConnectionKeepaliveTimer;

		private ConnectionContext()
		{
		}

		public ConnectionContext(IContextChannel Channel, IDataV2toV1 Implementation, Timer KeepaliveTimer)
		{
			ConnectionChannel = Channel;
			ConnectionImplementation = Implementation;
			ConnectionKeepaliveTimer = KeepaliveTimer;
		}
	}

	private static ReaderWriterLockSlim implementationLock = new ReaderWriterLockSlim();

	private static Dictionary<Guid, ConnectionContext> m_Implementations = new Dictionary<Guid, ConnectionContext>();

	private static int KeepaliveTimeout = 30000;

	protected virtual IDataV2toV1 GetImplementation()
	{
		return null;
	}

	public ASBIDataV1Shim()
	{
	}

	public virtual ConnectResponse Connect(ConnectRequest request)
	{
		ConnectResponse connectResponse = SysAuthServiceAuthentication.ProcessClientConnection(request);
		SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "Connect started new Authenticator for connection Id {0}", connectResponse.ConnectionValidator.ConnectionId.ToString());
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Start, 100, string.Empty, "Connect started new Authenticator for connection Id =", connectResponse.ConnectionValidator.ConnectionId.ToString());
		return connectResponse;
	}

	public virtual void AuthenticateMe(AuthenticateMe request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Stop, 100, string.Empty, "AuthenticateMe entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && (OperationContext.Current.Channel.LocalAddress.Uri.ToString().ToLower().StartsWith("http") || serviceAuthenticator.ProcessClientAuthenticateMe(request)))
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "AuthenticateMe found authenticator and validated request message, calling implementation OnConnect({0})", serviceAuthenticator.connectionID.ToString());
			ConnectionId connectionId = new ConnectionId
			{
				Id = serviceAuthenticator.connectionID
			};
			IDataV2toV1 implementation = GetImplementation();
			if (implementation != null)
			{
				Timer keepaliveTimer = new Timer(KeepaliveHandler, implementation, KeepaliveTimeout, -1);
				try
				{
					SvcTrace.DiagCsv.TraceEvent(TraceEventType.Start, 100, string.Empty, "AuthenticateMe found authenticator and validated request message, calling implementation OnConnect Id =", serviceAuthenticator.connectionID.ToString());
					implementation.OnConnect(connectionId, serviceAuthenticator.Lifetime);
					implementationLock.EnterWriteLock();
					try
					{
						m_Implementations.Add(serviceAuthenticator.connectionID, new ConnectionContext(OperationContext.Current.Channel, implementation, keepaliveTimer));
						SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "AuthenticateMe added implementation for ConnectionId {0}", serviceAuthenticator.connectionID);
					}
					finally
					{
						implementationLock.ExitWriteLock();
					}
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "AuthenticateMe caught exception from implementation for ConnectionId {0}: {1}", serviceAuthenticator.connectionID, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Start, 100, string.Empty, "AuthenticateMe exit Id =", serviceAuthenticator.connectionID.ToString());
	}

	public virtual RenewResponse Renew(RenewRequest request)
	{
		return SysAuthServiceAuthentication.ProcessClientRenew(request);
	}

	public virtual void UpdateSystemAuthenticationConfiguration(UpdateSystemAuthenticationConfiguration request)
	{
		SysAuthServiceAuthentication.ProcessClientUpdateSystemAuthenticationConfiguration(request);
	}

	public virtual void Disconnect(Disconnect request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Stop, 100, string.Empty, "Disconnect entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			OnDisconnect(request.ConnectionValidator.ConnectionId);
			serviceAuthenticator.ProcessClientDisconnect(request);
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Stop, 100, string.Empty, "Disconnect exit Id =", request.ConnectionValidator.ConnectionId.ToString());
	}

	private void OnDisconnect(Guid ConnectionId)
	{
		ConnectionId id = new ConnectionId
		{
			Id = ConnectionId
		};
		bool flag = false;
		implementationLock.EnterReadLock();
		ConnectionContext value;
		try
		{
			flag = m_Implementations.TryGetValue(ConnectionId, out value);
		}
		finally
		{
			implementationLock.ExitReadLock();
		}
		if (!flag)
		{
			return;
		}
		IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
		Timer connectionKeepaliveTimer = value.ConnectionKeepaliveTimer;
		connectionKeepaliveTimer.Change(-1, -1);
		connectionKeepaliveTimer.Dispose();
		try
		{
			SvcTrace.DiagCsv.TraceEvent(TraceEventType.Start, 100, string.Empty, "OnDisconnect found authenticator and validated request message, calling implementation OnDisconnect Id =", ConnectionId.ToString());
			connectionImplementation.OnDisconnect(id);
		}
		catch (Exception ex)
		{
			SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "OnDisconnect caught exception from implementation for ConnectionId {0}: {1}", ConnectionId, ex.Message);
			if (ex.InnerException != null)
			{
				SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
			}
		}
		implementationLock.EnterWriteLock();
		try
		{
			m_Implementations.Remove(ConnectionId);
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "OnDisconnect removed implementation for ConnectionId {0}", ConnectionId);
		}
		finally
		{
			implementationLock.ExitWriteLock();
		}
	}

	public virtual void KeepAlive(KeepAlive request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 100, string.Empty, "KeepAlive entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId connectionId = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					connectionImplementation.KeepAlive(connectionId);
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "KeepAlive caught exception from implementation for ConnectionId {0}: {1}", connectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 100, string.Empty, "KeepAlive exit Id =", request.ConnectionValidator.ConnectionId.ToString());
	}

	private void KeepaliveHandler(object Implementation)
	{
		Guid guid = Guid.Empty;
		IContextChannel contextChannel = null;
		implementationLock.EnterReadLock();
		try
		{
			foreach (KeyValuePair<Guid, ConnectionContext> implementation in m_Implementations)
			{
				if (implementation.Value.ConnectionImplementation == Implementation)
				{
					guid = implementation.Key;
					contextChannel = implementation.Value.ConnectionChannel;
					break;
				}
			}
		}
		finally
		{
			implementationLock.ExitReadLock();
		}
		if (guid == Guid.Empty)
		{
			SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "Keepalive timeout triggered, could not find ConnectionId");
			return;
		}
		OnDisconnect(guid);
		SysAuthenticatorServiceCache.RemoveServiceAuthenticator(guid);
		try
		{
			if (contextChannel != null)
			{
				SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "Keepalive timeout elapsed without any method calls, closing connection {0} and aborting service channel", guid.ToString());
				contextChannel.Abort();
			}
		}
		catch (Exception ex)
		{
			SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, ex.StackTrace);
		}
	}

	public virtual ActivateUserResponse ActivateUser(ActivateUserRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "ActivateUser entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ActivateUserResponse activateUserResponse = new ActivateUserResponse();
		activateUserResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null)
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "ActivateUser found authenticator for Connection Id {0}", request.ConnectionValidator.ConnectionId.ToString());
		}
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "ActivateUser validated request, passing to service");
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					activateUserResponse.Result = connectionImplementation.ActivateUser(id, request.UserToken.ToV1UserToken());
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "ActivateUser caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					activateUserResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					activateUserResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "ActivateUser exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return activateUserResponse;
	}

	public virtual ExchangeCapabilitiesResponse ExchangeCapabilities(ExchangeCapabilitiesRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "ExchangeCapabilities entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ExchangeCapabilitiesResponse exchangeCapabilitiesResponse = new ExchangeCapabilitiesResponse();
		exchangeCapabilitiesResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null)
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "ExchangeCapabilities found authenticator for Connection Id {0}", request.ConnectionValidator.ConnectionId.ToString());
		}
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "ExchangeCapabilities validated request, passing to service");
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					exchangeCapabilitiesResponse.Result = connectionImplementation.ExchangeCapabilities(out var ServiceCapabilities, id, request.ClientCapabilities);
					exchangeCapabilitiesResponse.ServiceCapabilities = ServiceCapabilities;
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "ExchangeCapabilities caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					exchangeCapabilitiesResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					exchangeCapabilitiesResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "ExchangeCapabilities exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return exchangeCapabilitiesResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.ReadResponse Read(ArchestrAServices.ASBIDataV2Contract.ReadRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "Read entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.ReadResponse readResponse = new ArchestrAServices.ASBIDataV2Contract.ReadResponse();
		readResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					ItemStatusV2[] Status = null;
					RuntimeValue[] Values = null;
					ItemIdentity[] items = null;
					readResponse.Status = null;
					readResponse.Values = null;
					if (request.Items != null)
					{
						items = request.Items.ToV1ItemIdentityArray();
					}
					readResponse.Result = connectionImplementation.Read(out Status, out Values, id, items);
					if (Status != null)
					{
						readResponse.Status = Status.ToTrueV2ItemStatusArray();
					}
					if (Values != null)
					{
						readResponse.Values = Values.ToV2RuntimeValueArray();
					}
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "Read caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					readResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					readResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "Read exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return readResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.WriteResponse Write(ArchestrAServices.ASBIDataV2Contract.WriteBasicRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "Write entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.WriteResponse writeResponse = new ArchestrAServices.ASBIDataV2Contract.WriteResponse();
		writeResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					WriteValueV2[] array = request.Values.ToMirroredV2WriteValueArray();
					if (connectionImplementation.Settings != null)
					{
						int setting = connectionImplementation.Settings.GetSetting("ArrayBase", 0);
						if (setting != 0)
						{
							for (int i = 0; i < array.Length; i++)
							{
								array[i].ArrayElementIndex += setting;
							}
						}
					}
					ItemIdentity[] items = null;
					if (request.Items != null)
					{
						items = request.Items.ToV1ItemIdentityArray();
					}
					writeResponse.Result = connectionImplementation.Write(out var Status, id, items, array, request.WriteHandle);
					writeResponse.Status = Status.ToTrueV2ItemStatusArray();
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "Write caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					writeResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					writeResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "Write exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return writeResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.WriteUserResponse WriteUser(ArchestrAServices.ASBIDataV2Contract.WriteUserRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteUser entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.WriteUserResponse writeUserResponse = new ArchestrAServices.ASBIDataV2Contract.WriteUserResponse();
		writeUserResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			ConnectionId id = new ConnectionId
			{
				Id = serviceAuthenticator.connectionID
			};
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					WriteValueV2[] array = null;
					ItemIdentity[] items = null;
					if (request.Values != null)
					{
						array = request.Values.ToMirroredV2WriteValueArray();
						if (connectionImplementation.Settings != null)
						{
							int setting = connectionImplementation.Settings.GetSetting("ArrayBase", 0);
							if (setting != 0)
							{
								for (int i = 0; i < array.Length; i++)
								{
									array[i].ArrayElementIndex += setting;
								}
							}
						}
					}
					if (request.Items != null)
					{
						items = request.Items.ToV1ItemIdentityArray();
					}
					writeUserResponse.Result = connectionImplementation.WriteUser(out var Status, id, items, array, request.User.ToV1UserToken(), request.WriteHandle);
					writeUserResponse.Status = Status.ToTrueV2ItemStatusArray();
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "WriteUser caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					writeUserResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					writeUserResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteUser exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return writeUserResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.WriteVerifiedResponse WriteVerified(ArchestrAServices.ASBIDataV2Contract.WriteVerifiedRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteVerified entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.WriteVerifiedResponse writeVerifiedResponse = new ArchestrAServices.ASBIDataV2Contract.WriteVerifiedResponse();
		writeVerifiedResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					WriteValueV2[] array = null;
					ItemIdentity[] items = null;
					writeVerifiedResponse.Status = null;
					if (request.Values != null)
					{
						array = request.Values.ToMirroredV2WriteValueArray();
						if (connectionImplementation.Settings != null)
						{
							int setting = connectionImplementation.Settings.GetSetting("ArrayBase", 0);
							if (setting != 0)
							{
								for (int i = 0; i < array.Length; i++)
								{
									array[i].ArrayElementIndex += setting;
								}
							}
						}
					}
					if (request.Items != null)
					{
						items = request.Items.ToV1ItemIdentityArray();
					}
					writeVerifiedResponse.Result = connectionImplementation.WriteVerified(out var Status, id, items, array, request.User.ToV1UserToken(), request.Supervisor.ToV1UserToken(), request.WriteHandle);
					if (Status != null)
					{
						writeVerifiedResponse.Status = Status.ToTrueV2ItemStatusArray();
					}
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "WriteVerified caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					writeVerifiedResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					writeVerifiedResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteVerified exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return writeVerifiedResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.WriteSecuredResponse WriteSecured(ArchestrAServices.ASBIDataV2Contract.WriteSecuredRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteSecured entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.WriteSecuredResponse writeSecuredResponse = new ArchestrAServices.ASBIDataV2Contract.WriteSecuredResponse();
		writeSecuredResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					WriteValueV2[] array = null;
					ItemIdentity[] items = null;
					writeSecuredResponse.Status = null;
					if (request.Values != null)
					{
						array = request.Values.ToMirroredV2WriteValueArray();
						if (connectionImplementation.Settings != null)
						{
							int setting = connectionImplementation.Settings.GetSetting("ArrayBase", 0);
							if (setting != 0)
							{
								for (int i = 0; i < array.Length; i++)
								{
									array[i].ArrayElementIndex += setting;
								}
							}
						}
					}
					if (request.Items != null)
					{
						items = request.Items.ToV1ItemIdentityArray();
					}
					writeSecuredResponse.Result = connectionImplementation.WriteSecured(out var Status, id, items, array, request.User.ToV1UserToken(), request.WriteHandle);
					if (Status != null)
					{
						writeSecuredResponse.Status = Status.ToTrueV2ItemStatusArray();
					}
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "WriteSecured caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					writeSecuredResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					writeSecuredResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteSecured exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return writeSecuredResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.WriteConfirmedResponse WriteConfirmed(ArchestrAServices.ASBIDataV2Contract.WriteConfirmedRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteConfirmed entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.WriteConfirmedResponse writeConfirmedResponse = new ArchestrAServices.ASBIDataV2Contract.WriteConfirmedResponse();
		writeConfirmedResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					if (connectionImplementation.Settings != null)
					{
						int setting = connectionImplementation.Settings.GetSetting("ArrayBase", 0);
						if (setting != 0)
						{
							request.Value.ArrayElementIndex += setting;
						}
					}
					writeConfirmedResponse.Result = connectionImplementation.WriteConfirmed(out var ValueReceived, out var WriteToken, id, request.Item.ToV1ItemIdentity(), request.Value.ToMirroredV2WriteValue(), request.User.ToV1UserToken(), request.Supervisor.ToV1UserToken());
					if (connectionImplementation.Settings != null)
					{
						int setting2 = connectionImplementation.Settings.GetSetting("ArrayBase", 0);
						if (setting2 != 0)
						{
							ValueReceived.ArrayElementIndex -= setting2;
						}
					}
					writeConfirmedResponse.ValueReceived = ValueReceived.ToTrueV2WriteValue();
					writeConfirmedResponse.WriteToken = WriteToken;
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "WriteConfirmed caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					writeConfirmedResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					writeConfirmedResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteConfirmed exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return writeConfirmedResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.ConfirmWriteResponse ConfirmWrite(ArchestrAServices.ASBIDataV2Contract.ConfirmWriteRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "ConfirmWrite entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.ConfirmWriteResponse confirmWriteResponse = new ArchestrAServices.ASBIDataV2Contract.ConfirmWriteResponse();
		confirmWriteResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					if (connectionImplementation.Settings != null)
					{
						int setting = connectionImplementation.Settings.GetSetting("ArrayBase", 0);
						if (setting != 0)
						{
							request.Value.ArrayElementIndex += setting;
						}
					}
					confirmWriteResponse.Result = connectionImplementation.ConfirmWrite(id, request.Item.ToV1ItemIdentity(), request.WriteToken, request.Value.ToMirroredV2WriteValue(), request.User.ToV1UserToken(), request.Supervisor.ToV1UserToken(), request.WriteHandle);
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "ConfirmWrite caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					confirmWriteResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					confirmWriteResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "ConfirmWrite exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return confirmWriteResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.PublishWriteCompleteResponse PublishWriteComplete(ArchestrAServices.ASBIDataV2Contract.PublishWriteCompleteRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "PublishWriteComplete entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.PublishWriteCompleteResponse publishWriteCompleteResponse = new ArchestrAServices.ASBIDataV2Contract.PublishWriteCompleteResponse();
		publishWriteCompleteResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					publishWriteCompleteResponse.CompleteWrites = null;
					publishWriteCompleteResponse.Result = connectionImplementation.PublishWriteComplete(out var CompleteWrites, id);
					if (CompleteWrites != null)
					{
						publishWriteCompleteResponse.CompleteWrites = CompleteWrites.ToV2ItemWriteCompleteArray();
					}
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "PublishWriteComplete caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					publishWriteCompleteResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					publishWriteCompleteResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "PublishWriteComplete exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return publishWriteCompleteResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.CreateSubscriptionResponse CreateSubscription(ArchestrAServices.ASBIDataV2Contract.CreateSubscriptionRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "CreateSubscription entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.CreateSubscriptionResponse createSubscriptionResponse = new ArchestrAServices.ASBIDataV2Contract.CreateSubscriptionResponse();
		createSubscriptionResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null)
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "CreateSubscription found authenticator for Connection Id {0}", request.ConnectionValidator.ConnectionId.ToString());
		}
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "CreateSubscription validated request, passing to service");
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					createSubscriptionResponse.Result = connectionImplementation.CreateSubscription(out var SubscriptionId, id, request.MaxQueueSize, request.SampleInterval);
					createSubscriptionResponse.SubscriptionId = SubscriptionId;
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "CreateSubscription caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					createSubscriptionResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					createSubscriptionResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "CreateSubscription exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return createSubscriptionResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.SetSubscriptionStateResponse SetSubscriptionState(ArchestrAServices.ASBIDataV2Contract.SetSubscriptionStateRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "SetSubscriptionState entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.SetSubscriptionStateResponse setSubscriptionStateResponse = new ArchestrAServices.ASBIDataV2Contract.SetSubscriptionStateResponse();
		setSubscriptionStateResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					setSubscriptionStateResponse.Result = connectionImplementation.SetSubscriptionState(id, request.SubscriptionId, request.NewStateProperty.ToV1Variant(), request.StateToChange);
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "SetSubscriptionState caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					setSubscriptionStateResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					setSubscriptionStateResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "SetSubscriptionState exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return setSubscriptionStateResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.GetSubscriptionStateResponse GetSubscriptionState(ArchestrAServices.ASBIDataV2Contract.GetSubscriptionStateRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "GetSubscriptionState entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.GetSubscriptionStateResponse getSubscriptionStateResponse = new ArchestrAServices.ASBIDataV2Contract.GetSubscriptionStateResponse();
		getSubscriptionStateResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					getSubscriptionStateResponse.Result = connectionImplementation.GetSubscriptionState(out var State, id, request.SubscriptionId, request.StateToGet);
					getSubscriptionStateResponse.StateProperty = State.ToV2Variant();
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "GetSubscriptionState caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					getSubscriptionStateResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					getSubscriptionStateResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "GetSubscriptionState exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return getSubscriptionStateResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.DeleteSubscriptionResponse DeleteSubscription(ArchestrAServices.ASBIDataV2Contract.DeleteSubscriptionRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "DeleteSubscription entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.DeleteSubscriptionResponse deleteSubscriptionResponse = new ArchestrAServices.ASBIDataV2Contract.DeleteSubscriptionResponse();
		deleteSubscriptionResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					deleteSubscriptionResponse.Result = connectionImplementation.DeleteSubscription(id, request.SubscriptionId);
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "DeleteSubscription caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					deleteSubscriptionResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					deleteSubscriptionResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "DeleteSubscription exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return deleteSubscriptionResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.AddMonitoredItemsResponse AddMonitoredItems(ArchestrAServices.ASBIDataV2Contract.AddMonitoredItemsRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "AddMonitoredItems entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.AddMonitoredItemsResponse addMonitoredItemsResponse = new ArchestrAServices.ASBIDataV2Contract.AddMonitoredItemsResponse();
		addMonitoredItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					MonitoredItem[] items = null;
					addMonitoredItemsResponse.Status = null;
					addMonitoredItemsResponse.ItemCapabilities = null;
					if (request.Items != null)
					{
						items = request.Items.ToV1MonitoredItemArray();
					}
					addMonitoredItemsResponse.Result = connectionImplementation.AddMonitoredItems(out var Status, out var ItemCapabilities, id, request.SubscriptionId, items, (byte)(request.RequireId ? 1 : 0));
					if (Status != null)
					{
						addMonitoredItemsResponse.Status = Status.ToV2ItemStatusArray();
					}
					if (ItemCapabilities != null)
					{
						addMonitoredItemsResponse.ItemCapabilities = ItemCapabilities.ToV2ItemRegistrationArray();
					}
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "AddMonitoredItems caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					addMonitoredItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					addMonitoredItemsResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "AddMonitoredItems exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return addMonitoredItemsResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.DeleteMonitoredItemsResponse DeleteMonitoredItems(ArchestrAServices.ASBIDataV2Contract.DeleteMonitoredItemsRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "DeleteMonitoredItems entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.DeleteMonitoredItemsResponse deleteMonitoredItemsResponse = new ArchestrAServices.ASBIDataV2Contract.DeleteMonitoredItemsResponse();
		deleteMonitoredItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					MonitoredItem[] items = null;
					deleteMonitoredItemsResponse.Status = null;
					if (request.Items != null)
					{
						items = request.Items.ToV1MonitoredItemArray();
					}
					deleteMonitoredItemsResponse.Result = connectionImplementation.DeleteMonitoredItems(out var Status, id, request.SubscriptionId, items);
					if (Status != null)
					{
						deleteMonitoredItemsResponse.Status = Status.ToV2ItemStatusArray();
					}
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "DeleteMonitoredItems caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					deleteMonitoredItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					deleteMonitoredItemsResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "DeleteMonitoredItems exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return deleteMonitoredItemsResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.GetMonitoredItemsResponse GetMonitoredItems(ArchestrAServices.ASBIDataV2Contract.GetMonitoredItemsRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "GetMonitoredItems entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.GetMonitoredItemsResponse getMonitoredItemsResponse = new ArchestrAServices.ASBIDataV2Contract.GetMonitoredItemsResponse();
		getMonitoredItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					getMonitoredItemsResponse.Items = null;
					getMonitoredItemsResponse.Result = connectionImplementation.GetMonitoredItems(out var Items, id, request.SubscriptionId);
					if (Items != null)
					{
						getMonitoredItemsResponse.Items = Items.ToV2MonitoredItemArray();
					}
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "GetMonitoredItems caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					getMonitoredItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					getMonitoredItemsResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "GetMonitoredItems exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return getMonitoredItemsResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.PublishResponse Publish(ArchestrAServices.ASBIDataV2Contract.PublishRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "Publish entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.PublishResponse publishResponse = new ArchestrAServices.ASBIDataV2Contract.PublishResponse();
		publishResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "Publish validated request");
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					publishResponse.Status = null;
					publishResponse.Values = null;
					publishResponse.Result = connectionImplementation.Publish(out var Status, out var Values, id, request.SubscriptionId);
					if (Status != null)
					{
						publishResponse.Status = Status.ToV2ItemStatusArray();
					}
					if (Values != null)
					{
						publishResponse.Values = Values.ToV2MonitoredItemValueArray();
					}
					SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "Publish found implementation, called user code with error {0}, {1} Statuses, {2} Values", publishResponse.Result.ErrorCode, (Status != null) ? Status.Length : 0, (Values != null) ? Values.Length : 0);
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "Publish caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					publishResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					publishResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
			else
			{
				SvcTrace.DiagException.TraceEvent(TraceEventType.Warning, 0, "Publish could not find implementation for ConnectionId {0}", request.ConnectionValidator.ConnectionId);
			}
		}
		else
		{
			SvcTrace.DiagException.TraceEvent(TraceEventType.Warning, 0, "Publish did not validate request for ConnectionId {0}", request.ConnectionValidator.ConnectionId);
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "Publish exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return publishResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.RegisterItemsResponse RegisterItems(ArchestrAServices.ASBIDataV2Contract.RegisterItemsRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "RegisterItems entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.RegisterItemsResponse registerItemsResponse = new ArchestrAServices.ASBIDataV2Contract.RegisterItemsResponse();
		registerItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null)
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "RegisterItems found authenticator from connection Id");
		}
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "RegisterItems authenticator validated request message");
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "RegisterItems calling implementation");
					ItemIdentity[] items = null;
					if (request.Items != null)
					{
						items = request.Items.ToV1ItemIdentityArray();
					}
					registerItemsResponse.Result = connectionImplementation.RegisterItems(out var Status, out var ItemCapabilities, id, items, (byte)(request.RequireId ? 1 : 0), (byte)(request.RegisterOnly ? 1 : 0));
					if (Status != null)
					{
						registerItemsResponse.Status = Status.ToV2ItemStatusArray();
					}
					else
					{
						registerItemsResponse.Status = null;
					}
					if (ItemCapabilities != null)
					{
						registerItemsResponse.ItemCapabilities = ItemCapabilities.ToV2ItemRegistrationArray();
					}
					else
					{
						registerItemsResponse.ItemCapabilities = null;
					}
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "RegisterItems caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					registerItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					registerItemsResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "RegisterItems exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return registerItemsResponse;
	}

	public virtual ArchestrAServices.ASBIDataV2Contract.UnregisterItemsResponse UnregisterItems(ArchestrAServices.ASBIDataV2Contract.UnregisterItemsRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "UnregisterItems entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ArchestrAServices.ASBIDataV2Contract.UnregisterItemsResponse unregisterItemsResponse = new ArchestrAServices.ASBIDataV2Contract.UnregisterItemsResponse();
		unregisterItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
		SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
		if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
		{
			bool flag = false;
			implementationLock.EnterReadLock();
			ConnectionContext value;
			try
			{
				flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
			}
			finally
			{
				implementationLock.ExitReadLock();
			}
			if (flag)
			{
				value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
				ConnectionId id = new ConnectionId
				{
					Id = serviceAuthenticator.connectionID
				};
				IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
				try
				{
					ItemIdentity[] items = null;
					if (request.Items != null)
					{
						items = request.Items.ToV1ItemIdentityArray();
					}
					unregisterItemsResponse.Result = connectionImplementation.UnregisterItems(out var Status, id, items);
					unregisterItemsResponse.Status = Status.ToV2ItemStatusArray();
				}
				catch (Exception ex)
				{
					SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "UnregisterItems caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
					if (ex.InnerException != null)
					{
						SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "   {0}", ex.InnerException.Message);
					}
					unregisterItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
					unregisterItemsResponse.Result.ErrorMessages = new string[1] { ex.Message };
				}
			}
		}
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "UnregisterItems exit Id =", request.ConnectionValidator.ConnectionId.ToString());
		return unregisterItemsResponse;
	}

	public bool ForceDisconnect()
	{
		return true;
	}
}