ControlPanel.cs

using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using OSDP.Net.Connections;
using OSDP.Net.Messages;
using OSDP.Net.Model.CommandData;
using OSDP.Net.Model.ReplyData;
using OSDP.Net.PanelCommands.DeviceDiscover;
using OSDP.Net.Tracing;
using CommunicationConfiguration = OSDP.Net.Model.CommandData.CommunicationConfiguration;
using DeviceCapabilities = OSDP.Net.Model.ReplyData.DeviceCapabilities;
using ExtendedRead = OSDP.Net.Model.ReplyData.ExtendedRead;
using ManufacturerSpecific = OSDP.Net.Model.ReplyData.ManufacturerSpecific;
 
namespace OSDP.Net
{
    public class ControlPanel
    {
        internal const byte ConfigurationAddress = 0x7f;
 
        private readonly object _lockBusCreation = new ();
        private readonly ConcurrentDictionary<Guid, Bus> _buses = new();
        private readonly ILogger<ControlPanel> _logger;
        private readonly BlockingCollection<ReplyTracker> _replies = new();
        private TimeSpan _replyResponseTimeout = TimeSpan.FromSeconds(8);
        private readonly ConcurrentDictionary<int, SemaphoreSlim> _requestLocks = new();
        private readonly TimeSpan _timeToWaitToCheckOnData = TimeSpan.FromMilliseconds(10);
        private readonly IDeviceProxyFactory _deviceProxyFactory;
        private CancellationTokenSource _shutdownCts = new();
        private int _inFlightCommands;

        [Obsolete("Sending a ILogger is deprecated, please send ILoggerFactory instead.")]
        public ControlPanel(ILogger<ControlPanel> logger) : this(null, null, logger) { }

        public ControlPanel(ILoggerFactory loggerFactory = null) : this(null, loggerFactory, null) { }
 
        internal ControlPanel(IDeviceProxyFactory deviceProxyFactory, ILoggerFactory loggerFactory = null)
            : this(deviceProxyFactory, loggerFactory, null) { }
 
        private ControlPanel(IDeviceProxyFactory deviceProxyFactory, ILoggerFactory loggerFactory,
            ILogger<ControlPanel> logger)
        {
            _logger = logger
                      ?? loggerFactory?.CreateLogger<ControlPanel>()
                      ?? NullLoggerFactory.Instance.CreateLogger<ControlPanel>();
            _deviceProxyFactory = deviceProxyFactory ?? new DeviceProxyFactory();
 
            Task.Factory.StartNew(() =>
            {
                foreach (var reply in _replies.GetConsumingEnumerable())
                {
                    OnReplyReceived(reply);
                }
            }, TaskCreationOptions.LongRunning);
        }

        public Guid StartConnection(IOsdpConnection connection) => StartConnection(connection, Bus.DefaultPollInterval);

        public Guid StartConnection(IOsdpConnection connection, TimeSpan pollInterval, bool isTracing) =>
            StartConnection(connection, pollInterval, isTracing ? OSDPFileCaptureTracer.Trace : _ => { });

        public Guid StartConnection(IOsdpConnection connection, TimeSpan pollInterval) =>
            StartConnection(connection, pollInterval, _ => { });

        public Guid StartConnection(IOsdpConnection connection, TimeSpan pollInterval, Action<TraceEntry> tracer)
        {
            var newBus = CreateBus(connection, pollInterval, tracer);
            newBus.ConnectionStatusChanged += BusOnConnectionStatusChanged;
            newBus.StartPolling();
            return newBus.Id;
        }

        private Bus CreateBus(IOsdpConnection connection, TimeSpan pollInterval, Action<TraceEntry> tracer)
        {
            // Lock while we check/create the bus. This is a very quick operation, so the lock is not a performance problem.
            lock (_lockBusCreation)
            {
                var existingBusWithThisConnection = _buses.Values
                    .FirstOrDefault(bus => bus.Connection == connection);
                if (existingBusWithThisConnection != null)
                    throw new InvalidOperationException(
                        $"The IOsdpConnection is already active in connection {existingBusWithThisConnection.Id}. " +
                        "That connection must be stopped before starting a new one.");
 
                var newBus = new Bus(
                    connection,
                    _replies,
                    pollInterval,
                    tracer,
                    _deviceProxyFactory,
                    _logger);
 
                _buses[newBus.Id] = newBus;
                return newBus;
            }
        }

        public async Task StopConnection(Guid connectionId)
        {
            if (!_buses.TryGetValue(connectionId, out Bus bus))
            {
                return;
            }
 
            // At this point, there might be multiple threads running concurrently trying to stop the connection.
            // No worries, the method is reentrant. All threads will complete safely.
 
            bus.ConnectionStatusChanged -= BusOnConnectionStatusChanged;
            await bus.Close().ConfigureAwait(false);
 
            foreach (byte address in bus.ConfigureDeviceAddresses)
            {
                // This will fire twice if two threads call StopConnection for the same connection simultaneously.
                OnConnectionStatusChanged(bus.Id, address, false, false);
                _requestLocks.TryRemove(new { connectionId, address }.GetHashCode(), out _);
            }
            bus.Dispose();
            _buses.TryRemove(connectionId, out bus);
        }
 
        private void BusOnConnectionStatusChanged(object sender, Bus.ConnectionStatusEventArgs eventArgs)
        {
            if (sender is Bus bus)
                OnConnectionStatusChanged(bus.Id, eventArgs.Address, eventArgs.IsConnected,
                    eventArgs.IsSecureSessionEstablished);
        }

        public async Task SendCustomCommand(Guid connectionId, byte address, CommandData command)
        {
            await SendCommand(connectionId, address, command).ConfigureAwait(false);
        }

        public void EnqueueCustomCommand(Guid connectionId, byte address, CommandData command)
        {
            if (!_buses.TryGetValue(connectionId, out var bus))
            {
                throw new ArgumentException("Connection could not be found", nameof(connectionId));
            }
 
            bus.SendCommand(address, command);
        }

        public async Task<DeviceIdentification> IdReport(Guid connectionId, byte address) =>
            await IdReport(connectionId, address, CancellationToken.None).ConfigureAwait(false);

        public async Task<DeviceIdentification> IdReport(Guid connectionId, byte address, CancellationToken cancellationToken)
        {
            var message = await SendCommand(
                connectionId,
                address,
                new IdReport(),
                cancellationToken).ConfigureAwait(false);
 
            return DeviceIdentification.ParseData(message.Payload);
        }

        public async Task<ExtendedDeviceIdentification> ExtendedIdReport(Guid connectionId, byte address,
            TimeSpan timeout, CancellationToken cancellationToken = default)
        {
            using var scope = await BeginCommandAsync(connectionId, address, timeout, cancellationToken);
            return await WaitForExtendedIdData(connectionId, address, timeout, scope.Token);
        }
 
