CommunicationSampleRuntime.cs

이 파일의 문서화 페이지로 가기

using System.Text;
using System.Windows;
using Dreamine.Communication.Abstractions.Enums;
using Dreamine.Communication.Abstractions.Interfaces;
using Dreamine.Communication.Abstractions.Models;
using Dreamine.Communication.Abstractions.Options;
using Dreamine.Communication.Core.Framing;
using Dreamine.Communication.Core.Protocols;
using Dreamine.Communication.Core.Resilience;
using Dreamine.Communication.RabbitMQ.Buses;
using Dreamine.Communication.RabbitMQ.Options;
using Dreamine.Communication.Serial.Options;
using Dreamine.Communication.Serial.Ports;
using Dreamine.Communication.Sockets.Clients;
using Dreamine.Communication.Sockets.Enums;
using Dreamine.Communication.Sockets.Options;
using Dreamine.Communication.Sockets.Servers;
using Dreamine.Communication.Sockets.Udp;
using Dreamine.Communication.Wpf.ViewModels;
 
namespace SampleSmart.Pages.PageSub.CommunicationTabs;

public sealed class CommunicationSampleRuntime
{
    private const string InMemoryChannelName = "InMemory-Communication";
    private const string InMemoryRouteName = "sample.communication.message";

    private const string RabbitMqChannelName = "RabbitMQ-MessageBus";
    private const string RabbitMqProtocol = "RabbitMQ";

    private const string DreamineEnvelopeProtocol = "DreamineEnvelope";
    private const string PlainTextProtocol = "PlainText";
    private const string RawAvailableProtocol = "RawAvailable";
    private const string RawJsonProtocol = "RawJson";

    private const int DreamineProtocolPort = 15001;
    private const int PlainTextProtocolPort = 15002;
    private const int RawAvailableProtocolPort = 15002;
    private const int RawJsonProtocolPort = 15003;

    private const int UdpPeerALocalPort = 16001;
    private const int UdpPeerBLocalPort = 16002;

    private readonly IMessageBus _messageBus;

    private bool _isInMemorySubscribed;
    private bool _isRabbitMqSubscribed;

    private IMessageTransport? _tcpServer;
    private TcpServerTransport? _rawTcpServer;
    private IMessageTransport? _tcpClient;
    private UdpTransport? _udpPeerA;
    private UdpTransport? _udpPeerB;
    private SerialPortTransport? _serialTransport;
    private RabbitMqMessageBus? _rabbitMqBus;

    private string _currentServerProtocol = PlainTextProtocol;
    private string _currentClientProtocol = PlainTextProtocol;
    private string _currentServerEncoding = PlainTextProtocolOptions.Utf8EncodingName;
    private string _currentClientEncoding = PlainTextProtocolOptions.Utf8EncodingName;
    private TcpServerSendTargetMode _currentServerSendTargetMode = TcpServerSendTargetMode.Broadcast;
    private bool _currentServerEchoEnabled;
    private string _currentUdpPeerAProtocol = PlainTextProtocol;
    private string _currentUdpPeerBProtocol = PlainTextProtocol;
    private string _currentUdpPeerAEncoding = PlainTextProtocolOptions.Utf8EncodingName;
    private string _currentUdpPeerBEncoding = PlainTextProtocolOptions.Utf8EncodingName;

    private string _currentSerialProtocol = RawAvailableProtocol;
    private string _currentSerialEncoding = PlainTextProtocolOptions.Utf8EncodingName;
    private string _currentSerialPortName = string.Empty;
    private int _currentSerialBaudRate = 9600;

    private string _currentRabbitMqHost = "localhost";
    private int _currentRabbitMqPort = 5672;
    private string _currentRabbitMqVirtualHost = "/";
    private string _currentRabbitMqExchangeName = "dreamine.sample.exchange";
    private string _currentRabbitMqQueueName = "dreamine.sample.queue";
    private string _currentRabbitMqRoutingKey = "dreamine.sample.route";

    public CommunicationSampleRuntime(IMessageBus messageBus)
    {
        _messageBus = messageBus ?? throw new ArgumentNullException(nameof(messageBus));
        Monitor = new CommunicationMonitorViewModel();
 
        _ = SubscribeInMemoryAsync();
    }

    public CommunicationMonitorViewModel Monitor { get; }

    public IReadOnlyList<string> TcpProtocols { get; } =
    [
        DreamineEnvelopeProtocol,
        PlainTextProtocol,
        RawAvailableProtocol,
        RawJsonProtocol
    ];

    public IReadOnlyList<string> SerialProtocols { get; } =
    [
        PlainTextProtocol,
        RawAvailableProtocol,
        RawJsonProtocol
    ];

    public IReadOnlyList<string> UdpProtocols { get; } =
    [
        DreamineEnvelopeProtocol,
        PlainTextProtocol,
        RawAvailableProtocol,
        RawJsonProtocol
    ];

    public IReadOnlyList<string> TextEncodings { get; } =
    [
        PlainTextProtocolOptions.Utf8EncodingName,
        PlainTextProtocolOptions.KoreanCodePage949EncodingName
    ];

    public IReadOnlyList<string> TcpServerSendTargetModes { get; } =
    [
        nameof(TcpServerSendTargetMode.Broadcast),
        nameof(TcpServerSendTargetMode.FirstClient),
        nameof(TcpServerSendTargetMode.LastClient)
    ];

    public IReadOnlyList<string> UdpTextEncodings => TextEncodings;

    public void AddInMemoryChannel()
    {
        if (Monitor.Channels.Any(x => x.Name == InMemoryChannelName))
        {
            return;
        }
 
        Monitor.AddChannel(
            InMemoryChannelName,
            TransportKind.InMemory,
            "SampleSmart in-memory communication channel.");
    }

    public async Task ConnectInMemoryAsync()
    {
        AddInMemoryChannel();
 
        await _messageBus.ConnectAsync();
 
        Monitor.UpdateChannelState(
            InMemoryChannelName,
            ConnectionState.Connected);
    }

    public async Task DisconnectInMemoryAsync()
    {
        AddInMemoryChannel();
 
        await _messageBus.DisconnectAsync();
 
        Monitor.UpdateChannelState(
            InMemoryChannelName,
            ConnectionState.Disconnected);
    }

    public async Task SendInMemoryAsync(string text)
    {
        AddInMemoryChannel();
 
        if (_messageBus.State != ConnectionState.Connected)
        {
            await ConnectInMemoryAsync();
        }
 
        if (string.IsNullOrWhiteSpace(text))
        {
            text = "Hello from SampleSmart InMemory";
        }
 
        var message = CreateTextMessage(
            "Sample.Send",
            InMemoryRouteName,
            text,
            "InMemory");
 
        Monitor.AddSendLog(
            InMemoryChannelName,
            TransportKind.InMemory,
            message);
 
        await _messageBus.PublishAsync(message);
    }

    public void ReceiveInMemory(string text)
    {
        AddInMemoryChannel();
 
        if (string.IsNullOrWhiteSpace(text))
        {
            text = "Hello from SampleSmart manual receive";
        }
 
        var message = CreateTextMessage(
            "Sample.Receive",
            "sample.communication.manual-receive",
            text,
            "InMemory");
 
        Monitor.AddReceiveLog(
            InMemoryChannelName,
            TransportKind.InMemory,
            message);
    }

