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

namespace ArchestrAServices.ASBContract;

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

		public IData ConnectionImplementation;

		public Timer ConnectionKeepaliveTimer;

		private ConnectionContext()
		{
		}

		public ConnectionContext(IContextChannel Channel, IData 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 IData GetImplementation()
	{
		return null;
	}

	public ASBIDataShim()
	{
	}

	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
			};
			IData 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;
		}
		IData 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
				};
				IData 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 ReadResponse Read(ReadRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "Read entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ReadResponse readResponse = new 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
				};
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					ItemStatus[] Status = null;
					RuntimeValue[] Values = null;
					readResponse.Result = connectionImplementation.Read(out Status, out Values, id, request.Items);
					readResponse.Status = Status;
					readResponse.Values = Values;
				}
				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 WriteResponse Write(WriteBasicRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "Write entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		WriteResponse writeResponse = new 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
				};
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					writeResponse.Result = connectionImplementation.Write(out var Status, id, request.Items, request.Values, request.WriteHandle);
					writeResponse.Status = Status;
				}
				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 WriteUserResponse WriteUser(WriteUserRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteUser entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		WriteUserResponse writeUserResponse = new 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);
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					writeUserResponse.Result = connectionImplementation.WriteUser(out var Status, id, request.Items, request.Values, request.User, request.WriteHandle);
					writeUserResponse.Status = Status;
				}
				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 WriteVerifiedResponse WriteVerified(WriteVerifiedRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteVerified entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		WriteVerifiedResponse writeVerifiedResponse = new 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
				};
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					writeVerifiedResponse.Result = connectionImplementation.WriteVerified(out var Status, id, request.Items, request.Values, request.User, request.Supervisor, request.WriteHandle);
					writeVerifiedResponse.Status = Status;
				}
				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 WriteSecuredResponse WriteSecured(WriteSecuredRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteSecured entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		WriteSecuredResponse writeSecuredResponse = new 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
				};
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					writeSecuredResponse.Result = connectionImplementation.WriteSecured(out var Status, id, request.Items, request.Values, request.User, request.WriteHandle);
					writeSecuredResponse.Status = Status;
				}
				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 WriteConfirmedResponse WriteConfirmed(WriteConfirmedRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteConfirmed entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		WriteConfirmedResponse writeConfirmedResponse = new 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
				};
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					writeConfirmedResponse.Result = connectionImplementation.WriteConfirmed(out var ValueReceived, out var WriteToken, id, request.Item, request.Value, request.User, request.Supervisor);
					writeConfirmedResponse.ValueReceived = ValueReceived;
					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 ConfirmWriteResponse ConfirmWrite(ConfirmWriteRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "ConfirmWrite entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		ConfirmWriteResponse confirmWriteResponse = new 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
				};
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					confirmWriteResponse.Result = connectionImplementation.ConfirmWrite(id, request.Item, request.WriteToken, request.Value, request.User, request.Supervisor, 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 PublishWriteCompleteResponse PublishWriteComplete(PublishWriteCompleteRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "PublishWriteComplete entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		PublishWriteCompleteResponse publishWriteCompleteResponse = new 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
				};
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					publishWriteCompleteResponse.Result = connectionImplementation.PublishWriteComplete(out var CompleteWrites, id);
					publishWriteCompleteResponse.CompleteWrites = CompleteWrites;
				}
				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 CreateSubscriptionResponse CreateSubscription(CreateSubscriptionRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "CreateSubscription entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		CreateSubscriptionResponse createSubscriptionResponse = new 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
				};
				IData 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 SetSubscriptionStateResponse SetSubscriptionState(SetSubscriptionStateRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "SetSubscriptionState entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		SetSubscriptionStateResponse setSubscriptionStateResponse = new 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
				};
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					setSubscriptionStateResponse.Result = connectionImplementation.SetSubscriptionState(id, request.SubscriptionId, request.NewStateProperty, 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 GetSubscriptionStateResponse GetSubscriptionState(GetSubscriptionStateRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "GetSubscriptionState entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		GetSubscriptionStateResponse getSubscriptionStateResponse = new 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
				};
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					getSubscriptionStateResponse.Result = connectionImplementation.GetSubscriptionState(out var State, id, request.SubscriptionId, request.StateToGet);
					getSubscriptionStateResponse.StateProperty = State;
				}
				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 DeleteSubscriptionResponse DeleteSubscription(DeleteSubscriptionRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "DeleteSubscription entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		DeleteSubscriptionResponse deleteSubscriptionResponse = new 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
				};
				IData 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 AddMonitoredItemsResponse AddMonitoredItems(AddMonitoredItemsRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "AddMonitoredItems entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		AddMonitoredItemsResponse addMonitoredItemsResponse = new 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
				};
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					addMonitoredItemsResponse.Result = connectionImplementation.AddMonitoredItems(out var Status, out var ItemCapabilities, id, request.SubscriptionId, request.Items, (byte)(request.RequireId ? 1 : 0));
					addMonitoredItemsResponse.Status = Status;
					addMonitoredItemsResponse.ItemCapabilities = ItemCapabilities;
				}
				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 DeleteMonitoredItemsResponse DeleteMonitoredItems(DeleteMonitoredItemsRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "DeleteMonitoredItems entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		DeleteMonitoredItemsResponse deleteMonitoredItemsResponse = new 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
				};
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					deleteMonitoredItemsResponse.Result = connectionImplementation.DeleteMonitoredItems(out var Status, id, request.SubscriptionId, request.Items);
					deleteMonitoredItemsResponse.Status = Status;
				}
				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 GetMonitoredItemsResponse GetMonitoredItems(GetMonitoredItemsRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "GetMonitoredItems entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		GetMonitoredItemsResponse getMonitoredItemsResponse = new 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
				};
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					getMonitoredItemsResponse.Result = connectionImplementation.GetMonitoredItems(out var Items, id, request.SubscriptionId);
					getMonitoredItemsResponse.Items = Items;
				}
				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 PublishResponse Publish(PublishRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "Publish entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		PublishResponse publishResponse = new 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
				};
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					publishResponse.Result = connectionImplementation.Publish(out var Status, out var Values, id, request.SubscriptionId);
					publishResponse.Status = Status;
					publishResponse.Values = Values;
					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 RegisterItemsResponse RegisterItems(RegisterItemsRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "RegisterItems entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		RegisterItemsResponse registerItemsResponse = new 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
				};
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "RegisterItems calling implementation");
					registerItemsResponse.Result = connectionImplementation.RegisterItems(out var Status, out var ItemCapabilities, id, request.Items, (byte)(request.RequireId ? 1 : 0), (byte)(request.RegisterOnly ? 1 : 0));
					registerItemsResponse.Status = Status;
					registerItemsResponse.ItemCapabilities = ItemCapabilities;
				}
				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 UnregisterItemsResponse UnregisterItems(UnregisterItemsRequest request)
	{
		SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "UnregisterItems entry Id =", request.ConnectionValidator.ConnectionId.ToString());
		UnregisterItemsResponse unregisterItemsResponse = new 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
				};
				IData connectionImplementation = value.ConnectionImplementation;
				try
				{
					unregisterItemsResponse.Result = connectionImplementation.UnregisterItems(out var Status, id, request.Items);
					unregisterItemsResponse.Status = Status;
				}
				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;
	}
}