        private async Task<T> WaitForMultiPartData<T>(
            Guid connectionId,
            byte address,
            TimeSpan timeout,
            CommandData command,
            Func<byte[], T> parser,
            Action<EventHandler<MultiPartMessageDataReplyEventArgs>> subscribe,
            Action<EventHandler<MultiPartMessageDataReplyEventArgs>> unsubscribe,
            CancellationToken cancellationToken)
        {
            bool complete = false;
            byte[] data = null;
 
            void Handler(object sender, MultiPartMessageDataReplyEventArgs args)
            {
                // Only process matching replies
                if (args.ConnectionId != connectionId || args.Address != address) return;
 
                var fragment = args.DataFragmentResponse;
                data ??= new byte[fragment.WholeMessageLength];
 
                complete = Message.BuildMultiPartMessageData(fragment.WholeMessageLength, fragment.Offset,
                    fragment.LengthOfFragment, fragment.Data, data);
            }
 
            subscribe(Handler);
            SetReceivingMultipartMessaging(connectionId, address, true);
 
            try
            {
                await SendCommand(connectionId, address, command, cancellationToken, throwOnNak: false)
                    .ConfigureAwait(false);
 
                DateTime endTime = DateTime.UtcNow + timeout;
 
                while (DateTime.UtcNow <= endTime)
                {
                    if (complete)
                    {
                        return parser(data);
                    }
 
                    await Task.Delay(_timeToWaitToCheckOnData, cancellationToken);
                }
 
                throw new TimeoutException("Timeout waiting to receive multi-part data.");
            }
            finally
            {
                unsubscribe(Handler);
                SetReceivingMultipartMessaging(connectionId, address, false);
            }
        }
 
        private async Task<ExtendedDeviceIdentification> WaitForExtendedIdData(Guid connectionId, byte address,
            TimeSpan timeout, CancellationToken cancellationToken)
        {
            return await WaitForMultiPartData(
                connectionId,
                address,
                timeout,
                new IdReport(requestExtended: true),
                data => ExtendedDeviceIdentification.ParseData(data),
                handler => ExtendedIdReplyReceived += handler,
                handler => ExtendedIdReplyReceived -= handler,
                cancellationToken).ConfigureAwait(false);
        }

        public async Task<DeviceCapabilities> DeviceCapabilities(Guid connectionId, byte address)
        {
            return Model.ReplyData.DeviceCapabilities.ParseData((await SendCommand(
                connectionId,
                address,
                new Model.CommandData.DeviceCapabilities()).ConfigureAwait(false)).Payload);
        }

        public async Task<LocalStatus> LocalStatus(Guid connectionId, byte address)
        {
            return Model.ReplyData.LocalStatus.ParseData((await SendCommand(
                connectionId,
                address,
                new NoPayloadCommandData(CommandType.LocalStatus)).ConfigureAwait(false)).Payload);
        }

        public async Task<InputStatus> InputStatus(Guid connectionId, byte address)
        {
            return Model.ReplyData.InputStatus.ParseData((await SendCommand(
                connectionId,
                address,
                new NoPayloadCommandData(CommandType.InputStatus)).ConfigureAwait(false)).Payload);
        }

        public async Task<OutputStatus> OutputStatus(Guid connectionId, byte address)
        {
            return Model.ReplyData.OutputStatus.ParseData((await SendCommand(
                connectionId,
                address,
                new NoPayloadCommandData(CommandType.OutputStatus)).ConfigureAwait(false)).Payload);
        }

        public async Task<byte[]> GetPIVData(Guid connectionId, byte address, GetPIVData getPIVData, TimeSpan timeout,
            CancellationToken cancellationToken = default)
        {
            using var scope = await BeginCommandAsync(connectionId, address, timeout, cancellationToken);
            return await WaitForPIVData(connectionId, address, getPIVData, timeout, scope.Token);
        }
 
        private SemaphoreSlim GetRequestLock(Guid connectionId, byte address)
        {
            int hash = new { connectionId, address }.GetHashCode();
 
            if (_requestLocks.TryGetValue(hash, out var requestLock))
            {
                return requestLock;
            }
 
            var newRequestLock = new SemaphoreSlim(1, 1);
            _requestLocks[hash] = newRequestLock;
            return newRequestLock;
        }
 
        private async Task<CommandScope> BeginCommandAsync(Guid connectionId, byte address, TimeSpan timeout,
            CancellationToken cancellationToken)
        {
            var linkedCts =
                CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _shutdownCts.Token);
            Interlocked.Increment(ref _inFlightCommands);
            try
            {
                var requestLock = GetRequestLock(connectionId, address);
                if (!await requestLock.WaitAsync(timeout, linkedCts.Token).ConfigureAwait(false))
                {
                    throw new TimeoutException("Timeout waiting for another request to complete.");
                }
                return new CommandScope(this, requestLock, linkedCts);
            }
            catch
            {
                linkedCts.Dispose();
                Interlocked.Decrement(ref _inFlightCommands);
                throw;
            }
        }
 
        private sealed class CommandScope : IDisposable
        {
            private readonly ControlPanel _owner;
            private readonly SemaphoreSlim _requestLock;
            private readonly CancellationTokenSource _linkedCts;
 
            public CommandScope(ControlPanel owner, SemaphoreSlim requestLock, CancellationTokenSource linkedCts)
            {
                _owner = owner;
                _requestLock = requestLock;
                _linkedCts = linkedCts;
            }
 
            public CancellationToken Token => _linkedCts.Token;
 
            public void Dispose()
            {
                _requestLock.Release();
                _linkedCts.Dispose();
                Interlocked.Decrement(ref _owner._inFlightCommands);
            }
        }
 
        private async Task<byte[]> WaitForPIVData(Guid connectionId, byte address, GetPIVData getPIVData, TimeSpan timeout,
            CancellationToken cancellationToken)
        {
            return await WaitForMultiPartData(
                connectionId,
                address,
                timeout,
                getPIVData,
                data => data,
                handler => PIVDataReplyReceived += handler,
                handler => PIVDataReplyReceived -= handler,
                cancellationToken).ConfigureAwait(false);
        }

        public async Task<ReaderStatus> ReaderStatus(Guid connectionId, byte address)
        {
            return Model.ReplyData.ReaderStatus.ParseData((await SendCommand(connectionId, address,
                new NoPayloadCommandData(CommandType.ReaderStatus)).ConfigureAwait(false)).Payload);
        }

        public async Task<ReturnReplyData<ManufacturerSpecific>> ManufacturerSpecificCommand(Guid connectionId,
            byte address,
            Model.CommandData.ManufacturerSpecific manufacturerSpecific)
        {
            var reply = await SendCommand(connectionId, address, manufacturerSpecific).ConfigureAwait(false);
 
            return new ReturnReplyData<ManufacturerSpecific>
            {
                Ack = reply.Type == (byte)ReplyType.Ack,
                ReplyData = reply.Type == (byte)ReplyType.ManufactureSpecific
                    ? ManufacturerSpecific.ParseData(reply.Payload)
                    : null
            };
        }

        public async Task<ReturnReplyData<ExtendedRead>> ExtendedWriteData(Guid connectionId, byte address,
            ExtendedWrite extendedWrite)
        {
            var reply = await SendCommand(connectionId, address, extendedWrite).ConfigureAwait(false);
 
            return new ReturnReplyData<ExtendedRead>
            {
                Ack = reply.Type == (byte)ReplyType.Ack,
                ReplyData = reply.Type == (byte)ReplyType.ExtendedRead
                    ? ExtendedRead.ParseData(reply.Payload)
                    : null
            };
        }