    public async Task StartTcpServerAsync(
        string protocol,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName,
        string sendTargetMode = nameof(TcpServerSendTargetMode.Broadcast),
        bool echoEnabled = false)
    {
        protocol = NormalizeProtocol(protocol);
        encodingName = NormalizeTextEncodingName(encodingName);
        var targetMode = NormalizeTcpServerSendTargetMode(sendTargetMode);
 
        if (_tcpServer is not null &&
            _tcpServer.State == ConnectionState.Listening &&
            _currentServerProtocol == protocol &&
            _currentServerEncoding == encodingName)
        {
            _currentServerSendTargetMode = targetMode;
            _currentServerEchoEnabled = echoEnabled;
 
            if (_rawTcpServer is not null)
            {
                _rawTcpServer.SendTargetMode = targetMode;
                UpdateTcpServerDescription(
                    protocol,
                    encodingName,
                    _rawTcpServer.ConnectedClientCount,
                    targetMode,
                    echoEnabled);
            }
 
            return;
        }
 
        if (_tcpServer is not null)
        {
            await StopTcpServerAsync();
        }
 
        _currentServerProtocol = protocol;
        _currentServerEncoding = encodingName;
        _currentServerSendTargetMode = targetMode;
        _currentServerEchoEnabled = echoEnabled;
 
        EnsureTcpServerChannel(protocol, encodingName);
 
        var port = GetTcpPort(protocol);
 
        _rawTcpServer = new TcpServerTransport(
            new TcpServerTransportOptions
            {
                Host = "127.0.0.1",
                Port = port,
                SendTargetMode = targetMode
            },
            CreateProtocolAdapter(
                protocol,
                "tcp",
                "Tcp",
                encodingName),
            CreateFrameCodec(protocol, encodingName));
 
        _tcpServer = new ResilientMessageTransport(
            _rawTcpServer,
            CreateSampleReconnectPolicy(),
            CreateSampleServerOutboundQueueOptions());
 
        var channelName = GetTcpServerChannelName(protocol, encodingName);
 
        AttachTcpResilientStateMonitor(
            _tcpServer,
            channelName);
 
        AttachTcpServerClientCountMonitor(
            _rawTcpServer,
            protocol,
            encodingName);
 
        UpdateTcpServerDescription(
            protocol,
            encodingName,
            _rawTcpServer.ConnectedClientCount,
            targetMode,
            echoEnabled);
 
        _tcpServer.MessageReceived += OnTcpServerMessageReceived;
 
        Monitor.UpdateChannelState(channelName, ConnectionState.Connecting);
 
        await _tcpServer.ConnectAsync();
 
        Monitor.UpdateChannelState(
            channelName,
            _tcpServer.State);
    }

    public void UpdateTcpServerOptions(
        string protocol,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName,
        string sendTargetMode = nameof(TcpServerSendTargetMode.Broadcast),
        bool echoEnabled = false)
    {
        protocol = NormalizeProtocol(protocol);
        encodingName = NormalizeTextEncodingName(encodingName);
        var targetMode = NormalizeTcpServerSendTargetMode(sendTargetMode);
 
        _currentServerSendTargetMode = targetMode;
        _currentServerEchoEnabled = echoEnabled;
 
        if (_rawTcpServer is null ||
            _currentServerProtocol != protocol ||
            _currentServerEncoding != encodingName)
        {
            return;
        }
 
        _rawTcpServer.SendTargetMode = targetMode;
 
        UpdateTcpServerDescription(
            protocol,
            encodingName,
            _rawTcpServer.ConnectedClientCount,
            targetMode,
            echoEnabled);
    }

    public async Task StopTcpServerAsync()
    {
        var protocol = _currentServerProtocol;
        var encodingName = _currentServerEncoding;
        var channelName = GetTcpServerChannelName(protocol, encodingName);
 
        if (_tcpServer is null)
        {
            if (Monitor.Channels.Any(x => x.Name == channelName))
            {
                Monitor.UpdateChannelState(channelName, ConnectionState.Disconnected);
            }
 
            return;
        }
 
        _tcpServer.MessageReceived -= OnTcpServerMessageReceived;
 
        await _tcpServer.DisposeAsync();
 
        _tcpServer = null;
        _rawTcpServer = null;
 
        if (Monitor.Channels.Any(x => x.Name == channelName))
        {
            Monitor.UpdateChannelState(channelName, ConnectionState.Disconnected);
        }
    }

    public async Task SendTcpServerAsync(
        string protocol,
        string text,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName,
        string sendTargetMode = nameof(TcpServerSendTargetMode.Broadcast))
    {
        protocol = NormalizeProtocol(protocol);
        encodingName = NormalizeTextEncodingName(encodingName);
        var targetMode = NormalizeTcpServerSendTargetMode(sendTargetMode);
        _currentServerSendTargetMode = targetMode;
 
        if (_rawTcpServer is not null)
        {
            _rawTcpServer.SendTargetMode = targetMode;
            UpdateTcpServerDescription(
                protocol,
                encodingName,
                _rawTcpServer.ConnectedClientCount,
                targetMode,
                _currentServerEchoEnabled);
        }
 
        if (string.IsNullOrWhiteSpace(text))
        {
            text = "Hello from Dreamine TCP Server";
        }
 
        if (_tcpServer is null ||
            _tcpServer.State != ConnectionState.Listening ||
            _currentServerProtocol != protocol ||
            _currentServerEncoding != encodingName)
        {
            await StartTcpServerAsync(protocol, encodingName, sendTargetMode, _currentServerEchoEnabled);
        }
 
        if (_tcpServer is null)
        {
            return;
        }
 
        var message = CreateTcpMessageByProtocol(
            protocol,
            $"Server.Send.{targetMode}",
            text,
            encodingName);
 
        var channelName = GetTcpServerChannelName(protocol, encodingName);
 
        Monitor.AddSendLog(
            channelName,
            TransportKind.Tcp,
            message);
 
        await _tcpServer.SendAsync(message);
    }

    public async Task ConnectTcpClientAsync(
        string protocol,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        protocol = NormalizeProtocol(protocol);
        encodingName = NormalizeTextEncodingName(encodingName);
 
        if (_tcpClient is not null &&
            _tcpClient.State == ConnectionState.Connected &&
            _currentClientProtocol == protocol &&
            _currentClientEncoding == encodingName)
        {
            return;
        }
 
        await PrepareTcpClientTransportAsync(protocol, encodingName);
 
        if (_tcpClient is null)
        {
            return;
        }
 
        var channelName = GetTcpClientChannelName(protocol, encodingName);
 
        Monitor.UpdateChannelState(channelName, ConnectionState.Connecting);
 
        try
        {
            await _tcpClient.ConnectAsync();
 
            Monitor.UpdateChannelState(
                channelName,
                _tcpClient.State);
        }
        catch
        {
            // ResilientMessageTransport의 내부 WatchLoop가 계속 재연결을 시도합니다.
            // 수동 Connect 실패는 UI 상태만 Connecting으로 유지하고 예외를 샘플 밖으로 전파하지 않습니다.
            Monitor.UpdateChannelState(channelName, ConnectionState.Connecting);
        }
    }