        public async Task<ReturnReplyData<ManufacturerSpecific>> ManufacturerSpecificCommand(Guid connectionId, byte address,
            Model.CommandData.ManufacturerSpecific manufacturerSpecific, ushort maximumFragmentSize, TimeSpan timeout,
            CancellationToken cancellationToken = default)
        {
            using var scope = await BeginCommandAsync(connectionId, address, timeout, cancellationToken);
            return await WaitForManufactureResponse(connectionId, address, manufacturerSpecific, maximumFragmentSize,
                scope.Token);
        }
 
        private async Task<ReturnReplyData<ManufacturerSpecific>> WaitForManufactureResponse(Guid connectionId, byte address,
            Model.CommandData.ManufacturerSpecific manufacturerSpecific, ushort maximumFragmentSize, CancellationToken cancellationToken)
        {
            SetReceivingMultipartMessaging(connectionId, address, true);
 
            var manufactureCommandCode = manufacturerSpecific.Data.Skip(0).Take(1).ToArray();
            var manufactureCommandData = manufacturerSpecific.Data.Skip(1).ToArray();
            ushort totalSize = (ushort)manufactureCommandData.Length;
            ushort offset = 0;
            bool continueTransfer = true;
            IncomingMessage reply = null;
 
            try
            {
                while (!cancellationToken.IsCancellationRequested && continueTransfer)
                {
                    ushort fragmentSize = (ushort)Math.Min(maximumFragmentSize, totalSize - offset);
                    reply = await SendCommand(connectionId, address, new Model.CommandData.ManufacturerSpecific(
                            manufacturerSpecific.VendorCode, manufactureCommandCode.Concat(
                                new MessageDataFragment(totalSize, offset, fragmentSize,
                                        manufactureCommandData.Skip(offset).Take(fragmentSize).ToArray(), 
                                        MessageDataFragmentFieldSize.FourBytes).BuildData()
                                    .ToArray()).ToArray()), cancellationToken)
                        .ConfigureAwait(false);
 
                    if (reply.Type != (byte)ReplyType.Ack) break;
 
                    offset += maximumFragmentSize;
 
                    // Determine if we should continue on successful status
                    continueTransfer = offset < totalSize;
                }
 
                if (reply == null)
                {
                    throw new Exception("Command didn't return a valid reply");
                }
                
                return new ReturnReplyData<ManufacturerSpecific>
                {
                    Ack = reply.Type == (byte)ReplyType.Ack,
                    ReplyData = reply.Type == (byte)ReplyType.ManufactureSpecific ? ManufacturerSpecific.ParseData(reply.Payload) : null
                };
            }
            finally
            {
                SetReceivingMultipartMessaging(connectionId, address, false);
            }
        }

        public async Task<ReturnReplyData<OutputStatus>> OutputControl(Guid connectionId, byte address,
            OutputControls outputControls)
        {
            var reply = await SendCommand(connectionId, address, outputControls).ConfigureAwait(false);
 
            return new ReturnReplyData<OutputStatus>
            {
                Ack = reply.Type == (byte)ReplyType.Ack,
                ReplyData = reply.Type == (byte)ReplyType.OutputStatusReport
                    ? Model.ReplyData.OutputStatus.ParseData(reply.Payload)
                    : null
            };
        }

        public async Task<bool> ReaderLedControl(Guid connectionId, byte address, ReaderLedControls readerLedControls)
        {
            var reply = await SendCommand(connectionId, address, readerLedControls).ConfigureAwait(false);
 
            return reply.Type == (byte)ReplyType.Ack;
        }

        public async Task<bool> ReaderBuzzerControl(Guid connectionId, byte address,
            ReaderBuzzerControl readerBuzzerControl)
        {
            var reply = await SendCommand(connectionId, address, readerBuzzerControl).ConfigureAwait(false);
 
            return reply.Type == (byte)ReplyType.Ack;
        }

        public async Task<bool> ReaderTextOutput(Guid connectionId, byte address, ReaderTextOutput readerTextOutput)
        {
            var reply = await SendCommand(connectionId, address, readerTextOutput).ConfigureAwait(false);
            
            return reply.Type == (byte)ReplyType.Ack;
        }

        public async Task<Model.ReplyData.CommunicationConfiguration> CommunicationConfiguration(Guid connectionId,
            byte address, CommunicationConfiguration communicationConfiguration)
        {
            if (_buses.Any(bus =>
                    bus.Key == connectionId &&
                    address != communicationConfiguration.Address &&
                    bus.Value.ConfigureDeviceAddresses.Any(configuredAddress =>
                        configuredAddress == communicationConfiguration.Address)))
            {
                throw new Exception("Address is already configured on the bus.");
            }
 
            return Model.ReplyData.CommunicationConfiguration.ParseData(
                (await SendCommand(connectionId, address, communicationConfiguration).ConfigureAwait(false))
                .Payload);
        }

        public async Task<bool> EncryptionKeySet(Guid connectionId, byte address,
            EncryptionKeyConfiguration encryptionKeyConfiguration)
        {
            var reply = await SendCommand(connectionId, address, encryptionKeyConfiguration).ConfigureAwait(false);
 
            return reply.Type == (byte)ReplyType.Ack;
        }

        public Task<Model.ReplyData.FileTransferStatus.StatusDetail> FileTransfer(Guid connectionId, byte address, byte fileType, byte[] fileData, ushort fragmentSize,
            Action<FileTransferStatus> callback, CancellationToken cancellationToken = default)
        {
            var bus = _buses[connectionId];
            return Task.Run(async () =>
            {
                bus.SetSendingMultipartMessage(address, true);
                try
                {
                    return await SendFileTransferCommands(connectionId, address, fileType, fileData, fragmentSize, callback,
                        cancellationToken);
                }
                finally
                {
                    bus.SetSendingMultipartMessage(address, false);
                    bus.SetSendingMultiMessageNoSecureChannel(address, false);
                }
            }, cancellationToken);
        }
 
        private async Task<Model.ReplyData.FileTransferStatus.StatusDetail> SendFileTransferCommands(Guid connectionId,
            byte address, byte fileType, byte[] fileData,
            ushort fragmentSize, Action<FileTransferStatus> callback, CancellationToken cancellationToken)
        {
            int totalSize = fileData.Length;
            int offset = 0;
            bool isFirstMessage = true;
 
            // Keep going until
            // * operation's cancelled
            // * an error occurs
            // * transfer's completed
            while (true)
            {
                cancellationToken.ThrowIfCancellationRequested();
 
                // Get the fragment size if it doesn't exceed the total size
                var nextFragmentSize = (ushort)Math.Min(fragmentSize, totalSize - offset);
 
                var reply = await SendCommand(connectionId, address,
            new FileTransferFragment(fileType,
                new MessageDataFragment(totalSize, offset, nextFragmentSize,
                    fileData.Skip(offset).Take(nextFragmentSize).ToArray(), 
                    MessageDataFragmentFieldSize.FourBytes)),
                        cancellationToken, throwOnNak: false)
                    .ConfigureAwait(false);
 
                // On the first message, calculate the proper fragment size based on whether encryption is being used
                if (isFirstMessage)
                {
                    isFirstMessage = false;
                    fragmentSize = Message.CalculateMaximumMessageSize(fragmentSize, reply.IsSecureMessage);
                }
 
                // Update offset
                offset += nextFragmentSize;
 
                // Parse the fileTransfer status
                var fileTransferStatusReply = reply.Type == (byte)ReplyType.FileTransferStatus
                    ? Model.ReplyData.FileTransferStatus.ParseData(reply.Payload)
                    : null;
 
                // Check reply to see if PD has requested some change in com procedures.
                if (fileTransferStatusReply != null)
                {
                    // Leave the secure channel if needed
                    if ((fileTransferStatusReply.Action &
                         Model.ReplyData.FileTransferStatus.ControlFlags.LeaveSecureChannel) ==
                        Model.ReplyData.FileTransferStatus.ControlFlags.LeaveSecureChannel)
                    {
                        _buses[connectionId].SetSendingMultiMessageNoSecureChannel(address, true);
                    }
 
                    // Set request delay if specified
                    if (fileTransferStatusReply is { RequestedDelay: > 0 })
                    {
                        _buses[connectionId].SetRequestDelay(address,
                            DateTime.UtcNow.AddMilliseconds(fileTransferStatusReply.RequestedDelay));
                    }
 
                    // Set fragment size if requested
                    if (fileTransferStatusReply is { UpdateMessageMaximum: > 0 })
                    {
                        fragmentSize = Message.CalculateMaximumMessageSize(fileTransferStatusReply.UpdateMessageMaximum,
                            reply.IsSecureMessage);
                    }
                }
 
                var status = new FileTransferStatus(
                    fileTransferStatusReply?.Detail ?? Model.ReplyData.FileTransferStatus.StatusDetail.UnknownError,
                    offset,
                    reply.Type == (byte)ReplyType.Nak ? Nak.ParseData(reply.Payload) : null);
 
                // Report status to progress listeners
                callback(status);
 
                switch (status.Status)
                {
                    // Abort transfer on error.
                    case < 0:
                        throw new FileTransferException("File transfer failed", status);
                    // File transfer is completed, but PD wants us to keep sending "idling" file transfer message (FtFragmentSize = 0) until we receive another status.
                    case Model.ReplyData.FileTransferStatus.StatusDetail.FinishingFileTransfer:
                        fragmentSize = 0;
                        break;
                    default:
                    {
                        if (offset >= totalSize)
                        {
                            // We're done. Return the last successful (=positive) status code.
                            return status.Status;
                        }
 
                        break;
                    }
                }
            }
        }

        public async Task<BiometricReadResult> ScanAndSendBiometricData(Guid connectionId, byte address,
            BiometricReadData biometricReadData, TimeSpan timeout,
            CancellationToken cancellationToken = default)
        {
            using var scope = await BeginCommandAsync(connectionId, address, timeout, cancellationToken);
            return await WaitForBiometricRead(connectionId, address, biometricReadData, timeout, scope.Token);
        }
 
        private async Task<BiometricReadResult> WaitForBiometricRead(Guid connectionId, byte address,
            BiometricReadData biometricReadData, TimeSpan timeout,
            CancellationToken cancellationToken)
        {
            bool complete = false;
            BiometricReadResult result = null;
 
            void Handler(object sender, BiometricReadResultsReplyEventArgs args)
            {
                // Only process matching replies
                if (args.ConnectionId != connectionId || args.Address != address) return;
 
                complete = true;
 
                result = args.BiometricReadResult;
            }
 
            BiometricReadResultsReplyReceived += Handler;
            SetReceivingMultipartMessaging(connectionId, address, true);
 
            try
            {
                await SendCommand(connectionId, address, biometricReadData, cancellationToken, throwOnNak: false)
                    .ConfigureAwait(false);
 
                DateTime endTime = DateTime.UtcNow + timeout;
 
                while (DateTime.UtcNow <= endTime)
                {
                    if (complete)
                    {
                        return result;
                    }
 
                    await Task.Delay(_timeToWaitToCheckOnData, cancellationToken);
                }
 
                throw new TimeoutException("Timeout waiting to for biometric read data.");
            }
            finally
            {
                BiometricReadResultsReplyReceived -= Handler;
                SetReceivingMultipartMessaging(connectionId, address, false);
            }
        }
 

        public async Task<BiometricMatchResult> ScanAndMatchBiometricTemplate(Guid connectionId, byte address,
            BiometricTemplateData biometricTemplateData, TimeSpan timeout,
            CancellationToken cancellationToken = default)
        {
            using var scope = await BeginCommandAsync(connectionId, address, timeout, cancellationToken);
            return await WaitForBiometricMatch(connectionId, address, biometricTemplateData, timeout, scope.Token);
        }
 
        private async Task<BiometricMatchResult> WaitForBiometricMatch(Guid connectionId, byte address,
            BiometricTemplateData biometricTemplateData, TimeSpan timeout,
            CancellationToken cancellationToken)
        {
            bool complete = false;
            BiometricMatchResult result = null;
 
            void Handler(object sender, BiometricMatchReplyEventArgs args)
            {
                // Only process matching replies
                if (args.ConnectionId != connectionId || args.Address != address) return;
 
                complete = true;
 
                result = args.BiometricMatchResult;
            }
 
            BiometricMatchReplyReceived += Handler;
            SetReceivingMultipartMessaging(connectionId, address, true);
 
            try
            {
                await SendCommand(connectionId, address, biometricTemplateData, cancellationToken, throwOnNak: false)
                    .ConfigureAwait(false);
 
                DateTime endTime = DateTime.UtcNow + timeout;
 
                while (DateTime.UtcNow <= endTime)
                {
                    if (complete)
                    {
                        return result;
                    }
 
                    await Task.Delay(_timeToWaitToCheckOnData, cancellationToken);
                }
 
                throw new TimeoutException("Timeout waiting to for biometric match.");
            }
            finally
            {
                BiometricMatchReplyReceived -= Handler;
                SetReceivingMultipartMessaging(connectionId, address, false);
            }
        }

        public async Task<byte[]> AuthenticationChallenge(Guid connectionId, byte address,
            byte algorithm, byte key, byte[] challenge, ushort maximumFragmentSize, TimeSpan timeout,
            CancellationToken cancellationToken = default)
        {
            using var scope = await BeginCommandAsync(connectionId, address, timeout, cancellationToken);
            return await WaitForChallengeResponse(connectionId, address, algorithm, key, challenge, maximumFragmentSize,
                timeout, scope.Token);
        }
 