    private async Task PrepareTcpClientTransportAsync(
        string protocol,
        string encodingName)
    {
        protocol = NormalizeProtocol(protocol);
        encodingName = NormalizeTextEncodingName(encodingName);
 
        if (_tcpClient is not null &&
            _currentClientProtocol == protocol &&
            _currentClientEncoding == encodingName)
        {
            return;
        }
 
        if (_tcpClient is not null)
        {
            await DisconnectTcpClientAsync();
        }
 
        _currentClientProtocol = protocol;
        _currentClientEncoding = encodingName;
 
        EnsureTcpClientChannel(protocol, encodingName);
 
        var port = GetTcpPort(protocol);
 
        var rawTcpClient = new TcpClientTransport(
            new TcpClientTransportOptions
            {
                Host = "127.0.0.1",
                Port = port
            },
            CreateProtocolAdapter(
                protocol,
                "tcp",
                "Tcp",
                encodingName),
            CreateFrameCodec(protocol, encodingName));
 
        _tcpClient = new ResilientMessageTransport(
            rawTcpClient,
            CreateSampleReconnectPolicy(),
            CreateSampleOutboundQueueOptions());
 
        var channelName = GetTcpClientChannelName(protocol, encodingName);
 
        AttachTcpResilientStateMonitor(
            _tcpClient,
            channelName);
 
        AttachTcpClientQueueMonitor(
            _tcpClient,
            protocol,
            encodingName,
            channelName);
 
        _tcpClient.MessageReceived += OnTcpClientMessageReceived;
 
        Monitor.UpdateChannelState(
            channelName,
            _tcpClient.State);
    }

    public async Task DisconnectTcpClientAsync()
    {
        var protocol = _currentClientProtocol;
        var encodingName = _currentClientEncoding;
        var channelName = GetTcpClientChannelName(protocol, encodingName);
 
        if (_tcpClient is null)
        {
            if (Monitor.Channels.Any(x => x.Name == channelName))
            {
                Monitor.UpdateChannelState(channelName, ConnectionState.Disconnected);
            }
 
            return;
        }
 
        _tcpClient.MessageReceived -= OnTcpClientMessageReceived;
 
        await _tcpClient.DisposeAsync();
 
        _tcpClient = null;
 
        if (Monitor.Channels.Any(x => x.Name == channelName))
        {
            Monitor.UpdateChannelState(channelName, ConnectionState.Disconnected);
        }
    }

    public async Task SendTcpClientAsync(
        string protocol,
        string text,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        protocol = NormalizeProtocol(protocol);
        encodingName = NormalizeTextEncodingName(encodingName);
 
        if (string.IsNullOrWhiteSpace(text))
        {
            text = "Hello from Dreamine TCP Client";
        }
 
        await PrepareTcpClientTransportAsync(protocol, encodingName);
 
        if (_tcpClient is null)
        {
            return;
        }
 
        var message = CreateTcpMessageByProtocol(
            protocol,
            "Client.Send",
            text,
            encodingName);
 
        var channelName = GetTcpClientChannelName(protocol, encodingName);
 
        Monitor.AddSendLog(
            channelName,
            TransportKind.Tcp,
            message);
 
        await _tcpClient.SendAsync(message);
 
        if (_tcpClient is ResilientMessageTransport resilientTransport)
        {
            var queueStatusMessage = CreateTcpMessageByProtocol(
                protocol,
                "Client.QueueStatus",
                $"QueueCount={resilientTransport.QueuedMessageCount}, State={_tcpClient.State}",
                encodingName);
 
            Monitor.AddReceiveLog(
                channelName,
                TransportKind.Tcp,
                queueStatusMessage);
        }
 
        Monitor.UpdateChannelState(
            channelName,
            _tcpClient.State);
    }

    public async Task StopAllTcpAsync()
    {
        await DisconnectTcpClientAsync();
        await StopTcpServerAsync();
    }

    public async Task StartUdpLoopbackAsync(
        string protocol,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        await ConnectUdpPeerAAsync(protocol, encodingName);
        await ConnectUdpPeerBAsync(protocol, encodingName);
    }

    public async Task ConnectUdpPeerAAsync(
        string protocol,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        protocol = NormalizeProtocol(protocol);
        encodingName = NormalizeTextEncodingName(encodingName);
 
        if (_udpPeerA is not null &&
            _udpPeerA.State == ConnectionState.Connected &&
            _currentUdpPeerAProtocol == protocol &&
            _currentUdpPeerAEncoding == encodingName)
        {
            return;
        }
 
        if (_udpPeerA is not null)
        {
            await DisconnectUdpPeerAAsync();
        }
 
        _currentUdpPeerAProtocol = protocol;
        _currentUdpPeerAEncoding = encodingName;
 
        EnsureUdpPeerChannel("A", protocol, encodingName);
 
        _udpPeerA = new UdpTransport(
            new UdpTransportOptions
            {
                LocalHost = "127.0.0.1",
                LocalPort = UdpPeerALocalPort,
                RemoteHost = "127.0.0.1",
                RemotePort = UdpPeerBLocalPort,
                ReuseAddress = true
            },
            CreateProtocolAdapter(
                protocol,
                "udp",
                "Udp",
                encodingName));
 
        _udpPeerA.MessageReceived += OnUdpPeerAMessageReceived;
 
        await _udpPeerA.ConnectAsync();
 
        Monitor.UpdateChannelState(
            GetUdpPeerChannelName("A", protocol, encodingName),
            ConnectionState.Connected);
    }

    public async Task ConnectUdpPeerBAsync(
        string protocol,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        protocol = NormalizeProtocol(protocol);
        encodingName = NormalizeTextEncodingName(encodingName);
 
        if (_udpPeerB is not null &&
            _udpPeerB.State == ConnectionState.Connected &&
            _currentUdpPeerBProtocol == protocol &&
            _currentUdpPeerBEncoding == encodingName)
        {
            return;
        }
 
        if (_udpPeerB is not null)
        {
            await DisconnectUdpPeerBAsync();
        }
 
        _currentUdpPeerBProtocol = protocol;
        _currentUdpPeerBEncoding = encodingName;
 
        EnsureUdpPeerChannel("B", protocol, encodingName);
 
        _udpPeerB = new UdpTransport(
            new UdpTransportOptions
            {
                LocalHost = "127.0.0.1",
                LocalPort = UdpPeerBLocalPort,
                RemoteHost = "127.0.0.1",
                RemotePort = UdpPeerALocalPort,
                ReuseAddress = true
            },
            CreateProtocolAdapter(
                protocol,
                "udp",
                "Udp",
                encodingName));
 
        _udpPeerB.MessageReceived += OnUdpPeerBMessageReceived;
 
        await _udpPeerB.ConnectAsync();
 
        Monitor.UpdateChannelState(
            GetUdpPeerChannelName("B", protocol, encodingName),
            ConnectionState.Connected);
    }

    public async Task DisconnectUdpPeerAAsync()
    {
        var protocol = _currentUdpPeerAProtocol;
        var encodingName = _currentUdpPeerAEncoding;
        var channelName = GetUdpPeerChannelName("A", protocol, encodingName);
 
        if (_udpPeerA is null)
        {
            if (Monitor.Channels.Any(x => x.Name == channelName))
            {
                Monitor.UpdateChannelState(channelName, ConnectionState.Disconnected);
            }
 
            return;
        }
 
        _udpPeerA.MessageReceived -= OnUdpPeerAMessageReceived;
 
        await _udpPeerA.DisposeAsync();
 
        _udpPeerA = null;
 
        if (Monitor.Channels.Any(x => x.Name == channelName))
        {
            Monitor.UpdateChannelState(channelName, ConnectionState.Disconnected);
        }
    }

    public async Task DisconnectUdpPeerBAsync()
    {
        var protocol = _currentUdpPeerBProtocol;
        var encodingName = _currentUdpPeerBEncoding;
        var channelName = GetUdpPeerChannelName("B", protocol, encodingName);
 
        if (_udpPeerB is null)
        {
            if (Monitor.Channels.Any(x => x.Name == channelName))
            {
                Monitor.UpdateChannelState(channelName, ConnectionState.Disconnected);
            }
 
            return;
        }
 
        _udpPeerB.MessageReceived -= OnUdpPeerBMessageReceived;
 
        await _udpPeerB.DisposeAsync();
 
        _udpPeerB = null;
 
        if (Monitor.Channels.Any(x => x.Name == channelName))
        {
            Monitor.UpdateChannelState(channelName, ConnectionState.Disconnected);
        }
    }

    public async Task StopAllUdpAsync()
    {
        await DisconnectUdpPeerBAsync();
        await DisconnectUdpPeerAAsync();
    }

    public async Task SendUdpPeerAAsync(
        string protocol,
        string text,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        protocol = NormalizeProtocol(protocol);
        encodingName = NormalizeTextEncodingName(encodingName);
 
        if (string.IsNullOrWhiteSpace(text))
        {
            text = "Hello from Dreamine UDP Peer A";
        }
 
        if (_udpPeerA is null ||
            _udpPeerA.State != ConnectionState.Connected ||
            _currentUdpPeerAProtocol != protocol ||
            _currentUdpPeerAEncoding != encodingName)
        {
            await ConnectUdpPeerAAsync(protocol, encodingName);
        }
 
        if (_udpPeerA is null)
        {
            return;
        }
 
        var message = CreateUdpMessageByProtocol(
            protocol,
            "PeerA.Send",
            text,
            encodingName);
 
        var channelName = GetUdpPeerChannelName("A", protocol, encodingName);
 
        Monitor.AddSendLog(
            channelName,
            TransportKind.Udp,
            message);
 
        await _udpPeerA.SendAsync(message);
    }

    public async Task SendUdpPeerBAsync(
        string protocol,
        string text,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        protocol = NormalizeProtocol(protocol);
        encodingName = NormalizeTextEncodingName(encodingName);
 
        if (string.IsNullOrWhiteSpace(text))
        {
            text = "Hello from Dreamine UDP Peer B";
        }
 
        if (_udpPeerB is null ||
            _udpPeerB.State != ConnectionState.Connected ||
            _currentUdpPeerBProtocol != protocol ||
            _currentUdpPeerBEncoding != encodingName)
        {
            await ConnectUdpPeerBAsync(protocol, encodingName);
        }
 
        if (_udpPeerB is null)
        {
            return;
        }
 
        var message = CreateUdpMessageByProtocol(
            protocol,
            "PeerB.Send",
            text,
            encodingName);
 
        var channelName = GetUdpPeerChannelName("B", protocol, encodingName);
 
        Monitor.AddSendLog(
            channelName,
            TransportKind.Udp,
            message);
 
        await _udpPeerB.SendAsync(message);
    }

    public async Task ConnectSerialAsync(
        string portName,
        int baudRate,
        string protocol,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        if (string.IsNullOrWhiteSpace(portName))
        {
            return;
        }
 
        protocol = NormalizeProtocol(protocol);
        encodingName = NormalizeTextEncodingName(encodingName);
 
        if (_serialTransport is not null &&
            _serialTransport.State == ConnectionState.Connected &&
            _currentSerialPortName == portName &&
            _currentSerialBaudRate == baudRate &&
            _currentSerialProtocol == protocol &&
            _currentSerialEncoding == encodingName)
        {
            return;
        }
 
        if (_serialTransport is not null)
        {
            await DisconnectSerialAsync();
        }
 
        _currentSerialPortName = portName;
        _currentSerialBaudRate = baudRate;
        _currentSerialProtocol = protocol;
        _currentSerialEncoding = encodingName;
 
        EnsureSerialChannel();
 
        _serialTransport = new SerialPortTransport(
            new SerialPortTransportOptions
            {
                PortName = portName,
                BaudRate = baudRate
            },
            CreateProtocolAdapter(
                protocol,
                "serial",
                "Serial",
                encodingName),
            CreateFrameCodec(protocol, encodingName));
 
        _serialTransport.MessageReceived += OnSerialMessageReceived;
 
        await _serialTransport.ConnectAsync();
 
        Monitor.UpdateChannelState(
            GetSerialChannelName(),
            ConnectionState.Connected);
    }

    public async Task DisconnectSerialAsync()
    {
        var channelName = GetSerialChannelName();
 
        if (_serialTransport is null)
        {
            if (Monitor.Channels.Any(x => x.Name == channelName))
            {
                Monitor.UpdateChannelState(channelName, ConnectionState.Disconnected);
            }
 
            return;
        }
 
        _serialTransport.MessageReceived -= OnSerialMessageReceived;
 
        await _serialTransport.DisposeAsync();
 
        _serialTransport = null;
 
        if (Monitor.Channels.Any(x => x.Name == channelName))
        {
            Monitor.UpdateChannelState(channelName, ConnectionState.Disconnected);
        }
    }

    public async Task SendSerialAsync(
        string protocol,
        string text,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        protocol = NormalizeProtocol(protocol);
        encodingName = NormalizeTextEncodingName(encodingName);
 
        if (string.IsNullOrWhiteSpace(text))
        {
            text = "test";
        }
 
        if (_serialTransport is null ||
            _serialTransport.State != ConnectionState.Connected)
        {
            return;
        }
 
        var message = CreateSerialMessageByProtocol(
            protocol,
            "Send",
            text,
            encodingName);
 
        var channelName = GetSerialChannelName();
 
        Monitor.AddSendLog(
            channelName,
            TransportKind.Serial,
            message);
 
        await _serialTransport.SendAsync(message);
    }

    public async Task ConnectRabbitMqAsync(
        string host,
        int port,
        string virtualHost,
        string userName,
        string password,
        string exchangeName,
        string queueName,
        string routingKey)
    {
        host = NormalizeText(host, "localhost");
        virtualHost = NormalizeText(virtualHost, "/");
        userName = NormalizeText(userName, "guest");
        password = NormalizeText(password, "guest");
        exchangeName = NormalizeText(exchangeName, "dreamine.sample.exchange");
        queueName = NormalizeText(queueName, "dreamine.sample.queue");
        routingKey = NormalizeText(routingKey, "dreamine.sample.route");
 
        if (port <= 0 || port > 65535)
        {
            port = 5672;
        }
 
        if (_rabbitMqBus is not null &&
            _rabbitMqBus.State == ConnectionState.Connected &&
            _currentRabbitMqHost == host &&
            _currentRabbitMqPort == port &&
            _currentRabbitMqVirtualHost == virtualHost &&
            _currentRabbitMqExchangeName == exchangeName &&
            _currentRabbitMqQueueName == queueName &&
            _currentRabbitMqRoutingKey == routingKey)
        {
            return;
        }
 
        if (_rabbitMqBus is not null)
        {
            await DisconnectRabbitMqAsync();
        }
 
        _currentRabbitMqHost = host;
        _currentRabbitMqPort = port;
        _currentRabbitMqVirtualHost = virtualHost;
        _currentRabbitMqExchangeName = exchangeName;
        _currentRabbitMqQueueName = queueName;
        _currentRabbitMqRoutingKey = routingKey;
        _isRabbitMqSubscribed = false;
 
        EnsureRabbitMqChannel();
 
        _rabbitMqBus = new RabbitMqMessageBus(
            new RabbitMqMessageBusOptions
            {
                HostName = host,
                Port = port,
                VirtualHost = virtualHost,
                UserName = userName,
                Password = password,
                ExchangeName = exchangeName,
                QueueName = queueName,
                RoutingKey = routingKey
            });
 
        try
        {
            await _rabbitMqBus.ConnectAsync();
 
            Monitor.UpdateChannelState(
                RabbitMqChannelName,
                ConnectionState.Connected);
        }
        catch (Exception ex)
        {
            Monitor.UpdateChannelState(
                RabbitMqChannelName,
                ConnectionState.Faulted);
 
            AddRabbitMqErrorLog("RabbitMQ.Connect.Failed", ex.Message);
        }
    }