        private async Task<byte[]> WaitForChallengeResponse(Guid connectionId, byte address, byte algorithm, byte key,
            byte[] challenge, ushort maximumFragmentSize, TimeSpan timeout,
            CancellationToken cancellationToken)
        {
            bool complete = false;
            var requestData = new List<byte> { algorithm, key };
            requestData.AddRange(challenge);
            byte[] responseData = null;
 
            void Handler(object sender, MultiPartMessageDataReplyEventArgs args)
            {
                // Only process matching replies
                if (args.ConnectionId != connectionId || args.Address != address) return;
 
                var dataFragmentResponse = args.DataFragmentResponse;
                responseData ??= new byte[dataFragmentResponse.WholeMessageLength];
 
                complete = Message.BuildMultiPartMessageData(dataFragmentResponse.WholeMessageLength, dataFragmentResponse.Offset,
                    dataFragmentResponse.LengthOfFragment, dataFragmentResponse.Data, responseData);
            }
 
            AuthenticationChallengeResponseReceived += Handler;
            SetReceivingMultipartMessaging(connectionId, address, true);    
            
            ushort totalSize = (ushort)requestData.Count;
            ushort offset = 0;
            bool continueTransfer = true;
 
            try
            {
                while (!cancellationToken.IsCancellationRequested && continueTransfer)
                {
                    ushort fragmentSize = (ushort)Math.Min(maximumFragmentSize, totalSize - offset);
                    await SendCommand(connectionId, address, new AuthenticationChallengeFragment(
                            new MessageDataFragment(totalSize, offset, fragmentSize,
                                requestData.Skip(offset).Take((ushort)Math.Min(fragmentSize, totalSize - offset))
                                    .ToArray(), 
                                MessageDataFragmentFieldSize.TwoBytes)), cancellationToken)
                        .ConfigureAwait(false);
 
                    offset += fragmentSize;
 
                    // Determine if we should continue on successful status
                    continueTransfer = offset < totalSize;
                }
 
                DateTime endTime = DateTime.UtcNow + timeout;
                
                while (DateTime.UtcNow <= endTime)
                {
                    if (complete)
                    {
                        return responseData;
                    }
                    
                    await Task.Delay(_timeToWaitToCheckOnData, cancellationToken);
                }
 
                throw new TimeoutException("Timeout waiting to receive challenge response.");
            }
            finally
            {
                AuthenticationChallengeResponseReceived -= Handler;
                SetReceivingMultipartMessaging(connectionId, address, false);
            }
        }

        public async Task<bool> ACUReceiveSize(Guid connectionId, byte address, ushort maximumReceiveSize)
        {
            var reply = await SendCommand(connectionId, address, new ACUReceiveSize(maximumReceiveSize))
                .ConfigureAwait(false);
 
            return reply.Type == (byte)ReplyType.Ack;
        }

        public async Task<bool> KeepReaderActive(Guid connectionId, byte address, ushort keepAliveTimeInMilliseconds)
        {
            var reply = await SendCommand(connectionId, address, new KeepReaderActive(keepAliveTimeInMilliseconds))
                .ConfigureAwait(false);
 
            return reply.Type == (byte)ReplyType.Ack;
        }

        public async Task<bool> AbortCurrentOperation(Guid connectionId, byte address)
        {
            var reply = await SendCommand(connectionId, address, new NoPayloadCommandData(CommandType.Abort))
                .ConfigureAwait(false);
 
            return reply.Type == (byte)ReplyType.Ack;
        }

        public bool IsOnline(Guid connectionId, byte address)
        {
            return _buses[connectionId].IsOnline(address);
        }
 
        private void SetReceivingMultipartMessaging(Guid connectionId, byte address, bool isReceivingMultipartMessaging)
        {
            if (!_buses.TryGetValue(connectionId, out var bus))
            {
                throw new ArgumentException("Connection could not be found", nameof(connectionId));
            }
            
            bus.SetReceivingMultipartMessage(address, isReceivingMultipartMessaging);
        }
        
        private async Task<IncomingMessage> SendCommand(Guid connectionId, byte address, CommandData command,
            CancellationToken cancellationToken = default, bool throwOnNak = true)
        {
            var source = new TaskCompletionSource<IncomingMessage>();
 
            void EventHandler(object sender, ReplyEventArgs replyEventArgs)
            {
                var reply = replyEventArgs.Reply;
                if (!reply.MatchIssuingCommand(address, command.Code)) return;
 
                if (throwOnNak && replyEventArgs.Reply.ReplyMessage.Type == (byte)ReplyType.Nak)
                {
                    source.SetException(new NackReplyException(Nak.ParseData(reply.ReplyMessage.Payload)));
                }
                else
                {
                    source.SetResult(reply.ReplyMessage);
                }
            }
 
            if (!_buses.TryGetValue(connectionId, out var bus))
            {
                throw new ArgumentException("Connection could not be found", nameof(connectionId));
            }
 
            ReplyReceived += EventHandler;
 
            try
            {
                bus.SendCommand(address, command);
 
                var task = await Task.WhenAny(
                    source.Task, Task.Delay(_replyResponseTimeout, cancellationToken)).ConfigureAwait(false);
 
                if (source.Task != task)
                {
                    throw task.IsCanceled 
                        ? new OperationCanceledException(cancellationToken)
                        : new TimeoutException();
                }
 
                return await source.Task;
            }
            finally
            {
                ReplyReceived -= EventHandler;
            }
        }

        public async Task Shutdown()
        {
            var shutdownCts = _shutdownCts;
            shutdownCts.Cancel();
 
            foreach (var bus in _buses.Values)
            {
                bus.ConnectionStatusChanged -= BusOnConnectionStatusChanged;
                await bus.Close().ConfigureAwait(false);
 
                foreach (byte address in bus.ConfigureDeviceAddresses)
                {
                    OnConnectionStatusChanged(bus.Id, address, false, false);
                }
                bus.Dispose();
            }
            _buses.Clear();
 
            while (Volatile.Read(ref _inFlightCommands) > 0)
            {
                await Task.Delay(_timeToWaitToCheckOnData).ConfigureAwait(false);
            }
 
            foreach (var requestLock in _requestLocks.Values)
            {
                requestLock.Dispose();
            }
            _requestLocks.Clear();
 
            _shutdownCts = new CancellationTokenSource();
            shutdownCts.Dispose();
 
            OSDPFileCaptureTracer.CloseAllWriters();
        }

        public void ResetDevice(Guid connectionId, int address)
        {
            if (_buses.TryGetValue(connectionId, out Bus bus))
            {
                bus.ResetDevice(address);
            }
        }

        public void AddDevice(Guid connectionId, byte address, bool useCrc, bool useSecureChannel, byte[] secureChannelKey = null)
        {
            if (!_buses.TryGetValue(connectionId, out Bus foundBus))
            {
                throw new ArgumentException("Connection could not be found", nameof(connectionId));
            }
 
            if (address > 127)
            {
                throw new ArgumentOutOfRangeException(nameof(address), "Address is out of range, it must between 0 and 127.");
            }
 
            foundBus.AddDevice(address, useCrc, useSecureChannel, useSecureChannel ? secureChannelKey : null);
        }

        public void RemoveDevice(Guid connectionId, byte address)
        {
            if (_buses.TryGetValue(connectionId, out Bus bus))
            {
                bus.RemoveDevice(address);
            }
        }