    public async Task SubscribeRabbitMqAsync(
        string exchangeName,
        string queueName,
        string routingKey)
    {
        exchangeName = NormalizeText(exchangeName, _currentRabbitMqExchangeName);
        queueName = NormalizeText(queueName, _currentRabbitMqQueueName);
        routingKey = NormalizeText(routingKey, _currentRabbitMqRoutingKey);
 
        if (_rabbitMqBus is null)
        {
            AddRabbitMqErrorLog(
                "RabbitMQ.Subscribe.Skipped",
                "RabbitMQ is not connected.");
            return;
        }
 
        if (_rabbitMqBus.State != ConnectionState.Connected)
        {
            AddRabbitMqErrorLog(
                "RabbitMQ.Subscribe.Skipped",
                $"RabbitMQ state is {_rabbitMqBus.State}.");
            return;
        }
 
        if (_isRabbitMqSubscribed)
        {
            return;
        }
 
        _currentRabbitMqExchangeName = exchangeName;
        _currentRabbitMqQueueName = queueName;
        _currentRabbitMqRoutingKey = routingKey;
 
        try
        {
            await _rabbitMqBus.SubscribeAsync(
                routingKey,
                (message, _) =>
                {
                    RunOnUiThread(() =>
                    {
                        Monitor.AddReceiveLog(
                            RabbitMqChannelName,
                            TransportKind.RabbitMq,
                            message);
                    });
 
                    return Task.CompletedTask;
                });
 
            _isRabbitMqSubscribed = true;
        }
        catch (Exception ex)
        {
            AddRabbitMqErrorLog("RabbitMQ.Subscribe.Failed", ex.Message);
        }
    }

    public async Task PublishRabbitMqAsync(
        string exchangeName,
        string routingKey,
        string text)
    {
        exchangeName = NormalizeText(exchangeName, _currentRabbitMqExchangeName);
        routingKey = NormalizeText(routingKey, _currentRabbitMqRoutingKey);
 
        if (string.IsNullOrWhiteSpace(text))
        {
            text = "test";
        }
 
        if (_rabbitMqBus is null)
        {
            AddRabbitMqErrorLog(
                "RabbitMQ.Publish.Skipped",
                "RabbitMQ is not connected.");
            return;
        }
 
        if (_rabbitMqBus.State != ConnectionState.Connected)
        {
            AddRabbitMqErrorLog(
                "RabbitMQ.Publish.Skipped",
                $"RabbitMQ state is {_rabbitMqBus.State}.");
            return;
        }
 
        _currentRabbitMqExchangeName = exchangeName;
        _currentRabbitMqRoutingKey = routingKey;
 
        var message = CreateRabbitMqMessage(
            "Publish",
            routingKey,
            text);
 
        Monitor.AddSendLog(
            RabbitMqChannelName,
            TransportKind.RabbitMq,
            message);
 
        try
        {
            await _rabbitMqBus.PublishAsync(message);
        }
        catch (Exception ex)
        {
            AddRabbitMqErrorLog("RabbitMQ.Publish.Failed", ex.Message);
        }
    }

    public async Task DisconnectRabbitMqAsync()
    {
        if (_rabbitMqBus is null)
        {
            if (Monitor.Channels.Any(x => x.Name == RabbitMqChannelName))
            {
                Monitor.UpdateChannelState(
                    RabbitMqChannelName,
                    ConnectionState.Disconnected);
            }
 
            return;
        }
 
        await _rabbitMqBus.DisposeAsync();
 
        _rabbitMqBus = null;
        _isRabbitMqSubscribed = false;
 
        if (Monitor.Channels.Any(x => x.Name == RabbitMqChannelName))
        {
            Monitor.UpdateChannelState(
                RabbitMqChannelName,
                ConnectionState.Disconnected);
        }
    }

    public async Task StopAllAsync()
    {
        await DisconnectRabbitMqAsync();
        await DisconnectSerialAsync();
        await StopAllUdpAsync();
        await StopAllTcpAsync();
        await DisconnectInMemoryAsync();
    }

    private async Task SubscribeInMemoryAsync()
    {
        if (_isInMemorySubscribed)
        {
            return;
        }
 
        _isInMemorySubscribed = true;
 
        await _messageBus.SubscribeAsync(
            InMemoryRouteName,
            (message, _) =>
            {
                RunOnUiThread(() =>
                {
                    Monitor.AddReceiveLog(
                        InMemoryChannelName,
                        TransportKind.InMemory,
                        message);
                });
 
                return Task.CompletedTask;
            });
    }

    private async void OnTcpServerMessageReceived(object? sender, MessageEnvelope message)
    {
        var protocol = _currentServerProtocol;
        var encodingName = _currentServerEncoding;
        var channelName = GetTcpServerChannelName(protocol, encodingName);
 
        RunOnUiThread(() =>
        {
            Monitor.AddReceiveLog(
                channelName,
                TransportKind.Tcp,
                message);
        });
 
        if (_tcpServer is null ||
            _tcpServer.State != ConnectionState.Listening ||
            !_currentServerEchoEnabled)
        {
            return;
        }
 
        var receiveText = Encoding.UTF8.GetString(message.Payload);
 
        var echoMessage = CreateTcpMessageByProtocol(
            protocol,
            $"Server.Echo.{_currentServerSendTargetMode}",
            $"Echo from Dreamine TCP Server - {receiveText}",
            encodingName);
 
        RunOnUiThread(() =>
        {
            Monitor.AddSendLog(
                channelName,
                TransportKind.Tcp,
                echoMessage);
        });
 
        await _tcpServer.SendAsync(echoMessage);
    }

    private static ReconnectPolicy CreateSampleReconnectPolicy()
    {
        return new ReconnectPolicy
        {
            Enabled = true,
            InitialDelay = TimeSpan.FromSeconds(1),
            MaxDelay = TimeSpan.FromSeconds(5),
            BackoffFactor = 1.5,
            MaxRetryCount = null,
            WatchInterval = TimeSpan.FromMilliseconds(500)
        };
    }

    private static OutboundQueueOptions CreateSampleOutboundQueueOptions()
    {
        return new OutboundQueueOptions
        {
            DisconnectedSendPolicy = DisconnectedSendPolicy.Queue,
            MaxQueueSize = 10_000,
            DropOldestWhenFull = true,
            MaxMessageAge = null,
            FlushOnReconnect = true
        };
    }

    private static OutboundQueueOptions CreateSampleServerOutboundQueueOptions()
    {
        return new OutboundQueueOptions
        {
            DisconnectedSendPolicy = DisconnectedSendPolicy.Fail,
            MaxQueueSize = 1_000,
            DropOldestWhenFull = true,
            MaxMessageAge = null,
            FlushOnReconnect = false
        };
    }

    private void AttachTcpResilientStateMonitor(
        IMessageTransport transport,
        string channelName)
    {
        if (transport is not ResilientMessageTransport resilientTransport)
        {
            return;
        }
 
        resilientTransport.StateChanged += (_, state) =>
        {
            RunOnUiThread(() =>
            {
                Monitor.UpdateChannelState(
                    channelName,
                    state);
            });
        };
    }

    private void AttachTcpServerClientCountMonitor(
        TcpServerTransport tcpServerTransport,
        string protocol,
        string encodingName)
    {
        tcpServerTransport.ConnectedClientCountChanged += (_, clientCount) =>
        {
            RunOnUiThread(() =>
            {
                UpdateTcpServerDescription(
                    protocol,
                    encodingName,
                    clientCount,
                    _currentServerSendTargetMode,
                    _currentServerEchoEnabled);
            });
        };
    }

    private void UpdateTcpServerDescription(
        string protocol,
        string encodingName,
        int clientCount,
        TcpServerSendTargetMode targetMode,
        bool echoEnabled)
    {
        var channelName = GetTcpServerChannelName(protocol, encodingName);
        var port = GetTcpPort(protocol);
 
        Monitor.UpdateChannelDescription(
            channelName,
            CreateTcpServerDescription(protocol, encodingName, port, clientCount, targetMode, echoEnabled));
    }

    private static string CreateTcpServerDescription(
        string protocol,
        string encodingName,
        int port,
        int clientCount,
        TcpServerSendTargetMode targetMode,
        bool echoEnabled)
    {
        var echoText = echoEnabled ? "On" : "Off";
 
        return $"TCP server [{protocol}/{NormalizeTextEncodingName(encodingName)}] on 127.0.0.1:{port}. Clients={clientCount}. Target={targetMode}. Echo={echoText}.";
    }

    private void AttachTcpClientQueueMonitor(
        IMessageTransport transport,
        string protocol,
        string encodingName,
        string channelName)
    {
        if (transport is not ResilientMessageTransport resilientTransport)
        {
            return;
        }
 
        resilientTransport.QueueCountChanged += (_, queueCount) =>
        {
            var queueStatusMessage = CreateTcpMessageByProtocol(
                protocol,
                "Client.QueueStatus",
                $"QueueCount={queueCount}, State={resilientTransport.State}",
                encodingName);
 
            RunOnUiThread(() =>
            {
                Monitor.AddReceiveLog(
                    channelName,
                    TransportKind.Tcp,
                    queueStatusMessage);
 
                Monitor.UpdateChannelState(
                    channelName,
                    resilientTransport.State);
            });
        };
    }

    private void OnTcpClientMessageReceived(object? sender, MessageEnvelope message)
    {
        var protocol = _currentClientProtocol;
        var encodingName = _currentClientEncoding;
        var channelName = GetTcpClientChannelName(protocol, encodingName);
 
        RunOnUiThread(() =>
        {
            Monitor.AddReceiveLog(
                channelName,
                TransportKind.Tcp,
                message);
        });
    }

    private void OnUdpPeerAMessageReceived(object? sender, MessageEnvelope message)
    {
        var protocol = _currentUdpPeerAProtocol;
        var encodingName = _currentUdpPeerAEncoding;
        var channelName = GetUdpPeerChannelName("A", protocol, encodingName);
 
        RunOnUiThread(() =>
        {
            Monitor.AddReceiveLog(
                channelName,
                TransportKind.Udp,
                message);
        });
    }

    private void OnUdpPeerBMessageReceived(object? sender, MessageEnvelope message)
    {
        var protocol = _currentUdpPeerBProtocol;
        var encodingName = _currentUdpPeerBEncoding;
        var channelName = GetUdpPeerChannelName("B", protocol, encodingName);
 
        RunOnUiThread(() =>
        {
            Monitor.AddReceiveLog(
                channelName,
                TransportKind.Udp,
                message);
        });
    }

    private void OnSerialMessageReceived(object? sender, MessageEnvelope message)
    {
        var channelName = GetSerialChannelName();
 
        RunOnUiThread(() =>
        {
            Monitor.AddReceiveLog(
                channelName,
                TransportKind.Serial,
                message);
        });
    }

    private void EnsureTcpServerChannel(
        string protocol,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        var channelName = GetTcpServerChannelName(protocol, encodingName);
        var port = GetTcpPort(protocol);
 
        if (Monitor.Channels.Any(x => x.Name == channelName))
        {
            return;
        }
 
        Monitor.AddChannel(
            channelName,
            TransportKind.Tcp,
            CreateTcpServerDescription(
                protocol,
                encodingName,
                port,
                0,
                _currentServerSendTargetMode,
                _currentServerEchoEnabled));
    }

    private void EnsureTcpClientChannel(
        string protocol,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        var channelName = GetTcpClientChannelName(protocol, encodingName);
        var port = GetTcpPort(protocol);
 
        if (Monitor.Channels.Any(x => x.Name == channelName))
        {
            return;
        }
 
        Monitor.AddChannel(
            channelName,
            TransportKind.Tcp,
            $"TCP client [{protocol}/{NormalizeTextEncodingName(encodingName)}] to 127.0.0.1:{port}.");
    }

    private void EnsureUdpPeerChannel(
        string peerName,
        string protocol,
        string encodingName)
    {
        encodingName = NormalizeTextEncodingName(encodingName);
 
        var channelName = GetUdpPeerChannelName(peerName, protocol, encodingName);
        var localPort = GetUdpLocalPort(peerName);
        var remotePort = GetUdpRemotePort(peerName);
 
        if (Monitor.Channels.Any(x => x.Name == channelName))
        {
            return;
        }
 
        Monitor.AddChannel(
            channelName,
            TransportKind.Udp,
            $"UDP peer {peerName} [{protocol}/{encodingName}] 127.0.0.1:{localPort} -> 127.0.0.1:{remotePort}.");
    }

    private void EnsureSerialChannel()
    {
        var channelName = GetSerialChannelName();
 
        if (Monitor.Channels.Any(x => x.Name == channelName))
        {
            return;
        }
 
        Monitor.AddChannel(
            channelName,
            TransportKind.Serial,
            $"Serial [{_currentSerialProtocol}/{_currentSerialEncoding}] on {_currentSerialPortName}:{_currentSerialBaudRate}.");
    }

    private void EnsureRabbitMqChannel()
    {
        if (Monitor.Channels.Any(x => x.Name == RabbitMqChannelName))
        {
            return;
        }
 
        Monitor.AddChannel(
            RabbitMqChannelName,
            TransportKind.RabbitMq,
            $"RabbitMQ on {_currentRabbitMqHost}:{_currentRabbitMqPort}, vhost={_currentRabbitMqVirtualHost}, exchange={_currentRabbitMqExchangeName}, queue={_currentRabbitMqQueueName}, route={_currentRabbitMqRoutingKey}.");
    }

    private string GetSerialChannelName()
    {
        if (string.IsNullOrWhiteSpace(_currentSerialPortName))
        {
            return "Serial-Port";
        }
 
        return $"Serial-{_currentSerialPortName}";
    }

    private static IMessageProtocolAdapter CreateProtocolAdapter(
        string protocol,
        string routePrefix = "tcp",
        string namePrefix = "Tcp",
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        var normalizedProtocol = NormalizeProtocol(protocol);
        var textEncoding = PlainTextProtocolOptions.CreateEncoding(encodingName);
 
        return normalizedProtocol switch
        {
            DreamineEnvelopeProtocol => new DreamineEnvelopeProtocolAdapter(),
 
            PlainTextProtocol => new PlainTextProtocolAdapter(
                textEncoding,
                $"{routePrefix}.plaintext",
                $"{namePrefix}.PlainText"),
 
            RawAvailableProtocol => new PlainTextProtocolAdapter(
                textEncoding,
                $"{routePrefix}.raw.available",
                $"{namePrefix}.RawAvailable"),
 
            RawJsonProtocol => new RawJsonProtocolAdapter(
                textEncoding,
                $"{routePrefix}.rawjson",
                $"{namePrefix}.RawJson"),
 
            _ => new PlainTextProtocolAdapter(
                textEncoding,
                $"{routePrefix}.plaintext",
                $"{namePrefix}.PlainText")
        };
    }