        public async Task<DiscoveryResult> DiscoverDevice(IEnumerable<IOsdpConnection> connections, DiscoveryOptions options = null)
        {
            options ??= new DiscoveryOptions();
            DiscoveryResult result = new();
            Guid connectionId = Guid.Empty;
 
            // ReSharper disable AccessToModifiedClosure
            // Disable the warning which doesn't apply to us as we are accumulating/modifying results of the discovery
            // in the above variables which are closed over. We are good with with
 
            void UpdateStatus(DiscoveryStatus status)
            {
                result.Status = status;
                options.ProgressCallback?.Invoke(result);
            }
 
            async Task<DeviceIdentification> TryIdReport(byte address)
            {
                try
                {
                    return await IdReport(connectionId, address, options.CancellationToken).ConfigureAwait(false);
                }
                catch (TimeoutException)
                {
                    return null;
                }
            }
 
            async Task<bool> FindConnectionWithActiveDevice()
            {
                bool isFirst = true;
 
                foreach (IOsdpConnection connection in connections)
                {
                    if (!isFirst)
                    {
                        await Task.Delay(options.ReconnectDelay, options.CancellationToken);
                    }
                    isFirst = false;
 
                    // WARNING: We are specifying zero timespan here so that Polling is
                    // DISABLED on this entire connection. If we don't do this, it seems
                    // non-existent devices will attempt to start polling and those commands
                    // ends up getting "stuck" so that even when we get to the valid device
                    // we'll end up timing out and not finding it :(
                    // Polling on "other" devices should be doing this, but there's something
                    // funky in there. If the device we are looking for happens to be at addr
                    // 0, everything will work, but anything else doesn't unless we disable
                    // polling
                    connectionId = StartConnection(connection, TimeSpan.Zero, options.Tracer ?? (_ => {}));
 
                    AddDevice(connectionId, ConfigurationAddress, true, false);
 
                    result.Connection = connection;
                    UpdateStatus(DiscoveryStatus.LookingForDeviceOnConnection);
 
                    var deviceIdentification = await TryIdReport(ConfigurationAddress).ConfigureAwait(false);
                    if (deviceIdentification != null)
                    {
                        result.Id = deviceIdentification;
                        RemoveDevice(connectionId, ConfigurationAddress);
                        await StopConnection(connectionId).ConfigureAwait(false);
                        UpdateStatus(DiscoveryStatus.ConnectionWithDeviceFound);
                        return true;
                    }
 
                    await StopConnection(connectionId).ConfigureAwait(false);
                }
 
                result.Connection = null;
                return false;
            }
 
            async Task<bool> FindDeviceAddress()
            {
                connectionId = StartConnection(result.Connection, TimeSpan.Zero, options.Tracer ?? (_ => {}));
                for (byte address = 0; address < ConfigurationAddress; address++)
                {
                    AddDevice(connectionId, address, true, false);
                    
                    result.Address = address;
                    UpdateStatus(DiscoveryStatus.LookingForDeviceAtAddress);
                    var deviceIdentification = await TryIdReport(address).ConfigureAwait(false);
 
                    if (deviceIdentification != null)
                    {
                        result.Id = deviceIdentification;
                        UpdateStatus(DiscoveryStatus.DeviceIdentified);
                        return true;
                    }
 
                    RemoveDevice(connectionId, address);
                }
                await StopConnection(connectionId).ConfigureAwait(false);
 
                // Since we didn't find a valid device, for an unexpected reason
                // let's just leave the at the configuration address
                result.Address = ConfigurationAddress;
                return false;
            }
 
            async Task CheckForDefaultSecurityKey()
            {
                var waitForSecureConnection = new TaskCompletionSource<bool>();
 
                void HandleStatusChange(object sender, ConnectionStatusEventArgs args)
                {
                    if (args.Address == result.Address && args.IsConnected && args.IsSecureChannelEstablished)
                    {
                        waitForSecureConnection.SetResult(true);
                    }
                }
 
                ConnectionStatusChanged += HandleStatusChange;
 
                try
                {
                    // Right now control panel API doesn't indicate connection errors due invalid credentials, even
                    // though internally the bus knows it got an error response from the device. Until underlying APIs give
                    // us that data, the best we can do here is wait for a successful connection and timeout when one 
                    // isn't established
                    connectionId = StartConnection(result.Connection, Bus.DefaultPollInterval,
                        options.Tracer ?? (_ => { }));
                    AddDevice(connectionId, result.Address, true, true);
 
                    using var waitForTask = await Task.WhenAny(waitForSecureConnection.Task,
                        Task.Delay(TimeSpan.FromSeconds(8), options.CancellationToken));
                    result.UsesDefaultSecurityKey = waitForTask == waitForSecureConnection.Task;
                }
                finally
                {
                    ConnectionStatusChanged -= HandleStatusChange;
                }
            }
 
            UpdateStatus(DiscoveryStatus.Started);
 
            // While we are doing discovery, we want to override default behavior which allows
            // underlying wire protocols to retry things if something goes wrong. In the
            // interests for time while cycling through every possible address, we are going to
            // not be as gracious
            var origResponseTimeout = _replyResponseTimeout;
            _replyResponseTimeout = options.ResponseTimeout;
 
            try
            {
                if (!_buses.IsEmpty)
                {
                    throw new ControlPanelInUseException();
                }
 
                if (!await FindConnectionWithActiveDevice().ConfigureAwait(false))
                {
                    UpdateStatus(DiscoveryStatus.DeviceNotFound);
                    return null;
                }
 
                if (!await FindDeviceAddress().ConfigureAwait(false))
                {
                    throw new DeviceDiscoveryException(
                        $"Unable to determine address of device that responded to a configuration address on baud rate {result.Connection.BaudRate}");
                }
 
                result.Capabilities = await DeviceCapabilities(connectionId, result.Address).ConfigureAwait(false);
                UpdateStatus(DiscoveryStatus.CapabilitiesDiscovered);
 
                // Connection above was opened intentionally with no polling (see above comments). Now we
                // need to open a new connection with polling before doing the next step
                await StopConnection(connectionId).ConfigureAwait(false);
                connectionId = Guid.Empty;
 
                await CheckForDefaultSecurityKey().ConfigureAwait(false);
 
                UpdateStatus(DiscoveryStatus.Succeeded);
                return result;
            }
            catch (Exception exception)
            {
                result.Error = exception;
                UpdateStatus(exception is OperationCanceledException 
                    ? DiscoveryStatus.Cancelled : DiscoveryStatus.Error);
                throw;
            }
            finally
            {
                if (connectionId != Guid.Empty) await StopConnection(connectionId).ConfigureAwait(false);
                _replyResponseTimeout = origResponseTimeout;
            }
 
            // ReSharper enable AccessToModifiedClosure
        }
 
        private void OnConnectionStatusChanged(Guid connectionId, byte address, bool isConnected,
            bool isSecureChannelEstablished)
        {
            ConnectionStatusChanged?.Invoke(this,
                new ConnectionStatusEventArgs(connectionId, address, isConnected, isSecureChannelEstablished));
        }
 