    private static IMessageFrameCodec CreateFrameCodec(
        string protocol,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        var delimiterEncoding = PlainTextProtocolOptions.CreateEncoding(encodingName);
 
        return NormalizeProtocol(protocol) switch
        {
            DreamineEnvelopeProtocol => new LengthPrefixedMessageFrameCodec(),
 
            PlainTextProtocol => new DelimiterMessageFrameCodec(
                "\r\n",
                delimiterEncoding,
                1024 * 1024),
 
            RawAvailableProtocol => new RawAvailableMessageFrameCodec(),
 
            RawJsonProtocol => new DelimiterMessageFrameCodec(
                "\r\n",
                Encoding.UTF8,
                1024 * 1024),
 
            _ => new DelimiterMessageFrameCodec(
                "\r\n",
                delimiterEncoding,
                1024 * 1024)
        };
    }

    private static int GetTcpPort(string protocol)
    {
        return NormalizeProtocol(protocol) switch
        {
            DreamineEnvelopeProtocol => DreamineProtocolPort,
            PlainTextProtocol => PlainTextProtocolPort,
            RawAvailableProtocol => RawAvailableProtocolPort,
            RawJsonProtocol => RawJsonProtocolPort,
            _ => PlainTextProtocolPort
        };
    }

    private static string GetTcpServerChannelName(
        string protocol,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        var normalizedEncodingName = NormalizeTextEncodingName(encodingName);
 
        return NormalizeProtocol(protocol) switch
        {
            DreamineEnvelopeProtocol => "TCP-Server-Dreamine",
            PlainTextProtocol => $"TCP-Server-PlainText-{normalizedEncodingName}",
            RawAvailableProtocol => $"TCP-Server-RawAvailable-{normalizedEncodingName}",
            RawJsonProtocol => "TCP-Server-RawJson",
            _ => $"TCP-Server-PlainText-{normalizedEncodingName}"
        };
    }

    private static string GetTcpClientChannelName(
        string protocol,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        var normalizedEncodingName = NormalizeTextEncodingName(encodingName);
 
        return NormalizeProtocol(protocol) switch
        {
            DreamineEnvelopeProtocol => "TCP-Client-Dreamine",
            PlainTextProtocol => $"TCP-Client-PlainText-{normalizedEncodingName}",
            RawAvailableProtocol => $"TCP-Client-RawAvailable-{normalizedEncodingName}",
            RawJsonProtocol => "TCP-Client-RawJson",
            _ => $"TCP-Client-PlainText-{normalizedEncodingName}"
        };
    }

    private static string GetUdpPeerChannelName(
        string peerName,
        string protocol,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        var normalizedPeerName = NormalizeUdpPeerName(peerName);
        var normalizedEncodingName = NormalizeTextEncodingName(encodingName);
 
        return NormalizeProtocol(protocol) switch
        {
            DreamineEnvelopeProtocol => $"UDP-Peer{normalizedPeerName}-Dreamine",
            PlainTextProtocol => $"UDP-Peer{normalizedPeerName}-PlainText-{normalizedEncodingName}",
            RawAvailableProtocol => $"UDP-Peer{normalizedPeerName}-RawAvailable-{normalizedEncodingName}",
            RawJsonProtocol => $"UDP-Peer{normalizedPeerName}-RawJson",
            _ => $"UDP-Peer{normalizedPeerName}-PlainText-{normalizedEncodingName}"
        };
    }

    private static string NormalizeTextEncodingName(string encodingName)
    {
        if (string.Equals(encodingName, PlainTextProtocolOptions.KoreanCodePage949EncodingName, StringComparison.OrdinalIgnoreCase) ||
            string.Equals(encodingName, "949", StringComparison.OrdinalIgnoreCase))
        {
            return PlainTextProtocolOptions.KoreanCodePage949EncodingName;
        }
 
        return PlainTextProtocolOptions.Utf8EncodingName;
    }
 

    private static int GetUdpLocalPort(string peerName)
    {
        return NormalizeUdpPeerName(peerName) == "B"
            ? UdpPeerBLocalPort
            : UdpPeerALocalPort;
    }

    private static int GetUdpRemotePort(string peerName)
    {
        return NormalizeUdpPeerName(peerName) == "B"
            ? UdpPeerALocalPort
            : UdpPeerBLocalPort;
    }

    private static string NormalizeUdpPeerName(string peerName)
    {
        return string.Equals(peerName, "B", StringComparison.OrdinalIgnoreCase)
            ? "B"
            : "A";
    }

    private static MessageEnvelope CreateTcpMessageByProtocol(
        string protocol,
        string direction,
        string text,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        var normalizedProtocol = NormalizeProtocol(protocol);
        var normalizedEncodingName = NormalizeTextEncodingName(encodingName);
        var payload = Encoding.UTF8.GetBytes(text);
 
        return normalizedProtocol switch
        {
            DreamineEnvelopeProtocol => new MessageEnvelope
            {
                Name = $"Tcp.{direction}.DreamineEnvelope",
                Route = "sample.communication.tcp",
                Payload = payload,
                Headers = new Dictionary<string, string>
                {
                    ["Protocol"] = DreamineEnvelopeProtocol
                }
            },
 
            PlainTextProtocol => new MessageEnvelope
            {
                Name = $"Tcp.{direction}.PlainText",
                Route = "tcp.plaintext",
                Payload = payload,
                Headers = new Dictionary<string, string>
                {
                    ["ContentType"] = "text/plain",
                    ["Protocol"] = PlainTextProtocol,
                    ["ExternalEncoding"] = normalizedEncodingName
                }
            },
 
            RawAvailableProtocol => new MessageEnvelope
            {
                Name = $"Tcp.{direction}.RawAvailable",
                Route = "tcp.raw.available",
                Payload = payload,
                Headers = new Dictionary<string, string>
                {
                    ["ContentType"] = "text/plain",
                    ["Protocol"] = RawAvailableProtocol,
                    ["ExternalEncoding"] = normalizedEncodingName
                }
            },
 
            RawJsonProtocol => new MessageEnvelope
            {
                Name = $"Tcp.{direction}.RawJson",
                Route = "tcp.rawjson",
                Payload = EnsureJsonPayload(text),
                Headers = new Dictionary<string, string>
                {
                    ["ContentType"] = "application/json",
                    ["Protocol"] = RawJsonProtocol
                }
            },
 
            _ => new MessageEnvelope
            {
                Name = $"Tcp.{direction}.PlainText",
                Route = "tcp.plaintext",
                Payload = payload,
                Headers = new Dictionary<string, string>
                {
                    ["ContentType"] = "text/plain",
                    ["Protocol"] = PlainTextProtocol,
                    ["ExternalEncoding"] = normalizedEncodingName
                }
            }
        };
    }

    private static MessageEnvelope CreateUdpMessageByProtocol(
        string protocol,
        string direction,
        string text,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        var normalizedProtocol = NormalizeProtocol(protocol);
        var normalizedEncodingName = NormalizeTextEncodingName(encodingName);
        var payload = Encoding.UTF8.GetBytes(text);
 
        return normalizedProtocol switch
        {
            DreamineEnvelopeProtocol => new MessageEnvelope
            {
                Name = $"Udp.{direction}.DreamineEnvelope",
                Route = "sample.communication.udp",
                Payload = payload,
                Headers = new Dictionary<string, string>
                {
                    ["Protocol"] = DreamineEnvelopeProtocol
                }
            },
 
            PlainTextProtocol => new MessageEnvelope
            {
                Name = $"Udp.{direction}.PlainText",
                Route = "udp.plaintext",
                Payload = payload,
                Headers = new Dictionary<string, string>
                {
                    ["ContentType"] = "text/plain",
                    ["Protocol"] = PlainTextProtocol,
                    ["ExternalEncoding"] = normalizedEncodingName
                }
            },
 
            RawAvailableProtocol => new MessageEnvelope
            {
                Name = $"Udp.{direction}.RawAvailable",
                Route = "udp.raw.available",
                Payload = payload,
                Headers = new Dictionary<string, string>
                {
                    ["ContentType"] = "text/plain",
                    ["Protocol"] = RawAvailableProtocol,
                    ["ExternalEncoding"] = normalizedEncodingName
                }
            },
 
            RawJsonProtocol => new MessageEnvelope
            {
                Name = $"Udp.{direction}.RawJson",
                Route = "udp.rawjson",
                Payload = EnsureJsonPayload(text),
                Headers = new Dictionary<string, string>
                {
                    ["ContentType"] = "application/json",
                    ["Protocol"] = RawJsonProtocol
                }
            },
 
            _ => new MessageEnvelope
            {
                Name = $"Udp.{direction}.PlainText",
                Route = "udp.plaintext",
                Payload = payload,
                Headers = new Dictionary<string, string>
                {
                    ["ContentType"] = "text/plain",
                    ["Protocol"] = PlainTextProtocol,
                    ["ExternalEncoding"] = normalizedEncodingName
                }
            }
        };
    }

    private static MessageEnvelope CreateSerialMessageByProtocol(
        string protocol,
        string direction,
        string text,
        string encodingName = PlainTextProtocolOptions.Utf8EncodingName)
    {
        var normalizedProtocol = NormalizeProtocol(protocol);
        var normalizedEncodingName = NormalizeTextEncodingName(encodingName);
        var payload = Encoding.UTF8.GetBytes(text);
 
        return normalizedProtocol switch
        {
            DreamineEnvelopeProtocol => new MessageEnvelope
            {
                Name = $"Serial.{direction}.DreamineEnvelope",
                Route = "sample.communication.serial",
                Payload = payload,
                Headers = new Dictionary<string, string>
                {
                    ["Protocol"] = DreamineEnvelopeProtocol
                }
            },
 
            PlainTextProtocol => new MessageEnvelope
            {
                Name = $"Serial.{direction}.PlainText",
                Route = "serial.plaintext",
                Payload = payload,
                Headers = new Dictionary<string, string>
                {
                    ["ContentType"] = "text/plain",
                    ["Protocol"] = PlainTextProtocol,
                    ["ExternalEncoding"] = normalizedEncodingName
                }
            },
 
            RawAvailableProtocol => new MessageEnvelope
            {
                Name = $"Serial.{direction}.RawAvailable",
                Route = "serial.raw.available",
                Payload = payload,
                Headers = new Dictionary<string, string>
                {
                    ["ContentType"] = "text/plain",
                    ["Protocol"] = RawAvailableProtocol,
                    ["ExternalEncoding"] = normalizedEncodingName
                }
            },
 
            RawJsonProtocol => new MessageEnvelope
            {
                Name = $"Serial.{direction}.RawJson",
                Route = "serial.rawjson",
                Payload = EnsureJsonPayload(text),
                Headers = new Dictionary<string, string>
                {
                    ["ContentType"] = "application/json",
                    ["Protocol"] = RawJsonProtocol
                }
            },
 
            _ => new MessageEnvelope
            {
                Name = $"Serial.{direction}.PlainText",
                Route = "serial.plaintext",
                Payload = payload,
                Headers = new Dictionary<string, string>
                {
                    ["ContentType"] = "text/plain",
                    ["Protocol"] = PlainTextProtocol,
                    ["ExternalEncoding"] = normalizedEncodingName
                }
            }
        };
    }

    private static MessageEnvelope CreateRabbitMqMessage(
        string direction,
        string route,
        string text)
    {
        return new MessageEnvelope
        {
            Name = $"RabbitMQ.{direction}",
            Route = route,
            Payload = Encoding.UTF8.GetBytes(text),
            Headers = new Dictionary<string, string>
            {
                ["ContentType"] = "text/plain",
                ["Protocol"] = RabbitMqProtocol
            }
        };
    }

    private static MessageEnvelope CreateTextMessage(
        string name,
        string route,
        string text,
        string protocol)
    {
        return new MessageEnvelope
        {
            Name = name,
            Route = route,
            Payload = Encoding.UTF8.GetBytes(text),
            Headers = new Dictionary<string, string>
            {
                ["ContentType"] = "text/plain",
                ["Protocol"] = protocol
            }
        };
    }

    private void AddRabbitMqErrorLog(
        string name,
        string text)
    {
        var message = CreateTextMessage(
            name,
            _currentRabbitMqRoutingKey,
            text,
            RabbitMqProtocol);
 
        Monitor.AddReceiveLog(
            RabbitMqChannelName,
            TransportKind.RabbitMq,
            message);
    }

    private static byte[] EnsureJsonPayload(string text)
    {
        if (string.IsNullOrWhiteSpace(text))
        {
            text = "{\"cmd\":\"PING\"}";
        }
 
        var trimmed = text.Trim();
 
        if (trimmed.StartsWith("{", StringComparison.Ordinal) ||
            trimmed.StartsWith("[", StringComparison.Ordinal))
        {
            return Encoding.UTF8.GetBytes(trimmed);
        }
 
        var json = $$"""
        {"message":"{{EscapeJsonString(text)}}"}
        """;
 
        return Encoding.UTF8.GetBytes(json);
    }

    private static string EscapeJsonString(string value)
    {
        return value
            .Replace("\\", "\\\\", StringComparison.Ordinal)
            .Replace("\"", "\\\"", StringComparison.Ordinal)
            .Replace("\r", "\\r", StringComparison.Ordinal)
            .Replace("\n", "\\n", StringComparison.Ordinal);
    }

    private static TcpServerSendTargetMode NormalizeTcpServerSendTargetMode(string? sendTargetMode)
    {
        if (Enum.TryParse<TcpServerSendTargetMode>(
                sendTargetMode,
                ignoreCase: true,
                out var parsed))
        {
            return parsed;
        }
 
        return TcpServerSendTargetMode.Broadcast;
    }

    private static string NormalizeProtocol(string? protocol)
    {
        if (string.IsNullOrWhiteSpace(protocol))
        {
            return PlainTextProtocol;
        }
 
        return protocol.Trim() switch
        {
            DreamineEnvelopeProtocol => DreamineEnvelopeProtocol,
            PlainTextProtocol => PlainTextProtocol,
            RawAvailableProtocol => RawAvailableProtocol,
            RawJsonProtocol => RawJsonProtocol,
            _ => PlainTextProtocol
        };
    }

    private static string NormalizeText(
        string? value,
        string defaultValue)
    {
        return string.IsNullOrWhiteSpace(value)
            ? defaultValue
            : value.Trim();
    }

    private static void RunOnUiThread(Action action)
    {
        ArgumentNullException.ThrowIfNull(action);
 
        var dispatcher = Application.Current?.Dispatcher;
 
        if (dispatcher is null || dispatcher.CheckAccess())
        {
            action();
            return;
        }
 
        dispatcher.Invoke(action);
    }
}