        private void OnReplyReceived(ReplyTracker reply)
        {
            // Not wrapped in try/catch: ReplyReceived is a private event whose subscribers are
            // internal SendCommand handlers. Exceptions must propagate back to callers via the
            // TaskCompletionSource so they receive the actual error instead of a timeout.
            ReplyReceived?.Invoke(this, new ReplyEventArgs { Reply = reply });
 
            try
            {
                switch ((ReplyType)reply.ReplyMessage.Type)
                {
                    case ReplyType.Nak:
                        NakReplyReceived?.Invoke(this,
                            new NakReplyEventArgs(reply.ConnectionId, reply.ReplyMessage.Address,
                                Nak.ParseData(reply.ReplyMessage.Payload)));
                        break;
                    case ReplyType.LocalStatusReport:
                        LocalStatusReportReplyReceived?.Invoke(this,
                            new LocalStatusReportReplyEventArgs(reply.ConnectionId,
                                reply.ReplyMessage.Address,
                                Model.ReplyData.LocalStatus.ParseData(reply.ReplyMessage.Payload)));
                        break;
                    case ReplyType.InputStatusReport:
                        InputStatusReportReplyReceived?.Invoke(this,
                            new InputStatusReportReplyEventArgs(reply.ConnectionId,
                                reply.ReplyMessage.Address,
                                Model.ReplyData.InputStatus.ParseData(reply.ReplyMessage.Payload)));
                        break;
                    case ReplyType.OutputStatusReport:
                        OutputStatusReportReplyReceived?.Invoke(this,
                            new OutputStatusReportReplyEventArgs(reply.ConnectionId,
                                reply.ReplyMessage.Address,
                                Model.ReplyData.OutputStatus.ParseData(reply.ReplyMessage.Payload)));
                        break;
                    case ReplyType.ReaderStatusReport:
                        ReaderStatusReportReplyReceived?.Invoke(this,
                            new ReaderStatusReportReplyEventArgs(reply.ConnectionId,
                                reply.ReplyMessage.Address,
                                Model.ReplyData.ReaderStatus.ParseData(reply.ReplyMessage.Payload)));
                        break;
                    case ReplyType.RawReaderData:
                        RawCardDataReplyReceived?.Invoke(this,
                            new RawCardDataReplyEventArgs(reply.ConnectionId,
                                reply.ReplyMessage.Address,
                                RawCardData.ParseData(reply.ReplyMessage.Payload)));
                        break;
                    case ReplyType.FormattedReaderData:
                        FormattedCardDataReplyReceived?.Invoke(this,
                            new FormattedCardDataReplyEventArgs(reply.ConnectionId,
                                reply.ReplyMessage.Address,
                                FormattedCardData.ParseData(reply.ReplyMessage.Payload)));
                        break;
                    case ReplyType.ManufactureSpecific:
                        ManufacturerSpecificReplyReceived?.Invoke(this,
                            new ManufacturerSpecificReplyEventArgs(reply.ConnectionId,
                                reply.ReplyMessage.Address,
                                ManufacturerSpecific.ParseData(reply.ReplyMessage.Payload)));
                        break;
                    case ReplyType.ExtendedRead:
                        ExtendedReadReplyReceived?.Invoke(this,
                            new ExtendedReadReplyEventArgs(reply.ConnectionId,
                                reply.ReplyMessage.Address,
                                ExtendedRead.ParseData(reply.ReplyMessage.Payload)));
                        break;
                    case ReplyType.PIVData:
                        PIVDataReplyReceived?.Invoke(this,
                            new MultiPartMessageDataReplyEventArgs(reply.ConnectionId,
                                reply.ReplyMessage.Address,
                                DataFragmentResponse.ParseData(reply.ReplyMessage.Payload)));
                        break;
                    case ReplyType.ExtendedPdIdReport:
                        ExtendedIdReplyReceived?.Invoke(this,
                            new MultiPartMessageDataReplyEventArgs(reply.ConnectionId,
                                reply.ReplyMessage.Address,
                                DataFragmentResponse.ParseData(reply.ReplyMessage.Payload)));
                        break;
                    case ReplyType.ResponseToChallenge:
                        AuthenticationChallengeResponseReceived?.Invoke(this,
                            new MultiPartMessageDataReplyEventArgs(reply.ConnectionId,
                                reply.ReplyMessage.Address,
                                DataFragmentResponse.ParseData(reply.ReplyMessage.Payload)));
                        break;
                    case ReplyType.KeypadData:
                        KeypadReplyReceived?.Invoke(this,
                            new KeypadReplyEventArgs(reply.ConnectionId, reply.ReplyMessage.Address,
                                KeypadData.ParseData(reply.ReplyMessage.Payload)));
                        break;
                    case ReplyType.BiometricData:
                        BiometricReadResultsReplyReceived?.Invoke(this,
                            new BiometricReadResultsReplyEventArgs(reply.ConnectionId,
                                reply.ReplyMessage.Address,
                                BiometricReadResult.ParseData(reply.ReplyMessage.Payload)));
                        break;
                    case ReplyType.BiometricMatchResult:
                        BiometricMatchReplyReceived?.Invoke(this,
                            new BiometricMatchReplyEventArgs(reply.ConnectionId,
                                reply.ReplyMessage.Address,
                                BiometricMatchResult.ParseData(reply.ReplyMessage.Payload)));
                        break;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "Error in typed reply event handler for reply {ReplyType} from address {Address}",
                    (ReplyType)reply.ReplyMessage.Type, reply.ReplyMessage.Address);
            }
 
            try
            {
                RawReplyReceived?.Invoke(this,
                    new RawReplyEventArgs(reply.ConnectionId, reply.ReplyMessage.Address,
                        reply.ReplyMessage.Type, reply.ReplyMessage.Payload));
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "Error in raw reply event handler for reply {ReplyType} from address {Address}",
                    (ReplyType)reply.ReplyMessage.Type, reply.ReplyMessage.Address);
            }
        }
 
        private event EventHandler<ReplyEventArgs> ReplyReceived;

        public event EventHandler<RawReplyEventArgs> RawReplyReceived;

        public event EventHandler<ConnectionStatusEventArgs> ConnectionStatusChanged;

        public event EventHandler<NakReplyEventArgs> NakReplyReceived;

        public event EventHandler<LocalStatusReportReplyEventArgs> LocalStatusReportReplyReceived;

        public event EventHandler<InputStatusReportReplyEventArgs> InputStatusReportReplyReceived;

        public event EventHandler<OutputStatusReportReplyEventArgs> OutputStatusReportReplyReceived;

        public event EventHandler<ReaderStatusReportReplyEventArgs> ReaderStatusReportReplyReceived;

        public event EventHandler<RawCardDataReplyEventArgs> RawCardDataReplyReceived;

        [Obsolete("Use Raw Card Data for incoming card reads.")]
        public event EventHandler<FormattedCardDataReplyEventArgs> FormattedCardDataReplyReceived;

        public event EventHandler<ManufacturerSpecificReplyEventArgs> ManufacturerSpecificReplyReceived;

        public event EventHandler<ExtendedReadReplyEventArgs> ExtendedReadReplyReceived;

        public event EventHandler<KeypadReplyEventArgs> KeypadReplyReceived;

        private event EventHandler<BiometricReadResultsReplyEventArgs> BiometricReadResultsReplyReceived;

        private event EventHandler<BiometricMatchReplyEventArgs> BiometricMatchReplyReceived;

        private event EventHandler<MultiPartMessageDataReplyEventArgs> PIVDataReplyReceived;

        private event EventHandler<MultiPartMessageDataReplyEventArgs> ExtendedIdReplyReceived;

        private event EventHandler<MultiPartMessageDataReplyEventArgs> AuthenticationChallengeResponseReceived;

        public class NakReplyEventArgs : EventArgs
        {
            public NakReplyEventArgs(Guid connectionId, byte address, Nak nak)
            {
                ConnectionId = connectionId;
                Address = address;
                Nak = nak;
            }

            public Guid ConnectionId { get; }

            public byte Address { get; }

            public Nak Nak { get; }
        }

        public class ConnectionStatusEventArgs : EventArgs
        {
            public ConnectionStatusEventArgs(Guid connectionId, byte address, bool isConnected,
                bool isSecureChannelEstablished)
            {
                ConnectionId = connectionId;
                Address = address;
                IsConnected = isConnected;
                IsSecureChannelEstablished = isSecureChannelEstablished;
            }

            public Guid ConnectionId { get; }

            public byte Address { get; }

            public bool IsConnected { get; }

            public bool IsSecureChannelEstablished { get; }

            public override string ToString() =>
                $"{ConnectionId}:{Address} - Conn: {IsConnected}; Sec: {IsSecureChannelEstablished}";
        }

        public class LocalStatusReportReplyEventArgs : EventArgs
        {
            public LocalStatusReportReplyEventArgs(Guid connectionId, byte address, LocalStatus localStatus)
            {
                ConnectionId = connectionId;
                Address = address;
                LocalStatus = localStatus;
            }

            public Guid ConnectionId { get; }

            public byte Address { get; }

            public LocalStatus LocalStatus { get; }
        }

        public class InputStatusReportReplyEventArgs : EventArgs
        {
            public InputStatusReportReplyEventArgs(Guid connectionId, byte address, InputStatus inputStatus)
            {
                ConnectionId = connectionId;
                Address = address;
                InputStatus = inputStatus;
            }

            public Guid ConnectionId { get; }

            public byte Address { get; }

            public InputStatus InputStatus { get; }
        }

        public class OutputStatusReportReplyEventArgs : EventArgs
        {
            public OutputStatusReportReplyEventArgs(Guid connectionId, byte address, OutputStatus outputStatus)
            {
                ConnectionId = connectionId;
                Address = address;
                OutputStatus = outputStatus;
            }

            public Guid ConnectionId { get; }

            public byte Address { get; }

            public OutputStatus OutputStatus { get; }
        }

        public class ReaderStatusReportReplyEventArgs : EventArgs
        {
            public ReaderStatusReportReplyEventArgs(Guid connectionId, byte address, ReaderStatus readerStatus)
            {
                ConnectionId = connectionId;
                Address = address;
                ReaderStatus = readerStatus;
            }

            public Guid ConnectionId { get; }

            public byte Address { get; }

            public ReaderStatus ReaderStatus { get; }
        }

        public class RawCardDataReplyEventArgs : EventArgs
        {
            public RawCardDataReplyEventArgs(Guid connectionId, byte address, RawCardData rawCardData)
            {
                ConnectionId = connectionId;
                Address = address;
                RawCardData = rawCardData;
            }

            public Guid ConnectionId { get; }

            public byte Address { get; }

            public RawCardData RawCardData { get; }
        }

        public class FormattedCardDataReplyEventArgs : EventArgs
        {
            public FormattedCardDataReplyEventArgs(Guid connectionId, byte address, FormattedCardData formattedCardData)
            {
                ConnectionId = connectionId;
                Address = address;
                FormattedCardData = formattedCardData;
            }

            public Guid ConnectionId { get; }

            public byte Address { get; }

            public FormattedCardData FormattedCardData { get; }
        }

        public class ManufacturerSpecificReplyEventArgs : EventArgs
        {
            public ManufacturerSpecificReplyEventArgs(Guid connectionId, byte address, ManufacturerSpecific manufacturerSpecific)
            {
                ConnectionId = connectionId;
                Address = address;
                ManufacturerSpecific = manufacturerSpecific;
            }

            public Guid ConnectionId { get; }

            public byte Address { get; }

            public ManufacturerSpecific ManufacturerSpecific { get; }
        }

        public class ExtendedReadReplyEventArgs : EventArgs
        {
            public ExtendedReadReplyEventArgs(Guid connectionId, byte address, ExtendedRead extendedRead)
            {
                ConnectionId = connectionId;
                Address = address;
                ExtendedRead = extendedRead;
            }

            public Guid ConnectionId { get; }

            public byte Address { get; }

            public ExtendedRead ExtendedRead { get; }
        }

        private class MultiPartMessageDataReplyEventArgs : EventArgs
        {
            public MultiPartMessageDataReplyEventArgs(Guid connectionId, byte address, DataFragmentResponse dataFragmentResponse)
            {
                ConnectionId = connectionId;
                Address = address;
                DataFragmentResponse = dataFragmentResponse;
            }

            public Guid ConnectionId { get; }

            public byte Address { get; }

            public DataFragmentResponse DataFragmentResponse { get; }
        }

        public class KeypadReplyEventArgs : EventArgs
        {
            public KeypadReplyEventArgs(Guid connectionId, byte address, KeypadData keypadData)
            {
                ConnectionId = connectionId;
                Address = address;
                KeypadData = keypadData;
            }

            public Guid ConnectionId { get; }

            public byte Address { get; }

            public KeypadData KeypadData { get; }
        }

        private class BiometricReadResultsReplyEventArgs : EventArgs
        {
            public BiometricReadResultsReplyEventArgs(Guid connectionId, byte address,
                BiometricReadResult biometricReadResult)
            {
                ConnectionId = connectionId;
                Address = address;
                BiometricReadResult = biometricReadResult;
            }

            public Guid ConnectionId { get; }

            public byte Address { get; }

            public BiometricReadResult BiometricReadResult { get; }
        }

        private class BiometricMatchReplyEventArgs : EventArgs
        {
            public BiometricMatchReplyEventArgs(Guid connectionId, byte address,
                BiometricMatchResult biometricMatchResult)
            {
                ConnectionId = connectionId;
                Address = address;
                BiometricMatchResult = biometricMatchResult;
            }

            public Guid ConnectionId { get; }

            public byte Address { get; }

            public BiometricMatchResult BiometricMatchResult { get; }
        }

        public class FileTransferStatus
        {
            public FileTransferStatus(Model.ReplyData.FileTransferStatus.StatusDetail status, int currentOffset,
                Nak nak)
            {
                Status = status;
                CurrentOffset = currentOffset;
                Nak = nak;
            }

            public Model.ReplyData.FileTransferStatus.StatusDetail  Status { get; }

            public int CurrentOffset { get; }

            public Nak Nak { get; }
        }

        public class FileTransferException : Exception
        {
            internal FileTransferException(string msg, FileTransferStatus status) : base(msg)
            {
                Status = status;
            }

            public FileTransferStatus Status { get; }
        }

        public class RawReplyEventArgs : EventArgs
        {
            public RawReplyEventArgs(Guid connectionId, byte address, byte replyType, ReadOnlyMemory<byte> payload)
            {
                ConnectionId = connectionId;
                Address = address;
                ReplyType = replyType;
                Payload = payload;
            }

            public Guid ConnectionId { get; }

            public byte Address { get; }

            public byte ReplyType { get; }

            public ReadOnlyMemory<byte> Payload { get; }
        }
 
        private class ReplyEventArgs : EventArgs
        {
            public ReplyTracker Reply { get; set; }
        }
    }
}