XmppService.cs

//#define DEBUG_XMPP_REMOTE
//#define DEBUG_LOG_REMOTE
//#define DEBUG_DB_REMOTE
 
using EDaler;
using EDaler.Uris;
using Mopups.Services;
using NeuroAccessMaui.Extensions;
using NeuroAccessMaui.Resources.Languages;
using NeuroAccessMaui.Services.Contacts;
using NeuroAccessMaui.Services.Contracts;
using NeuroAccessMaui.Services.Notification.Things;
using NeuroAccessMaui.Services.Notification.Xmpp;
using NeuroAccessMaui.Services.Push;
using NeuroAccessMaui.Services.Tag;
using NeuroAccessMaui.Services.UI.Photos;
using NeuroAccessMaui.Services.Wallet;
using NeuroAccessMaui.UI.Pages.Contacts.Chat;
using NeuroAccessMaui.UI.Pages.Registration;
using NeuroAccessMaui.UI.Popups.Xmpp.ReportOrBlock;
using NeuroAccessMaui.UI.Popups.Xmpp.ReportType;
using NeuroAccessMaui.UI.Popups.Xmpp.SubscribeTo;
using NeuroAccessMaui.UI.Popups.Xmpp.SubscriptionRequest;
using NeuroFeatures;
using NeuroFeatures.Events;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Reflection;
using System.Text;
using System.Xml;
using Waher.Content;
using Waher.Content.Html;
using Waher.Content.Markdown;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Events.Filter;
using Waher.Events.XMPP;
using Waher.Networking.Sniffers;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.Abuse;
using Waher.Networking.XMPP.Concentrator;
using Waher.Networking.XMPP.Contracts;
using Waher.Networking.XMPP.Control;
using Waher.Networking.XMPP.DataForms;
using Waher.Networking.XMPP.HttpFileUpload;
using Waher.Networking.XMPP.HTTPX;
using Waher.Networking.XMPP.PEP;
using Waher.Networking.XMPP.Provisioning;
using Waher.Networking.XMPP.Provisioning.SearchOperators;
using Waher.Networking.XMPP.PubSub;
using Waher.Networking.XMPP.Push;
using Waher.Networking.XMPP.Sensor;
using Waher.Networking.XMPP.ServiceDiscovery;
using Waher.Networking.XMPP.StanzaErrors;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Persistence.XmlLedger;
using Waher.Runtime.Inventory;
using Waher.Runtime.Settings;
using Waher.Runtime.Temporary;
using Waher.Security.JWT;
using Waher.Things;
using Waher.Things.SensorData;
 
namespace NeuroAccessMaui.Services.Xmpp
{
    [Singleton]
    internal sealed class XmppService : LoadableService, IXmppService, IDisposable
    {
        //private bool isDisposed;
        private XmppClient? xmppClient;
        private ContractsClient? contractsClient;
        private HttpFileUploadClient? fileUploadClient;
        private ThingRegistryClient? thingRegistryClient;
        private ProvisioningClient? provisioningClient;
        private ControlClient? controlClient;
        private SensorClient? sensorClient;
        private ConcentratorClient? concentratorClient;
        private EDalerClient? eDalerClient;
        private NeuroFeaturesClient? neuroFeaturesClient;
        private PushNotificationClient? pushNotificationClient;
        private AbuseClient? abuseClient;
        private PepClient? pepClient;
        private HttpxClient? httpxClient;
        private Timer? reconnectTimer;
        private string? domainName;
        private string? accountName;
        private string? passwordHash;
        private string? passwordHashMethod;
        private bool xmppConnected = false;
        private DateTime xmppLastStateChange = DateTime.MinValue;
        private readonly InMemorySniffer? sniffer = new(250);
        private bool isCreatingClient;
        private EventFilter? xmppFilteredEventSink;
        private string? token = null;
        private DateTime tokenCreated = DateTime.MinValue;
#if DEBUG_XMPP_REMOTE || DEBUG_LOG_REMOTE || DEBUG_DB_REMOTE
        private const string debugRecipient = "";     // TODO: Set JID of recipient of debug messages.
#endif
#if DEBUG_XMPP_REMOTE || DEBUG_DB_REMOTE
        private RemoteSniffer? debugSniffer = null;
#endif
#if DEBUG_LOG_REMOTE
        private EventFilter? debugEventSink = null;
#endif
 
        #region Creation / Destruction
 
        public XmppService()
        {
        }
 
        private async Task CreateXmppClient()
        {
            if (this.isCreatingClient)
                return;
 
            try
            {
                this.isCreatingClient = true;
 
                if (!this.XmppParametersCurrent() || this.XmppStale())
                {
                    if (this.xmppClient is not null)
                        await this.DestroyXmppClient();
 
                    this.domainName = ServiceRef.TagProfile.Domain;
                    this.accountName = ServiceRef.TagProfile.Account;
                    this.passwordHash = ServiceRef.TagProfile.XmppPasswordHash;
                    this.passwordHashMethod = ServiceRef.TagProfile.XmppPasswordHashMethod;
 
                    string? HostName;
                    int PortNumber;
                    bool IsIpAddress;
 
                    if (ServiceRef.TagProfile.DefaultXmppConnectivity)
                    {
                        HostName = this.domainName;
                        PortNumber = XmppCredentials.DefaultPort;
                        IsIpAddress = false;
                    }
                    else
                    {
                        (HostName, PortNumber, IsIpAddress) = await ServiceRef.NetworkService.LookupXmppHostnameAndPort(this.domainName!);
 
                        if (HostName == this.domainName && PortNumber == XmppCredentials.DefaultPort)
                        {
                            ServiceRef.TagProfile.SetDomain(this.domainName, true, ServiceRef.TagProfile.ApiKey ?? string.Empty,
                                ServiceRef.TagProfile.ApiSecret ?? string.Empty);
                        }
                    }
 
                    this.xmppLastStateChange = DateTime.Now;
                    this.xmppConnected = false;
 
                    Assembly AppAssembly = App.Current!.GetType().Assembly;
 
                    if (string.IsNullOrEmpty(this.passwordHashMethod))
                    {
                        this.xmppClient = new XmppClient(HostName, PortNumber, this.accountName, this.passwordHash,
                            Constants.LanguageCodes.Default, AppAssembly, this.sniffer);
                    }
                    else
                    {
                        this.xmppClient = new XmppClient(HostName, PortNumber, this.accountName, this.passwordHash, this.passwordHashMethod,
                            Constants.LanguageCodes.Default, AppAssembly, this.sniffer);
                    }
 
#if DEBUG_XMPP_REMOTE || DEBUG_LOG_REMOTE || DEBUG_DB_REMOTE
                    if (!string.IsNullOrEmpty(debugRecipient))
                    {
#endif
#if DEBUG_XMPP_REMOTE || DEBUG_DB_REMOTE
                        this.debugSniffer = new RemoteSniffer(debugRecipient, DateTime.MaxValue, this.xmppClient, this.xmppClient,
                            ConcentratorServer.NamespaceConcentratorCurrent);
#endif
#if DEBUG_XMPP_REMOTE
                        this.xmppClient.Add(this.debugSniffer);
#endif
#if DEBUG_LOG_REMOTE
                        if (this.debugEventSink is not null)
                        {
                            Log.Unregister(this.debugEventSink);
                            this.debugEventSink?.Dispose();
                            this.debugEventSink = null;
                        }
 
                        this.debugEventSink = new EventFilter("Debug Event Filter",
                            new XmppEventSink("Debug Event Sink", this.xmppClient, debugRecipient, false),
                            EventType.Informational, (Event) =>
                            {
                                if (this.xmppClient is null || this.xmppClient.State != XmppState.Connected)
                                    return false;
 
                                return string.IsNullOrEmpty(Event.StackTrace) || !Event.StackTrace.Contains("XmppEventSink");
                            });
 
                        Log.Register(this.debugEventSink);
#endif
#if DEBUG_DB_REMOTE
                        if (!Ledger.HasProvider)
                        {
                            XmlFileLedger XmlFileLedger = new(new RemoteLedgerWriter());
                            Ledger.Register(XmlFileLedger);
 
                            await XmlFileLedger.Start();
 
                            Ledger.StartListeningToDatabaseEvents();
                        }
#endif
#if DEBUG_XMPP_REMOTE || DEBUG_LOG_REMOTE || DEBUG_DB_REMOTE
                    }
#endif
 
                    this.xmppClient.RequestRosterOnStartup = false;
                    this.xmppClient.TrustServer = !IsIpAddress;
                    this.xmppClient.AllowCramMD5 = false;
                    this.xmppClient.AllowDigestMD5 = false;
                    this.xmppClient.AllowPlain = false;
                    this.xmppClient.AllowEncryption = true;
                    this.xmppClient.AllowScramSHA1 = true;
                    this.xmppClient.AllowScramSHA256 = true;
                    this.xmppClient.AllowQuickLogin = true;
 
                    this.xmppClient.RequestRosterOnStartup = true;
                    this.xmppClient.OnStateChanged += this.XmppClient_StateChanged;
                    this.xmppClient.OnConnectionError += this.XmppClient_ConnectionError;
                    this.xmppClient.OnError += this.XmppClient_Error;
                    this.xmppClient.OnChatMessage += this.XmppClient_OnChatMessage;
                    this.xmppClient.OnNormalMessage += this.XmppClient_OnNormalMessage;
                    this.xmppClient.OnPresenceSubscribe += this.XmppClient_OnPresenceSubscribe;
                    this.xmppClient.OnPresenceUnsubscribed += this.XmppClient_OnPresenceUnsubscribed;
                    this.xmppClient.OnRosterItemAdded += this.XmppClient_OnRosterItemAdded;
                    this.xmppClient.OnRosterItemUpdated += this.XmppClient_OnRosterItemUpdated;
                    this.xmppClient.OnRosterItemRemoved += this.XmppClient_OnRosterItemRemoved;
                    this.xmppClient.OnPresence += this.XmppClient_OnPresence;
 
                    this.xmppClient.RegisterMessageHandler("Delivered", ContractsClient.NamespaceOnboarding, this.TransferIdDelivered, true);
                    this.xmppClient.RegisterMessageHandler("clientMessage", ContractsClient.NamespaceLegalIdentitiesCurrent, this.ClientMessage, true);
 
                    this.xmppFilteredEventSink = new EventFilter("XMPP Event Filter",
                        new XmppEventSink("XMPP Event Sink", this.xmppClient, ServiceRef.TagProfile.LogJid, false),
                        EventType.Error);
 
                    // Add extensions before connecting
 
                    this.abuseClient = new AbuseClient(this.xmppClient);
 
                    if (!string.IsNullOrWhiteSpace(ServiceRef.TagProfile.LegalJid))
                    {
                        this.contractsClient = new ContractsClient(this.xmppClient, ServiceRef.TagProfile.LegalJid);
                        this.RegisterContractsEventHandlers();
 
                        if (!await this.contractsClient.LoadKeys(false))
                        {
                            if (ServiceRef.TagProfile.IsCompleteOrWaitingForValidation())
                            {
                                Log.Alert("Regeneration of keys not permitted at this time.",
                                    string.Empty, string.Empty, string.Empty, EventLevel.Major, string.Empty, string.Empty, Environment.StackTrace);
 
                                throw new Exception("Regeneration of keys not permitted at this time.");
                            }
 
                            await this.GenerateNewKeys();
                        }
                    }
 
                    if (!string.IsNullOrWhiteSpace(ServiceRef.TagProfile.HttpFileUploadJid) && (ServiceRef.TagProfile.HttpFileUploadMaxSize > 0))
                        this.fileUploadClient = new HttpFileUploadClient(this.xmppClient, ServiceRef.TagProfile.HttpFileUploadJid, ServiceRef.TagProfile.HttpFileUploadMaxSize);
 
                    if (!string.IsNullOrWhiteSpace(ServiceRef.TagProfile.RegistryJid))
                        this.thingRegistryClient = new ThingRegistryClient(this.xmppClient, ServiceRef.TagProfile.RegistryJid);
 
                    if (!string.IsNullOrWhiteSpace(ServiceRef.TagProfile.ProvisioningJid))
                    {
                        this.provisioningClient = new ProvisioningClient(this.xmppClient, ServiceRef.TagProfile.ProvisioningJid)
                        {
                            ManagePresenceSubscriptionRequests = false
                        };
 
                        this.provisioningClient.CanControlQuestion += this.ProvisioningClient_CanControlQuestion;
                        this.provisioningClient.CanReadQuestion += this.ProvisioningClient_CanReadQuestion;
                        this.provisioningClient.IsFriendQuestion += this.ProvisioningClient_IsFriendQuestion;
                    }
 
                    if (!string.IsNullOrWhiteSpace(ServiceRef.TagProfile.EDalerJid))
                    {
                        this.eDalerClient = new EDalerClient(this.xmppClient, this.contractsClient, ServiceRef.TagProfile.EDalerJid);
                        this.RegisterEDalerEventHandlers(this.eDalerClient);
                    }
 
                    if (!string.IsNullOrWhiteSpace(ServiceRef.TagProfile.NeuroFeaturesJid))
                    {
                        this.neuroFeaturesClient = new NeuroFeaturesClient(this.xmppClient, this.contractsClient, ServiceRef.TagProfile.NeuroFeaturesJid);
                        this.RegisterNeuroFeatureEventHandlers(this.neuroFeaturesClient);
                    }
 
                    if (ServiceRef.TagProfile.SupportsPushNotification)
                        this.pushNotificationClient = new PushNotificationClient(this.xmppClient);
 
                    this.sensorClient = new SensorClient(this.xmppClient);
                    this.controlClient = new ControlClient(this.xmppClient);
                    this.concentratorClient = new ConcentratorClient(this.xmppClient);
 
                    this.pepClient = new PepClient(this.xmppClient);
                    this.ReregisterPepEventHandlers(this.pepClient);
 
                    this.httpxClient = new HttpxClient(this.xmppClient, 8192);
                    Types.SetModuleParameter("XMPP", this.xmppClient);      // Makes the XMPP Client the default XMPP client, when resolving HTTP over XMPP requests.
 
                    this.IsLoggedOut = false;
                    this.xmppClient.Connect(IsIpAddress ? string.Empty : this.domainName);
                    this.RecreateReconnectTimer();
 
                    // Await connected state during registration or user initiated log in, but not otherwise.
                    if (!ServiceRef.TagProfile.IsCompleteOrWaitingForValidation())
                    {
                        if (!await this.WaitForConnectedState(Constants.Timeouts.XmppConnect))
                        {
                            ServiceRef.LogService.LogWarning("Connection to XMPP server failed.",
                                new KeyValuePair<string, object?>("Domain", this.domainName ?? string.Empty),
                                new KeyValuePair<string, object?>("Account", this.accountName ?? string.Empty),
                                new KeyValuePair<string, object?>("Timeout", Constants.Timeouts.XmppConnect));
                        }
                    }
                }
            }
            finally
            {
                this.isCreatingClient = false;
            }
        }
 
#if DEBUG_DB_REMOTE
        private class RemoteLedgerWriter()
            : TextWriter(CultureInfo.CurrentCulture)
        {
            private readonly StringBuilder sb = new();
 
            public override Encoding Encoding => Encoding.Unicode;
            public override void Flush() => this.FlushAsync().Wait();
            public override Task FlushAsync(CancellationToken cancellationToken) => this.FlushAsync();
 
            public override async Task FlushAsync()
            {
                try
                {
                    string s = this.sb.ToString();
                    string s2 = s.TrimStart();
                    if (string.IsNullOrEmpty(s2))
                        return;
 
                    if (ServiceRef.XmppService is not XmppService Service)
                        return;
 
                    RemoteSniffer? Sniffer = Service.debugSniffer;
                    if (Sniffer is null)
                        return;
 
                    this.sb.Clear();
 
                    int i = s2.IndexOf('<');
                    if (i > 0)
                        s2 = s2[i..];
 
                    string[] Rows = s.Replace("\r\n", "\n").Replace('\r', '\n').Split('\n');
 
                    if (s2.StartsWith("<New", StringComparison.OrdinalIgnoreCase))
                    {
                        foreach (string Row in Rows)
                            await Sniffer.TransmitText(Row);
                    }
                    else if (s2.StartsWith("<Update", StringComparison.OrdinalIgnoreCase))
                    {
                        foreach (string Row in Rows)
                            await Sniffer.ReceiveText(Row);
                    }
                    else if (s2.StartsWith("<Delete", StringComparison.OrdinalIgnoreCase))
                    {
                        foreach (string Row in Rows)
                            await Sniffer.Error(Row);
                    }
                    else if (s2.StartsWith("<Clear", StringComparison.OrdinalIgnoreCase))
                    {
                        foreach (string Row in Rows)
                            await Sniffer.Warning(Row);
                    }
                    else
                    {
                        foreach (string Row in Rows)
                            await Sniffer.Information(Row);
                    }
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
 
            public override void Write(char value) => this.sb.Append(value);
            public override void Write(char[]? buffer) => this.sb.Append(buffer);
            public override void Write(char[] buffer, int index, int count) => this.sb.Append(new string(buffer, index, count));
            public override void Write(ReadOnlySpan<char> buffer) => this.sb.Append(new string(buffer));
            public override void Write(bool value) => this.sb.Append(value);
            public override void Write(int value) => this.sb.Append(value);
            public override void Write(uint value) => this.sb.Append(value);
            public override void Write(long value) => this.sb.Append(value);
            public override void Write(ulong value) => this.sb.Append(value);
            public override void Write(float value) => this.sb.Append(value);
            public override void Write(double value) => this.sb.Append(value);
            public override void Write(decimal value) => this.sb.Append(value);
            public override void Write(string? value) => this.sb.Append(value);
            public override void Write(object? value) => this.sb.Append(value);
            public override void Write(StringBuilder? value) => this.sb.Append(value);
            public override void Write([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, object? arg0) => this.sb.Append(string.Format(this.FormatProvider, format, arg0));
            public override void Write([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, object? arg0, object? arg1) => this.sb.Append(string.Format(this.FormatProvider, format, arg0, arg1));
            public override void Write([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, object? arg0, object? arg1, object? arg2) => this.sb.Append(string.Format(this.FormatProvider, format, arg0, arg1, arg2));
            public override void Write([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params object?[] arg) => this.sb.Append(string.Format(this.FormatProvider, format, arg));
            public override Task WriteAsync(char value) { this.sb.Append(value); return Task.CompletedTask; }
            public override Task WriteAsync(string? value) { this.sb.Append(value); return Task.CompletedTask; }
            public override Task WriteAsync(StringBuilder? value, CancellationToken cancellationToken = default) { this.sb.Append(value); return Task.CompletedTask; }
            public override Task WriteAsync(char[] buffer, int index, int count) { this.sb.Append(new string(buffer, index, count)); return Task.CompletedTask; }
            public override Task WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default) { this.sb.Append(buffer); return Task.CompletedTask; }
            public override void WriteLine() => this.sb.AppendLine(string.Empty);
            public override void WriteLine(char value) => this.sb.AppendLine(value.ToString());
            public override void WriteLine(char[]? buffer) => this.sb.AppendLine(new string(buffer));
            public override void WriteLine(char[] buffer, int index, int count) => this.sb.AppendLine(new string(buffer, index, count));
            public override void WriteLine(ReadOnlySpan<char> buffer) => this.sb.AppendLine(new string(buffer));
            public override void WriteLine(bool value) => this.sb.AppendLine(value.ToString());
            public override void WriteLine(int value) => this.sb.AppendLine(value.ToString(CultureInfo.CurrentCulture));
            public override void WriteLine(uint value) => this.sb.AppendLine(value.ToString(CultureInfo.CurrentCulture));
            public override void WriteLine(long value) => this.sb.AppendLine(value.ToString(CultureInfo.CurrentCulture));
            public override void WriteLine(ulong value) => this.sb.AppendLine(value.ToString(CultureInfo.CurrentCulture));
            public override void WriteLine(float value) => this.sb.AppendLine(value.ToString(CultureInfo.CurrentCulture));
            public override void WriteLine(double value) => this.sb.AppendLine(value.ToString(CultureInfo.CurrentCulture));
            public override void WriteLine(decimal value) => this.sb.AppendLine(value.ToString(CultureInfo.CurrentCulture));
            public override void WriteLine(string? value) => this.sb.AppendLine(value?.ToString());
            public override void WriteLine(StringBuilder? value) => this.sb.AppendLine(value?.ToString());
            public override void WriteLine(object? value) => this.sb.AppendLine(value?.ToString());
            public override void WriteLine([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, object? arg0) => this.sb.AppendLine(string.Format(this.FormatProvider, format, arg0));
            public override void WriteLine([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, object? arg0, object? arg1) => this.sb.AppendLine(string.Format(this.FormatProvider, format, arg0, arg1));
            public override void WriteLine([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, object? arg0, object? arg1, object? arg2) => this.sb.AppendLine(string.Format(this.FormatProvider, format, arg0, arg1, arg2));
            public override void WriteLine([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params object?[] arg) => this.sb.AppendLine(string.Format(this.FormatProvider, format, arg));
            public override Task WriteLineAsync(char value) { this.sb.AppendLine(value.ToString()); return Task.CompletedTask; }
            public override Task WriteLineAsync(string? value) { this.sb.AppendLine(value); return Task.CompletedTask; }
            public override Task WriteLineAsync(StringBuilder? value, CancellationToken cancellationToken = default) { this.sb.AppendLine(value?.ToString()); return Task.CompletedTask; }
            public override Task WriteLineAsync(char[] buffer, int index, int count) { this.sb.AppendLine(new string(buffer, index, count)); return Task.CompletedTask; }
            public override Task WriteLineAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default) { this.sb.AppendLine(new string(buffer.Span)); return Task.CompletedTask; }
            public override Task WriteLineAsync() { this.sb.AppendLine(string.Empty); return Task.CompletedTask; }
        }
#endif
 
        private async Task DestroyXmppClient()
        {
            this.reconnectTimer?.Dispose();
            this.reconnectTimer = null;
 
            await this.OnConnectionStateChanged(XmppState.Offline);
 
            if (this.xmppFilteredEventSink is not null)
            {
                ServiceRef.LogService.RemoveListener(this.xmppFilteredEventSink);
                this.xmppFilteredEventSink.SecondarySink.Dispose();
                this.xmppFilteredEventSink.Dispose();
                this.xmppFilteredEventSink = null;
            }
 
            this.contractsClient?.Dispose();
            this.contractsClient = null;
 
            this.fileUploadClient?.Dispose();
            this.fileUploadClient = null;
 
            this.thingRegistryClient?.Dispose();
            this.thingRegistryClient = null;
 
            this.provisioningClient?.Dispose();
            this.provisioningClient = null;
 
            this.eDalerClient?.Dispose();
            this.eDalerClient = null;
 
            this.neuroFeaturesClient?.Dispose();
            this.neuroFeaturesClient = null;
 
            this.pushNotificationClient?.Dispose();
            this.pushNotificationClient = null;
 
            this.sensorClient?.Dispose();
            this.sensorClient = null;
 
            this.controlClient?.Dispose();
            this.controlClient = null;
 
            this.concentratorClient?.Dispose();
            this.concentratorClient = null;
 
            this.pepClient?.Dispose();
            this.pepClient = null;
 
            this.abuseClient?.Dispose();
            this.abuseClient = null;
 
#if DEBUG_DB_REMOTE
            this.debugSniffer = null;
#endif
#if DEBUG_LOG_REMOTE
            if (this.debugEventSink is not null)
            {
                Log.Unregister(this.debugEventSink);
                this.debugEventSink?.Dispose();
                this.debugEventSink = null;
            }
#endif
            this.xmppClient?.Dispose();
            this.xmppClient = null;
        }
 
        private bool XmppStale()
        {
            return this.xmppClient is null ||
                this.xmppClient.State == XmppState.Offline ||
                this.xmppClient.State == XmppState.Error ||
                (this.xmppClient.State != XmppState.Connected && (DateTime.Now - this.xmppLastStateChange).TotalSeconds >= 10);
        }
 
        private bool XmppParametersCurrent()
        {
            if (this.xmppClient is null)
                return false;
 
            if (this.domainName != ServiceRef.TagProfile.Domain)
                return false;
 
            if (this.accountName != ServiceRef.TagProfile.Account)
                return false;
 
            if (this.passwordHash != ServiceRef.TagProfile.XmppPasswordHash)
                return false;
 
            if (this.passwordHashMethod != ServiceRef.TagProfile.XmppPasswordHashMethod)
                return false;
 
            if (this.contractsClient?.ComponentAddress != ServiceRef.TagProfile.LegalJid)
                return false;
 
            if (this.fileUploadClient?.FileUploadJid != ServiceRef.TagProfile.HttpFileUploadJid)
                return false;
 
            if (this.thingRegistryClient?.ThingRegistryAddress != ServiceRef.TagProfile.RegistryJid)
                return false;
 
            if (this.provisioningClient?.ProvisioningServerAddress != ServiceRef.TagProfile.ProvisioningJid)
                return false;
 
            if (this.eDalerClient?.ComponentAddress != ServiceRef.TagProfile.EDalerJid)
                return false;
 
            if (this.neuroFeaturesClient?.ComponentAddress != ServiceRef.TagProfile.NeuroFeaturesJid)
                return false;
 
            if ((this.pushNotificationClient is null) ^ !ServiceRef.TagProfile.SupportsPushNotification)
                return false;
 
            return true;
        }
 
        private void RecreateReconnectTimer()
        {
            this.reconnectTimer?.Dispose();
            this.reconnectTimer = new Timer(this.ReconnectTimer_Tick, null, Constants.Intervals.Reconnect, Constants.Intervals.Reconnect);
        }
 
        public void Dispose()
        {
            this.reconnectTimer?.Dispose();
            this.reconnectTimer = null;
 
            if (this.xmppFilteredEventSink is not null)
            {
                ServiceRef.LogService.RemoveListener(this.xmppFilteredEventSink);
                this.xmppFilteredEventSink.SecondarySink.Dispose();
                this.xmppFilteredEventSink.Dispose();
                this.xmppFilteredEventSink = null;
            }
 
            this.contractsClient?.Dispose();
            this.contractsClient = null;
 
            this.fileUploadClient?.Dispose();
            this.fileUploadClient = null;
 
            this.thingRegistryClient?.Dispose();
            this.thingRegistryClient = null;
 
            this.provisioningClient?.Dispose();
            this.provisioningClient = null;
 
            this.eDalerClient?.Dispose();
            this.eDalerClient = null;
 
            this.neuroFeaturesClient?.Dispose();
            this.neuroFeaturesClient = null;
 
            this.pushNotificationClient?.Dispose();
            this.pushNotificationClient = null;
 
            this.sensorClient?.Dispose();
            this.sensorClient = null;
 
            this.controlClient?.Dispose();
            this.controlClient = null;
 
            this.concentratorClient?.Dispose();
            this.concentratorClient = null;
 
            this.pepClient?.Dispose();
            this.pepClient = null;
 
            this.abuseClient?.Dispose();
            this.abuseClient = null;
 
            this.xmppClient?.Dispose();
            this.xmppClient = null;
 
            /*
            this.Dispose(true);
            GC.SuppressFinalize(this);
            */
        }
 
        /*
        protected virtual void Dispose(bool disposing)
        {
            if (this.isDisposed)
            {
                return;
            }
 
            if (disposing)
            {
                this.abuseClient.Dispose();
                this.contractsClient.Dispose();
                this.fileUploadClient.Dispose();
                this.httpxClient.Dispose();
                this.reconnectTimer.Dispose();
                this.sniffer.Dispose();
                this.xmppClient.Dispose();
                this.xmppFilteredEventSink.SecondarySink.Dispose();
                this.xmppFilteredEventSink.Dispose();
            }
 
            this.isDisposed = true;
        }
        */
        #endregion
 
        #region Lifecycle
 
        public async Task<bool> WaitForConnectedState(TimeSpan Timeout)
        {
            if (this.xmppClient is null)
            {
                DateTime Start = DateTime.Now;
 
                while (this.xmppClient is null && DateTime.Now - Start < Timeout)
                    await Task.Delay(1000);
 
                if (this.xmppClient is null)
                    return false;
 
                Timeout -= DateTime.Now - Start;
            }
 
            if (this.xmppClient.State == XmppState.Connected)
                return true;
 
            if (Timeout < TimeSpan.Zero)
                return false;
 
            int i = await this.xmppClient.WaitStateAsync((int)Timeout.TotalMilliseconds, XmppState.Connected);
            return i >= 0;
        }
 
        public override async Task Load(bool IsResuming, CancellationToken CancellationToken)
        {
            if (this.BeginLoad(IsResuming, CancellationToken))
            {
                try
                {
                    ServiceRef.TagProfile.StepChanged += this.TagProfile_StepChanged;
                    ServiceRef.TagProfile.Changed += this.TagProfile_Changed;
 
                    if (ServiceRef.TagProfile.ShouldCreateClient() && !this.XmppParametersCurrent())
                        await this.CreateXmppClient();
 
                    if ((this.xmppClient is not null) &&
                        this.xmppClient.State == XmppState.Connected &&
                        ServiceRef.TagProfile.IsCompleteOrWaitingForValidation())
                    {
                        // Don't await this one, just fire and forget, to improve startup time.
                        _ = this.xmppClient.SetPresenceAsync(Availability.Online);
                    }
 
                    this.EndLoad(true);
                }
                catch (Exception ex)
                {
                    ex = Log.UnnestException(ex);
                    ServiceRef.LogService.LogException(ex, this.GetClassAndMethod(MethodBase.GetCurrentMethod()));
                    this.EndLoad(false);
                }
            }
        }
 
        public override Task Unload()
        {
            return this.Unload(false);
        }
 
        public Task UnloadFast()
        {
            return this.Unload(true);
        }
 
        private async Task Unload(bool fast)
        {
            if (this.BeginUnload())
            {
                try
                {
                    ServiceRef.TagProfile.StepChanged -= this.TagProfile_StepChanged;
                    ServiceRef.TagProfile.Changed -= this.TagProfile_Changed;
 
                    this.reconnectTimer?.Dispose();
                    this.reconnectTimer = null;
 
                    if (this.xmppClient is not null)
                    {
                        this.xmppClient.CheckConnection = false;
 
                        if (!fast)
                        {
                            try
                            {
                                await Task.WhenAny(
                                    this.xmppClient.SetPresenceAsync(Availability.Offline),
                                    Task.Delay(1000)    // Wait at most 1000 ms.
                                );
                            }
                            catch (Exception)
                            {
                                // Ignore
                            }
                        }
                    }
 
                    await this.DestroyXmppClient();
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex, this.GetClassAndMethod(MethodBase.GetCurrentMethod()));
                }
 
                this.EndUnload();
            }
        }
 
        private void TagProfile_StepChanged(object? Sender, EventArgs e)
        {
            if (!this.IsLoaded)
                return;
 
            Task ExecutionTask = Task.Run(async () =>
            {
                try
                {
                    bool CreateXmppClient = ServiceRef.TagProfile.ShouldCreateClient();
 
                    if (CreateXmppClient && !this.XmppParametersCurrent())
                        await this.CreateXmppClient();
                    else if (!CreateXmppClient)
                        await this.DestroyXmppClient();
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex);
                }
            });
        }
 
        private void TagProfile_Changed(object? Sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == nameof(ITagProfile.Account))
                this.TagProfile_StepChanged(Sender, new EventArgs());
        }
 
        private Task XmppClient_Error(object? _, Exception e)
        {
            this.LatestError = e.Message;
            return Task.CompletedTask;
        }
 
        private Task XmppClient_ConnectionError(object? _, Exception e)
        {
            if (e is ObjectDisposedException)
                this.LatestConnectionError = ServiceRef.Localizer[nameof(AppResources.UnableToConnect)];
            else
                this.LatestConnectionError = e.Message;
 
            return Task.CompletedTask;
        }
 
        private async Task XmppClient_StateChanged(object? Sender, XmppState NewState)
        {
            this.xmppLastStateChange = DateTime.Now;
 
            switch (NewState)
            {
                case XmppState.Connecting:
                    this.LatestError = string.Empty;
                    this.LatestConnectionError = string.Empty;
                    break;
 
                case XmppState.Connected:
                    this.LatestError = string.Empty;
                    this.LatestConnectionError = string.Empty;
 
                    this.xmppConnected = true;
 
                    this.RecreateReconnectTimer();
 
                    if (string.IsNullOrEmpty(ServiceRef.TagProfile.XmppPasswordHashMethod))
                    {
                        ServiceRef.TagProfile.SetAccount(ServiceRef.TagProfile.Account ?? string.Empty,
                            this.xmppClient?.PasswordHash ?? string.Empty,
                            this.xmppClient?.PasswordHashMethod ?? string.Empty);
                    }
 
                    if (ServiceRef.TagProfile.NeedsUpdating() && await this.DiscoverServices())
                    {
                        if (this.contractsClient is null && !string.IsNullOrWhiteSpace(ServiceRef.TagProfile.LegalJid))
                        {
                            this.contractsClient = new ContractsClient(this.xmppClient, ServiceRef.TagProfile.LegalJid);
                            this.RegisterContractsEventHandlers();
 
                            if (!await this.contractsClient.LoadKeys(false))
                            {
                                this.contractsClient.Dispose();
                                this.contractsClient = null;
                            }
                        }
 
                        if (this.fileUploadClient is null && !string.IsNullOrWhiteSpace(ServiceRef.TagProfile.HttpFileUploadJid) && (ServiceRef.TagProfile.HttpFileUploadMaxSize > 0))
                            this.fileUploadClient = new HttpFileUploadClient(this.xmppClient, ServiceRef.TagProfile.HttpFileUploadJid, ServiceRef.TagProfile.HttpFileUploadMaxSize);
 
                        if (this.thingRegistryClient is null && !string.IsNullOrWhiteSpace(ServiceRef.TagProfile.RegistryJid))
                            this.thingRegistryClient = new ThingRegistryClient(this.xmppClient, ServiceRef.TagProfile.RegistryJid);
 
                        if (this.provisioningClient is null && !string.IsNullOrWhiteSpace(ServiceRef.TagProfile.RegistryJid))
                        {
                            this.provisioningClient = new ProvisioningClient(this.xmppClient, ServiceRef.TagProfile.ProvisioningJid)
                            {
                                ManagePresenceSubscriptionRequests = false
                            };
 
                            this.provisioningClient.CanControlQuestion += this.ProvisioningClient_CanControlQuestion;
                            this.provisioningClient.CanReadQuestion += this.ProvisioningClient_CanReadQuestion;
                            this.provisioningClient.IsFriendQuestion += this.ProvisioningClient_IsFriendQuestion;
                        }
 
                        if (this.eDalerClient is null && !string.IsNullOrWhiteSpace(ServiceRef.TagProfile.EDalerJid))
                        {
                            this.eDalerClient = new EDalerClient(this.xmppClient, this.contractsClient, ServiceRef.TagProfile.EDalerJid);
                            this.RegisterEDalerEventHandlers(this.eDalerClient);
                        }
 
                        if (this.neuroFeaturesClient is null && !string.IsNullOrWhiteSpace(ServiceRef.TagProfile.NeuroFeaturesJid))
                        {
                            this.neuroFeaturesClient = new NeuroFeaturesClient(this.xmppClient, this.contractsClient, ServiceRef.TagProfile.NeuroFeaturesJid);
                            this.RegisterNeuroFeatureEventHandlers(this.neuroFeaturesClient);
                        }
 
                        if (this.pushNotificationClient is null && ServiceRef.TagProfile.SupportsPushNotification)
                            this.pushNotificationClient = new PushNotificationClient(this.xmppClient);
                    }
 
                    ServiceRef.LogService.AddListener(this.xmppFilteredEventSink!);
 
                    await ServiceRef.PushNotificationService.CheckPushNotificationToken();
                    break;
 
                case XmppState.Offline:
                case XmppState.Error:
                    if (this.xmppConnected && !this.IsUnloading)
                    {
                        this.xmppConnected = false;
 
                        if (this.xmppClient is not null && !this.xmppClient.Disposed)
                            this.xmppClient.Reconnect();
                    }
                    break;
            }
 
            await this.OnConnectionStateChanged(NewState);
        }
 
        public event StateChangedEventHandler? ConnectionStateChanged;
 
        private async Task OnConnectionStateChanged(XmppState NewState)
        {
            try
            {
                Task? T = this.ConnectionStateChanged?.Invoke(this, NewState);
 
                if (T is not null)
                    await T;
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        #endregion
 
        #region State
 
        public bool IsLoggedOut { get; private set; }
        public bool IsOnline => (this.xmppClient is not null) && this.xmppClient.State == XmppState.Connected;
        public XmppState State => this.xmppClient?.State ?? XmppState.Offline;
        public string BareJid => this.xmppClient?.BareJID ?? string.Empty;
 
        public string? LatestError { get; private set; }
        public string? LatestConnectionError { get; private set; }
 
        #endregion
 
        #region Connections
 
        private enum ConnectOperation
        {
            Connect,
            ConnectAndCreateAccount,
            ConnectToAccount
        }
 
        public Task<(bool Succeeded, string? ErrorMessage, string[]? Alternatives)> TryConnect(string domain, bool isIpAddress, string hostName, int portNumber,
            string languageCode, Assembly applicationAssembly, Func<XmppClient, Task> connectedFunc)
        {
            return this.TryConnectInner(domain, isIpAddress, hostName, portNumber, string.Empty, string.Empty, string.Empty, languageCode,
                string.Empty, string.Empty, applicationAssembly, connectedFunc, ConnectOperation.Connect);
        }
 
        public Task<(bool Succeeded, string? ErrorMessage, string[]? Alternatives)> TryConnectAndCreateAccount(string domain, bool isIpAddress, string hostName,
            int portNumber, string userName, string password, string languageCode, string ApiKey, string ApiSecret,
            Assembly applicationAssembly, Func<XmppClient, Task> connectedFunc)
        {
            return this.TryConnectInner(domain, isIpAddress, hostName, portNumber, userName, password, string.Empty, languageCode,
                ApiKey, ApiSecret, applicationAssembly, connectedFunc, ConnectOperation.ConnectAndCreateAccount);
        }
 
        public Task<(bool Succeeded, string? ErrorMessage, string[]? Alternatives)> TryConnectAndConnectToAccount(string domain, bool isIpAddress, string hostName,
            int portNumber, string userName, string password, string passwordMethod, string languageCode, Assembly applicationAssembly,
            Func<XmppClient, Task> connectedFunc)
        {
            return this.TryConnectInner(domain, isIpAddress, hostName, portNumber, userName, password, passwordMethod, languageCode,
                string.Empty, string.Empty, applicationAssembly, connectedFunc, ConnectOperation.ConnectToAccount);
        }
 
        private async Task<(bool Succeeded, string? ErrorMessage, string[]? Alternatives)> TryConnectInner(string Domain, bool IsIpAddress, string HostName,
            int PortNumber, string UserName, string Password, string PasswordMethod, string LanguageCode, string ApiKey, string ApiSecret,
            Assembly ApplicationAssembly, Func<XmppClient, Task> ConnectedFunc, ConnectOperation Operation)
        {
            TaskCompletionSource<bool> Connected = new();
            bool Succeeded;
            string? ErrorMessage = null;
            bool StreamNegotiation = false;
            bool StreamOpened = false;
            bool StartingEncryption = false;
            bool Authenticating = false;
            bool Registering = false;
            bool IsTimeout = false;
            string? ConnectionError = null;
            string[]? Alternatives = null;
 
            Task OnConnectionError(object _, Exception e)
            {
                if (e is ObjectDisposedException)
                    ConnectionError = ServiceRef.Localizer[nameof(AppResources.UnableToConnect)];
                else if (e is ConflictException ConflictInfo)
                    Alternatives = ConflictInfo.Alternatives;
                else
                    ConnectionError = e.Message;
 
                Connected.TrySetResult(false);
                return Task.CompletedTask;
            }
 
            async Task OnStateChanged(object _, XmppState newState)
            {
                switch (newState)
                {
                    case XmppState.StreamNegotiation:
                        StreamNegotiation = true;
                        break;
 
                    case XmppState.StreamOpened:
                        StreamOpened = true;
                        break;
 
                    case XmppState.StartingEncryption:
                        StartingEncryption = true;
                        break;
 
                    case XmppState.Authenticating:
                        Authenticating = true;
 
                        if (Operation == ConnectOperation.Connect)
                            Connected.TrySetResult(true);
 
                        break;
 
                    case XmppState.Registering:
                        Registering = true;
                        break;
 
                    case XmppState.Connected:
                        Connected.TrySetResult(true);
                        break;
 
                    case XmppState.Offline:
                        Connected.TrySetResult(false);
                        break;
 
                    case XmppState.Error:
                        // When State = Error, wait for the OnConnectionError event to arrive also, as it holds more/direct information.
                        // Just in case it never would - set state error and result.
                        await Task.Delay(Constants.Timeouts.XmppConnect);
                        Connected.TrySetResult(false);
                        break;
                }
            }
 
            XmppClient? Client = null;
            try
            {
                if (string.IsNullOrEmpty(PasswordMethod))
                    Client = new XmppClient(HostName, PortNumber, UserName, Password, LanguageCode, ApplicationAssembly, this.sniffer);
                else
                    Client = new XmppClient(HostName, PortNumber, UserName, Password, PasswordMethod, LanguageCode, ApplicationAssembly, this.sniffer);
 
                if (Operation == ConnectOperation.ConnectAndCreateAccount)
                {
                    if (!string.IsNullOrEmpty(ApiKey) && !string.IsNullOrEmpty(ApiSecret))
                        Client.AllowRegistration(ApiKey, ApiSecret);
                    else
                        Client.AllowRegistration();
                }
 
                Client.TrustServer = !IsIpAddress;
                Client.AllowCramMD5 = false;
                Client.AllowDigestMD5 = false;
                Client.AllowPlain = false;
                Client.AllowEncryption = true;
                Client.AllowScramSHA1 = true;
                Client.AllowScramSHA256 = true;
                Client.AllowQuickLogin = true;
 
                Client.OnConnectionError += OnConnectionError;
                Client.OnStateChanged += OnStateChanged;
 
                Client.Connect(IsIpAddress ? string.Empty : Domain);
 
                void TimerCallback(object? _)
                {
                    IsTimeout = true;
                    Connected.TrySetResult(false);
                }
 
                using Timer _ = new(TimerCallback, null, (int)Constants.Timeouts.XmppConnect.TotalMilliseconds, Timeout.Infinite);
                Succeeded = await Connected.Task;
 
                if (Succeeded && (ConnectedFunc is not null))
                    await ConnectedFunc(Client);
 
                Client.OnStateChanged -= OnStateChanged;
                Client.OnConnectionError -= OnConnectionError;
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex, new KeyValuePair<string, object?>(nameof(ConnectOperation), Operation.ToString()));
                Succeeded = false;
                ErrorMessage = ServiceRef.Localizer[nameof(AppResources.UnableToConnectTo), Domain];
            }
            finally
            {
                Client?.Dispose();
                Client = null;
            }
 
            if (!Succeeded && string.IsNullOrEmpty(ErrorMessage))
            {
                if (this.sniffer is not null)
                    System.Diagnostics.Debug.WriteLine("Sniffer: ", await this.sniffer.SnifferToText());
 
                if (!StreamNegotiation || IsTimeout)
                    ErrorMessage = ServiceRef.Localizer[nameof(AppResources.CantConnectTo), Domain];
                else if (!StreamOpened)
                    ErrorMessage = ServiceRef.Localizer[nameof(AppResources.DomainIsNotAValidOperator), Domain];
                else if (!StartingEncryption)
                    ErrorMessage = ServiceRef.Localizer[nameof(AppResources.DomainDoesNotFollowEncryptionPolicy), Domain];
                else if (!Authenticating)
                    ErrorMessage = ServiceRef.Localizer[nameof(AppResources.UnableToAuthenticateWith), Domain];
                else if (!Registering)
                {
                    if (!string.IsNullOrWhiteSpace(ConnectionError))
                        ErrorMessage = ConnectionError;
                    else
                        ErrorMessage = ServiceRef.Localizer[nameof(AppResources.OperatorDoesNotSupportRegisteringNewAccounts), Domain];
                }
                else if (Operation == ConnectOperation.ConnectAndCreateAccount)
                    ErrorMessage = ServiceRef.Localizer[nameof(AppResources.UsernameNameAlreadyTaken), this.accountName ?? string.Empty];
                else if (Operation == ConnectOperation.ConnectToAccount)
                    ErrorMessage = ServiceRef.Localizer[nameof(AppResources.InvalidUsernameOrPassword), this.accountName ?? string.Empty];
                else
                    ErrorMessage = ServiceRef.Localizer[nameof(AppResources.UnableToConnectTo), Domain];
            }
 
            return (Succeeded, ErrorMessage, Alternatives);
        }
 
        private void ReconnectTimer_Tick(object? _)
        {
            if (this.xmppClient is null)
                return;
 
            if (!ServiceRef.NetworkService.IsOnline)
                return;
 
            if (this.XmppStale())
            {
                this.xmppLastStateChange = DateTime.Now;
 
                if (!this.xmppClient.Disposed)
                    this.xmppClient.Reconnect();
            }
        }
 
        #endregion
 
        #region Password
 
        public Task<bool> ChangePassword(string NewPassword)
        {
            TaskCompletionSource<bool> PasswordChanged = new();
 
            this.XmppClient.ChangePassword(NewPassword, (sender, e) =>
            {
                PasswordChanged.TrySetResult(e.Ok);
                return Task.CompletedTask;
            }, null);
 
            return PasswordChanged.Task;
        }
 
        #endregion
 
        #region Components & Services
 
        public Task<ServiceDiscoveryEventArgs> SendServiceDiscoveryRequest(string FullJid)
        {
            TaskCompletionSource<ServiceDiscoveryEventArgs> Result = new();
 
            this.XmppClient.SendServiceDiscoveryRequest(FullJid, (_, e) =>
            {
                Result.TrySetResult(e);
                return Task.CompletedTask;
            }, null);
 
            return Result.Task;
        }
 
        public async Task<bool> DiscoverServices(XmppClient? Client = null)
        {
            Client ??= this.xmppClient;
 
            if (Client is null)
                return false;
 
            ServiceItemsDiscoveryEventArgs response;
 
            try
            {
                response = await Client.ServiceItemsDiscoveryAsync(null, string.Empty, string.Empty);
            }
            catch (Exception ex)
            {
                if (this.sniffer is not null)
                {
                    string commsDump = await this.sniffer.SnifferToText();
                    ServiceRef.LogService.LogException(ex, new KeyValuePair<string, object?>("Sniffer", commsDump));
                }
 
                return false;
            }
 
            List<Task> Tasks = [];
            object SynchObject = new();
 
            Tasks.Add(CheckFeatures(Client, SynchObject));
 
            foreach (Item Item in response.Items)
                Tasks.Add(CheckComponent(Client, Item, SynchObject));
 
            await Task.WhenAll([.. Tasks]);
 
            if (string.IsNullOrWhiteSpace(ServiceRef.TagProfile.LegalJid))
                return false;
 
            if (string.IsNullOrWhiteSpace(ServiceRef.TagProfile.HttpFileUploadJid) || (ServiceRef.TagProfile.HttpFileUploadMaxSize <= 0))
                return false;
 
            if (string.IsNullOrWhiteSpace(ServiceRef.TagProfile.LogJid))
                return false;
 
            if (string.IsNullOrWhiteSpace(ServiceRef.TagProfile.EDalerJid))
                return false;
 
            if (string.IsNullOrWhiteSpace(ServiceRef.TagProfile.NeuroFeaturesJid))
                return false;
 
            if (!ServiceRef.TagProfile.SupportsPushNotification)
                return false;
 
            return true;
        }
 
        private static async Task CheckFeatures(XmppClient Client, object SynchObject)
        {
            ServiceDiscoveryEventArgs e = await Client.ServiceDiscoveryAsync(string.Empty);
 
            lock (SynchObject)
            {
                ServiceRef.TagProfile.SupportsPushNotification = e.HasFeature(PushNotificationClient.MessagePushNamespace);
            }
        }
 
        private static async Task CheckComponent(XmppClient Client, Item Item, object SynchObject)
        {
            ServiceDiscoveryEventArgs itemResponse = await Client.ServiceDiscoveryAsync(null, Item.JID, Item.Node);
 
            lock (SynchObject)
            {
                if (itemResponse.HasAnyFeature(ContractsClient.NamespacesLegalIdentities))
                    ServiceRef.TagProfile.LegalJid = Item.JID;
 
                if (itemResponse.HasAnyFeature(ThingRegistryClient.NamespacesDiscovery))
                    ServiceRef.TagProfile.RegistryJid = Item.JID;
 
                if (itemResponse.HasAnyFeature(ProvisioningClient.NamespacesProvisioningDevice) &&
                    itemResponse.HasAnyFeature(ProvisioningClient.NamespacesProvisioningOwner) &&
                    itemResponse.HasAnyFeature(ProvisioningClient.NamespacesProvisioningToken))
                {
                    ServiceRef.TagProfile.ProvisioningJid = Item.JID;
                }
 
                if (itemResponse.HasFeature(HttpFileUploadClient.Namespace))
                {
                    long maxSize = HttpFileUploadClient.FindMaxFileSize(Client, itemResponse) ?? 0;
                    ServiceRef.TagProfile.SetFileUploadParameters(Item.JID, maxSize);
                }
 
                if (itemResponse.HasFeature(XmppEventSink.NamespaceEventLogging))
                    ServiceRef.TagProfile.LogJid = Item.JID;
 
                if (itemResponse.HasFeature(XmppEventSink.NamespaceEventLogging))
                    ServiceRef.TagProfile.LogJid = Item.JID;
 
                if (itemResponse.HasFeature(EDalerClient.NamespaceEDaler))
                    ServiceRef.TagProfile.EDalerJid = Item.JID;
 
                if (itemResponse.HasFeature(NeuroFeaturesClient.NamespaceNeuroFeatures))
                    ServiceRef.TagProfile.NeuroFeaturesJid = Item.JID;
            }
        }
 
        #endregion
 
        #region Transfer
 
        private async Task TransferIdDelivered(object? Sender, MessageEventArgs e)
        {
            if (e.From != Constants.Domains.OnboardingDomain)
            {
                return;
            }
 
            string Code = XML.Attribute(e.Content, "code");
            bool Deleted = XML.Attribute(e.Content, "deleted", false);
 
            if (!Deleted)
                return;
 
            string CodesGenerated = await RuntimeSettings.GetAsync(Constants.Settings.TransferIdCodeSent, string.Empty);
            string[] Codes = CodesGenerated.Split(CommonTypes.CRLF, StringSplitOptions.RemoveEmptyEntries);
 
            if (Array.IndexOf<string>(Codes, Code) < 0)
                return;
 
            await this.DestroyXmppClient();
 
            this.domainName = string.Empty;
            this.accountName = string.Empty;
            this.passwordHash = string.Empty;
            this.passwordHashMethod = string.Empty;
            this.xmppConnected = false;
 
            ServiceRef.TagProfile.ClearAll();
            await RuntimeSettings.SetAsync(Constants.Settings.TransferIdCodeSent, string.Empty);
            await Database.Provider.Flush();
 
            await App.SetRegistrationPageAsync();
        }
 
        public async Task AddTransferCode(string Code)
        {
            string CodesGenerated = await RuntimeSettings.GetAsync(Constants.Settings.TransferIdCodeSent, string.Empty);
 
            if (string.IsNullOrEmpty(CodesGenerated))
                CodesGenerated = Code;
            else
                CodesGenerated += "\r\n" + Code;
 
            await RuntimeSettings.SetAsync(Constants.Settings.TransferIdCodeSent, CodesGenerated);
            await Database.Provider.Flush();
        }
 
        #endregion
 
        #region Presence Subscriptions
 
        private async Task XmppClient_OnPresenceSubscribe(object? Sender, PresenceEventArgs e)
        {
            LegalIdentity? RemoteIdentity = null;
            string FriendlyName = string.IsNullOrWhiteSpace(e.NickName) ? e.FromBareJID : e.NickName;
            string? PhotoUrl = null;
            int PhotoWidth = 0;
            int PhotoHeight = 0;
 
            foreach (XmlNode N in e.Presence.ChildNodes)
            {
                if (N is XmlElement E && E.LocalName == "identity" && E.NamespaceURI == ContractsClient.NamespaceLegalIdentitiesCurrent)
                {
                    RemoteIdentity = LegalIdentity.Parse(E);
                    if (RemoteIdentity is not null)
                    {
                        FriendlyName = ContactInfo.GetFriendlyName(RemoteIdentity);
 
                        IdentityStatus Status = await this.ContractsClient.ValidateAsync(RemoteIdentity);
                        if (Status != IdentityStatus.Valid)
                        {
                            e.Decline();
 
                            Log.Warning("Invalid ID received. Presence subscription declined.", e.FromBareJID, RemoteIdentity.Id, "IdValidationError",
                                new KeyValuePair<string, object?>("Recipient JID", this.BareJid),
                                new KeyValuePair<string, object?>("Sender JID", e.FromBareJID),
                                new KeyValuePair<string, object?>("Legal ID", RemoteIdentity.Id),
                                new KeyValuePair<string, object?>("Validation", Status));
                            return;
                        }
 
                        break;
                    }
                }
            }
 
            ContactInfo Info = await ContactInfo.FindByBareJid(e.FromBareJID);
            if ((Info is not null) && Info.AllowSubscriptionFrom.HasValue)
            {
                if (Info.AllowSubscriptionFrom.Value)
                    e.Accept();
                else
                    e.Decline();
 
                if (Info.FriendlyName != FriendlyName || ((RemoteIdentity is not null) && Info.LegalId != RemoteIdentity.Id))
                {
                    if (RemoteIdentity is not null)
                    {
                        Info.LegalId = RemoteIdentity.Id;
                        Info.LegalIdentity = RemoteIdentity;
                    }
 
                    Info.FriendlyName = FriendlyName;
                    await Database.Update(Info);
                }
 
                return;
            }
 
            if ((RemoteIdentity is not null) && (RemoteIdentity.Attachments is not null))
            {
                (PhotoUrl, PhotoWidth, PhotoHeight) = await PhotosLoader.LoadPhotoAsTemporaryFile(RemoteIdentity.Attachments,
                    Constants.QrCode.DefaultImageWidth, Constants.QrCode.DefaultImageHeight);
            }
 
            SubscriptionRequestViewModel SubscriptionRequestViewModel = new(e.FromBareJID, FriendlyName, PhotoUrl, PhotoWidth, PhotoHeight);
            SubscriptionRequestPopup SubscriptionRequestPopup = new(SubscriptionRequestViewModel);
 
            await MopupService.Instance.PushAsync(SubscriptionRequestPopup);
            PresenceRequestAction Action = await SubscriptionRequestViewModel.Result;
 
            switch (Action)
            {
                case PresenceRequestAction.Accept:
                    e.Accept();
 
                    if (Info is null)
                    {
                        Info = new ContactInfo()
                        {
                            AllowSubscriptionFrom = true,
                            BareJid = e.FromBareJID,
                            FriendlyName = string.IsNullOrWhiteSpace(e.NickName) ? e.FromBareJID : e.NickName,
                            IsThing = false
                        };
 
                        await Database.Insert(Info);
                    }
                    else if (!Info.AllowSubscriptionFrom.HasValue || !Info.AllowSubscriptionFrom.Value)
                    {
                        Info.AllowSubscriptionFrom = true;
                        await Database.Update(Info);
                    }
 
                    RosterItem? Item = this.XmppClient[e.FromBareJID];
 
                    if (Item is null || (Item.State != SubscriptionState.Both && Item.State != SubscriptionState.To))
                    {
                        SubscribeToViewModel SubscribeToViewModel = new(e.FromBareJID);
                        SubscribeToPopup SubscribeToPopup = new(SubscribeToViewModel);
 
                        await MopupService.Instance.PushAsync(SubscribeToPopup);
                        bool? SubscribeTo = await SubscribeToViewModel.Result;
 
                        if (SubscribeTo.HasValue && SubscribeTo.Value)
                        {
                            string IdXml;
 
                            if (ServiceRef.TagProfile.LegalIdentity is null)
                                IdXml = string.Empty;
                            else
                            {
                                StringBuilder Xml = new();
                                ServiceRef.TagProfile.LegalIdentity.Serialize(Xml, true, true, true, true, true, true, true);
                                IdXml = Xml.ToString();
                            }
 
                            e.Client.RequestPresenceSubscription(e.FromBareJID, IdXml);
                        }
                    }
                    break;
 
                case PresenceRequestAction.Reject:
                    e.Decline();
 
                    if (this.abuseClient is null)
                        break;
 
                    ReportOrBlockViewModel ReportOrBlockViewModel = new(e.FromBareJID);
                    ReportOrBlockPopup ReportOrBlockPopup = new(ReportOrBlockViewModel);
 
                    await MopupService.Instance.PushAsync(ReportOrBlockPopup);
                    ReportOrBlockAction ReportOrBlock = await ReportOrBlockViewModel.Result;
 
                    if (ReportOrBlock == ReportOrBlockAction.Block || ReportOrBlock == ReportOrBlockAction.Report)
                    {
                        if (Info is null)
                        {
                            Info = new ContactInfo()
                            {
                                AllowSubscriptionFrom = false,
                                BareJid = e.FromBareJID,
                                FriendlyName = string.IsNullOrWhiteSpace(e.NickName) ? e.FromBareJID : e.NickName,
                                IsThing = false
                            };
 
                            await Database.Insert(Info);
                        }
                        else if (!Info.AllowSubscriptionFrom.HasValue || Info.AllowSubscriptionFrom.Value)
                        {
                            Info.AllowSubscriptionFrom = false;
                            await Database.Update(Info);
                        }
 
                        if (ReportOrBlock == ReportOrBlockAction.Report)
                        {
                            ReportTypeViewModel ReportTypeViewModel = new(e.FromBareJID);
                            ReportTypePopup ReportTypePopup = new(ReportTypeViewModel);
 
                            await MopupService.Instance.PushAsync(ReportOrBlockPopup);
                            ReportingReason? ReportType = await ReportTypeViewModel.Result;
 
                            if (ReportType.HasValue)
                            {
                                TaskCompletionSource<bool> Result = new();
 
                                await this.abuseClient.BlockJID(e.FromBareJID, ReportType.Value, (sender2, e2) =>
                                {
                                    Result.TrySetResult(e.Ok);
                                    return Task.CompletedTask;
                                }, null);
 
                                await Result.Task;
                            }
                        }
                    }
                    break;
 
                case PresenceRequestAction.Ignore:
                default:
                    break;
            }
        }
 
        private async Task XmppClient_OnPresenceUnsubscribed(object? Sender, PresenceEventArgs e)
        {
            ContactInfo ContactInfo = await ContactInfo.FindByBareJid(e.FromBareJID);
            if ((ContactInfo is not null) && ContactInfo.AllowSubscriptionFrom.HasValue && ContactInfo.AllowSubscriptionFrom.Value)
            {
                ContactInfo.AllowSubscriptionFrom = null;
                await Database.Update(ContactInfo);
            }
        }
 
        #endregion
 
        #region IQ Stanzas (Information Query)
 
        public Task<XmlElement> IqSetAsync(string To, string Xml)
        {
            return this.XmppClient.IqSetAsync(To, Xml);
        }
 
        private XmppClient XmppClient
        {
            get
            {
                if (this.xmppClient is null)
                    throw new Exception("Not connected to XMPP network.");
 
                return this.xmppClient;
            }
        }
 
        #endregion
 
        #region Messages
 
        public void SendMessage(QoSLevel QoS, Waher.Networking.XMPP.MessageType Type, string Id, string To, string CustomXml, string Body,
            string Subject, string Language, string ThreadId, string ParentThreadId, DeliveryEventHandler? DeliveryCallback, object? State)
        {
            this.ContractsClient.LocalE2eEndpoint.SendMessage(this.XmppClient, E2ETransmission.NormalIfNotE2E,
                QoS, Type, Id, To, CustomXml, Body, Subject, Language, ThreadId, ParentThreadId, DeliveryCallback, State);
        }
 
        private Task XmppClient_OnNormalMessage(object? Sender, MessageEventArgs e)
        {
            Log.Warning("Unhandled message received.", e.To, e.From,
                new KeyValuePair<string, object?>("Stanza", e.Message.OuterXml));
 
            return Task.CompletedTask;
        }
 
        private async Task XmppClient_OnChatMessage(object? Sender, MessageEventArgs e)
        {
            string RemoteBareJid = e.FromBareJID;
 
            foreach (XmlNode N in e.Message.ChildNodes)
            {
                if (N is XmlElement E &&
                    E.LocalName == "qlRef" &&
                    E.NamespaceURI == XmppClient.NamespaceQuickLogin &&
                    RemoteBareJid.IndexOf('@') < 0 &&
                    RemoteBareJid.IndexOf('/') < 0)
                {
                    LegalIdentity? RemoteIdentity = null;
 
                    foreach (XmlNode N2 in E.ChildNodes)
                    {
                        if (N2 is XmlElement E2 &&
                            E2.LocalName == "identity" &&
                            E2.NamespaceURI == ContractsClient.NamespaceLegalIdentitiesCurrent)
                        {
                            RemoteIdentity = LegalIdentity.Parse(E2);
                            break;
                        }
                    }
 
                    if (RemoteIdentity is not null)
                    {
                        IdentityStatus Status = await this.ValidateIdentity(RemoteIdentity);
                        if (Status != IdentityStatus.Valid)
                        {
                            Log.Warning("Message rejected because the embedded legal identity was not valid.",
                                new KeyValuePair<string, object?>("Identity", RemoteIdentity.Id),
                                new KeyValuePair<string, object?>("From", RemoteBareJid),
                                new KeyValuePair<string, object?>("Status", Status));
                            return;
                        }
 
                        string Jid = RemoteIdentity["JID"];
 
                        if (string.IsNullOrEmpty(Jid))
                        {
                            Log.Warning("Message rejected because the embedded legal identity lacked JID.",
                                new KeyValuePair<string, object?>("Identity", RemoteIdentity.Id),
                                new KeyValuePair<string, object?>("From", RemoteBareJid),
                                new KeyValuePair<string, object?>("Status", Status));
                            return;
                        }
 
                        if (!string.Equals(XML.Attribute(E, "bareJid", string.Empty), Jid, StringComparison.OrdinalIgnoreCase))
                        {
                            Log.Warning("Message rejected because the embedded legal identity had a different JID compared to the JID of the quick-login reference.",
                                new KeyValuePair<string, object?>("Identity", RemoteIdentity.Id),
                                new KeyValuePair<string, object?>("From", RemoteBareJid),
                                new KeyValuePair<string, object?>("Status", Status));
                            return;
                        }
 
                        RemoteBareJid = Jid;
                    }
                }
            }
 
            ContactInfo ContactInfo = await ContactInfo.FindByBareJid(RemoteBareJid);
            string FriendlyName = ContactInfo?.FriendlyName ?? RemoteBareJid;
            string? ReplaceObjectId = null;
 
            ChatMessage Message = new()
            {
                Created = DateTime.UtcNow,
                RemoteBareJid = RemoteBareJid,
                RemoteObjectId = e.Id,
                MessageType = NeuroAccessMaui.UI.Pages.Contacts.Chat.MessageType.Received,
                Html = string.Empty,
                PlainText = e.Body,
                Markdown = string.Empty
            };
 
            foreach (XmlNode N in e.Message.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    switch (N.LocalName)
                    {
                        case "content":
                            if (E.NamespaceURI == "urn:xmpp:content")
                            {
                                string Type = XML.Attribute(E, "type");
 
                                switch (Type)
                                {
                                    case "text/markdown":
                                        Message.Markdown = E.InnerText;
                                        break;
 
                                    case "text/plain":
                                        Message.PlainText = E.InnerText;
                                        break;
 
                                    case "text/html":
                                        Message.Html = E.InnerText;
                                        break;
                                }
                            }
                            break;
 
                        case "html":
                            if (E.NamespaceURI == "http://jabber.org/protocol/xhtml-im")
                            {
                                string Html = E.InnerXml;
 
                                int i = Html.IndexOf("<body", StringComparison.OrdinalIgnoreCase);
                                if (i >= 0)
                                {
                                    i = Html.IndexOf('>', i + 5);
                                    if (i >= 0)
                                        Html = Html[(i + 1)..].TrimStart();
 
                                    i = Html.LastIndexOf("</body>", StringComparison.OrdinalIgnoreCase);
                                    if (i >= 0)
                                        Html = Html[..i].TrimEnd();
                                }
 
                                Message.Html = Html;
                            }
                            break;
 
                        case "replace":
                            if (E.NamespaceURI == "urn:xmpp:message-correct:0")
                                ReplaceObjectId = XML.Attribute(E, "id");
                            break;
 
                        case "delay":
                            if (E.NamespaceURI == PubSubClient.NamespaceDelayedDelivery &&
                                E.HasAttribute("stamp") &&
                                XML.TryParse(E.GetAttribute("stamp"), out DateTime Timestamp2))
                            {
                                Message.Created = Timestamp2.ToUniversalTime();
                            }
                            break;
                    }
                }
            }
 
            if (!string.IsNullOrEmpty(Message.Markdown))
            {
                try
                {
                    MarkdownSettings Settings = new()
                    {
                        AllowScriptTag = false,
                        EmbedEmojis = false,    // TODO: Emojis
                        AudioAutoplay = false,
                        AudioControls = false,
                        ParseMetaData = false,
                        VideoAutoplay = false,
                        VideoControls = false
                    };
 
                    MarkdownDocument Doc = await MarkdownDocument.CreateAsync(Message.Markdown, Settings);
 
                    if (string.IsNullOrEmpty(Message.PlainText))
                        Message.PlainText = (await Doc.GeneratePlainText()).Trim();
 
                    if (string.IsNullOrEmpty(Message.Html))
                        Message.Html = HtmlDocument.GetBody(await Doc.GenerateHTML());
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex);
                    Message.Markdown = string.Empty;
                }
            }
 
            if (string.IsNullOrEmpty(ReplaceObjectId))
                await Database.Insert(Message);
            else
            {
                ChatMessage Old = await Database.FindFirstIgnoreRest<ChatMessage>(new FilterAnd(
                    new FilterFieldEqualTo("RemoteBareJid", RemoteBareJid),
                    new FilterFieldEqualTo("RemoteObjectId", ReplaceObjectId)));
 
                if (Old is null)
                {
                    ReplaceObjectId = null;
                    await Database.Insert(Message);
                }
                else
                {
                    Old.Updated = Message.Created;
                    Old.Html = Message.Html;
                    Old.PlainText = Message.PlainText;
                    Old.Markdown = Message.Markdown;
 
                    await Database.Update(Old);
 
                    Message = Old;
                }
            }
 
            MainThread.BeginInvokeOnMainThread(async () =>
            {
                if (ServiceRef.UiService.CurrentPage is ChatPage &&
                    ServiceRef.UiService.CurrentPage.BindingContext is ChatViewModel ChatViewModel &&
                    string.Equals(ChatViewModel.BareJid, RemoteBareJid, StringComparison.OrdinalIgnoreCase))
                {
                    if (string.IsNullOrEmpty(ReplaceObjectId))
                        await ChatViewModel.MessageAddedAsync(Message);
                    else
                        await ChatViewModel.MessageUpdatedAsync(Message);
                }
                else
                {
                    await ServiceRef.NotificationService.NewEvent(new ChatMessageNotificationEvent(e)
                    {
                        ReplaceObjectId = ReplaceObjectId,
                        BareJid = RemoteBareJid,
                        Category = RemoteBareJid
                    });
                }
            });
        }
 
        private Task ClientMessage(object? Sender, MessageEventArgs e)
        {
            string Code = XML.Attribute(e.Content, "code");
            string Type = XML.Attribute(e.Content, "type");
            string Message = e.Body;
 
            if (!string.IsNullOrEmpty(Code))
            {
                try
                {
                    string LocalizedMessage = ServiceRef.Localizer["ClientMessage" + Code];
 
                    if (!string.IsNullOrEmpty(LocalizedMessage))
                        Message = LocalizedMessage;
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
 
            MainThread.BeginInvokeOnMainThread(async () =>
            {
                switch (Type.ToUpperInvariant())
                {
                    case "NONE":
                    default:
                        await ServiceRef.UiService.DisplayAlert(
                            ServiceRef.Localizer[nameof(AppResources.Information)], Message,
                            ServiceRef.Localizer[nameof(AppResources.Ok)]);
                        break;
 
                    case "CLIENT":
                    case "SERVER":
                    case "SERVICE":
                        await ServiceRef.UiService.DisplayAlert(
                            ServiceRef.Localizer[nameof(AppResources.ErrorTitle)], Message,
                            ServiceRef.Localizer[nameof(AppResources.Ok)]);
                        break;
 
                }
            });
 
            return Task.CompletedTask;
        }
 
        #endregion
 
        #region Presence
 
        private async Task XmppClient_OnPresence(object? Sender, PresenceEventArgs e)
        {
            try
            {
                Task? T = this.OnPresence?.Invoke(this, e);
                if (T is not null)
                    await T;
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public event PresenceEventHandlerAsync? OnPresence;
 
        public void RequestPresenceSubscription(string BareJid)
        {
            this.XmppClient.RequestPresenceSubscription(BareJid);
        }
 
        public void RequestPresenceSubscription(string BareJid, string CustomXml)
        {
            this.XmppClient.RequestPresenceSubscription(BareJid, CustomXml);
        }
 
        public void RequestPresenceUnsubscription(string BareJid)
        {
            this.XmppClient.RequestPresenceUnsubscription(BareJid);
        }
 
        public void RequestRevokePresenceSubscription(string BareJid)
        {
            this.XmppClient.RequestRevokePresenceSubscription(BareJid);
        }
 
        #endregion
 
        #region Roster
 
        public RosterItem[] Roster => this.xmppClient?.Roster ?? [];
 
        public RosterItem? GetRosterItem(string BareJid)
        {
            return this.XmppClient?.GetRosterItem(BareJid);
        }
 
        public void AddRosterItem(RosterItem Item)
        {
            this.XmppClient.AddRosterItem(Item);
        }
 
        public void RemoveRosterItem(string BareJid)
        {
            this.XmppClient.RemoveRosterItem(BareJid);
        }
 
        private async Task XmppClient_OnRosterItemAdded(object? Sender, RosterItem Item)
        {
            try
            {
                Task? T = this.OnRosterItemAdded?.Invoke(this, Item);
                if (T is not null)
                    await T;
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public event RosterItemEventHandlerAsync? OnRosterItemAdded;
 
        private async Task XmppClient_OnRosterItemUpdated(object? Sender, RosterItem Item)
        {
            try
            {
                Task? T = this.OnRosterItemUpdated?.Invoke(this, Item);
                if (T is not null)
                    await T;
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public event RosterItemEventHandlerAsync? OnRosterItemUpdated;
 
        private async Task XmppClient_OnRosterItemRemoved(object? Sender, RosterItem Item)
        {
            try
            {
                Task? T = this.OnRosterItemRemoved?.Invoke(this, Item);
                if (T is not null)
                    await T;
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public event RosterItemEventHandlerAsync? OnRosterItemRemoved;
 
        #endregion
 
        #region Push Notification
 
        public bool SupportsPushNotification => this.pushNotificationClient is not null;
 
 
        private PushNotificationClient PushNotificationClient
        {
            get
            {
                if (this.pushNotificationClient is null)
                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.PushNotificationServiceNotFound)]);
 
                return this.pushNotificationClient;
            }
        }
 
        public async Task<bool> NewPushNotificationToken(TokenInformation TokenInformation)
        {
            // TODO: Check if started
 
            if (this.pushNotificationClient is null || !this.IsOnline || string.IsNullOrEmpty(TokenInformation.Token))
                return false;
            else
            {
                await this.ReportNewPushNotificationToken(TokenInformation.Token, TokenInformation.Service, TokenInformation.ClientType);
 
                return true;
            }
        }
 
        public Task ReportNewPushNotificationToken(string Token, PushMessagingService Service, ClientType ClientType)
        {
            return this.PushNotificationClient.NewTokenAsync(Token, Service, ClientType);
        }
 
        public Task ClearPushNotificationRules()
        {
            return this.PushNotificationClient.ClearRulesAsync();
        }
 
        public Task AddPushNotificationRule(Waher.Networking.XMPP.MessageType MessageType, string LocalName, string Namespace,
            string Channel, string MessageVariable, string PatternMatchingScript, string ContentScript)
        {
            return this.PushNotificationClient.AddRuleAsync(MessageType, LocalName, Namespace, Channel, MessageVariable,
                PatternMatchingScript, ContentScript);
        }
 
        #endregion
 
        #region Tokens
 
        public async Task<string?> GetApiToken(int Seconds)
        {
            DateTime Now = DateTime.UtcNow;
 
            if (!string.IsNullOrEmpty(this.token) && Now.Subtract(this.tokenCreated).TotalSeconds < Seconds - 10)
                return this.token;
 
            if (!this.IsOnline)
            {
                if (!await this.WaitForConnectedState(TimeSpan.FromSeconds(20)))
                    return this.token;
            }
 
            if (this.httpxClient is null)
                throw new Exception("Not connected to XMPP network.");
 
            this.token = await this.httpxClient.GetJwtTokenAsync(Seconds);
            this.tokenCreated = Now;
 
            return this.token;
        }
 
        public async Task<object> PostToProtectedApi(string LocalResource, object Data, params KeyValuePair<string, string>[] Headers)
        {
            StringBuilder Url = new();
 
            if (this.IsOnline)
                Url.Append("httpx://");
            else if (!string.IsNullOrEmpty(this.token))     // Token needs to be retrieved regularly when connected, if protected APIs are to be used when disconnected or during connection.
            {
                Url.Append("https://");
 
                KeyValuePair<string, string> Authorization = new("Authorization", "Bearer " + this.token);
 
                if (Headers is null)
                    Headers = [Authorization];
                else
                {
                    int c = Headers.Length;
 
                    Array.Resize(ref Headers, c + 1);
                    Headers[c] = Authorization;
                }
            }
            else
                throw new IOException("No connection and no token available for call to protect API.");
 
            Url.Append(ServiceRef.TagProfile.Domain);
            Url.Append(LocalResource);
 
            return await InternetContent.PostAsync(new Uri(Url.ToString()), Data, Headers);
        }
 
        #endregion
 
        #region HTTP File Upload
 
        private HttpFileUploadClient FileUploadClient
        {
            get
            {
                if (this.fileUploadClient is null)
                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.FileUploadServiceNotFound)]);
 
                return this.fileUploadClient;
            }
        }
 
        public bool FileUploadIsSupported
        {
            get
            {
                try
                {
                    return ServiceRef.TagProfile.FileUploadIsSupported &&
                        this.fileUploadClient is not null &&
                        this.fileUploadClient.HasSupport;
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex);
                    return false;
                }
            }
        }
 
        public Task<HttpFileUploadEventArgs> RequestUploadSlotAsync(string FileName, string ContentType, long ContentSize)
        {
            return this.FileUploadClient.RequestUploadSlotAsync(FileName, ContentType, ContentSize);
        }
 
 
        #endregion
 
        #region Personal Eventing Protocol (PEP)
 
        private readonly LinkedList<KeyValuePair<Type, PersonalEventNotificationEventHandler>> pepHandlers = new();
 
        private PepClient PepClient
        {
            get
            {
                if (this.pepClient is null)
                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.PepServiceNotFound)]);
 
                return this.pepClient;
            }
        }
 
        public void RegisterPepHandler(Type PersonalEventType, PersonalEventNotificationEventHandler Handler)
        {
            lock (this.pepHandlers)
            {
                this.pepHandlers.AddLast(new KeyValuePair<Type, PersonalEventNotificationEventHandler>(PersonalEventType, Handler));
            }
 
            this.PepClient.RegisterHandler(PersonalEventType, Handler);
        }
 
        public bool UnregisterPepHandler(Type PersonalEventType, PersonalEventNotificationEventHandler Handler)
        {
            lock (this.pepHandlers)
            {
                LinkedListNode<KeyValuePair<Type, PersonalEventNotificationEventHandler>>? Node = this.pepHandlers.First;
 
                while (Node is not null)
                {
                    if (Node.Value.Key == PersonalEventType &&
                        (Node.Value.Value.Target?.Equals(Handler.Target) ?? Handler.Target is null) &&
                        Node.Value.Value.Method.Equals(Handler.Method))
                    {
                        this.pepHandlers.Remove(Node);
                        break;
                    }
 
                    Node = Node.Next;
                }
            }
 
            return this.PepClient.UnregisterHandler(PersonalEventType, Handler);
        }
 
        private void ReregisterPepEventHandlers(PepClient PepClient)
        {
            lock (this.pepHandlers)
            {
                foreach (KeyValuePair<Type, PersonalEventNotificationEventHandler> P in this.pepHandlers)
                    PepClient.RegisterHandler(P.Key, P.Value);
            }
        }
 
        #endregion
 
        #region Thing Registries & Discovery
 
        private ThingRegistryClient ThingRegistryClient
        {
            get
            {
                if (this.thingRegistryClient is null)
                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.ThingRegistryServiceNotFound)]);
 
                return this.thingRegistryClient;
            }
        }
 
        public string RegistryServiceJid => this.ThingRegistryClient.ThingRegistryAddress;
 
        public bool IsIoTDiscoClaimURI(string DiscoUri)
        {
            return ThingRegistryClient.IsIoTDiscoClaimURI(DiscoUri);
        }
 
        public bool IsIoTDiscoSearchURI(string DiscoUri)
        {
            return ThingRegistryClient.IsIoTDiscoSearchURI(DiscoUri);
        }
 
        public bool IsIoTDiscoDirectURI(string DiscoUri)
        {
            return ThingRegistryClient.IsIoTDiscoDirectURI(DiscoUri);
        }
 
        public bool TryDecodeIoTDiscoClaimURI(string DiscoUri, [NotNullWhen(true)] out MetaDataTag[]? Tags)
        {
            return ThingRegistryClient.TryDecodeIoTDiscoClaimURI(DiscoUri, out Tags);
        }
 
        public bool TryDecodeIoTDiscoSearchURI(string DiscoUri, [NotNullWhen(true)] out SearchOperator[]? Operators,
            out string? RegistryJid)
        {
            RegistryJid = null;
            Operators = null;
            if (!ThingRegistryClient.TryDecodeIoTDiscoURI(DiscoUri, out IEnumerable<SearchOperator> Operators2))
                return false;
 
            List<SearchOperator> List = [];
 
            foreach (SearchOperator Operator in Operators2)
            {
                if (Operator.Name.Equals("R", StringComparison.OrdinalIgnoreCase))
                {
                    if (!string.IsNullOrEmpty(RegistryJid))
                        return false;
 
                    if (Operator is not StringTagEqualTo StrEqOp)
                        return false;
 
                    RegistryJid = StrEqOp.Value;
                }
                else
                    List.Add(Operator);
            }
 
            Operators = [.. List];
 
            return true;
        }
 
        public bool TryDecodeIoTDiscoDirectURI(string DiscoUri, [NotNullWhen(true)] out string? Jid, out string? SourceId, out string? NodeId,
            out string? PartitionId, [NotNullWhen(true)] out MetaDataTag[]? Tags)
        {
            Jid = null;
            SourceId = null;
            NodeId = null;
            PartitionId = null;
 
            if (!ThingRegistryClient.TryDecodeIoTDiscoURI(DiscoUri, out IEnumerable<SearchOperator> Operators2))
            {
                Tags = null;
                return false;
            }
 
            List<MetaDataTag> TagsFound = [];
 
            foreach (SearchOperator Operator in Operators2)
            {
                if (Operator is StringTagEqualTo S)
                {
                    switch (S.Name.ToUpper(CultureInfo.InvariantCulture))
                    {
                        case Constants.XmppProperties.Jid:
                            Jid = S.Value;
                            break;
 
                        case Constants.XmppProperties.SourceId:
                            SourceId = S.Value;
                            break;
 
                        case Constants.XmppProperties.NodeId:
                            NodeId = S.Value;
                            break;
 
                        case Constants.XmppProperties.Partition:
                            PartitionId = S.Value;
                            break;
 
                        default:
                            TagsFound.Add(new MetaDataStringTag(S.Name, S.Value));
                            break;
                    }
                }
                else if (Operator is NumericTagEqualTo N)
                    TagsFound.Add(new MetaDataNumericTag(N.Name, N.Value));
                else
                {
                    Tags = null;
                    return false;
                }
            }
 
            Tags = [.. TagsFound];
 
            return !string.IsNullOrEmpty(Jid);
        }
 
        public Task<NodeResultEventArgs> ClaimThing(string DiscoUri, bool MakePublic)
        {
            if (!this.TryDecodeIoTDiscoClaimURI(DiscoUri, out MetaDataTag[]? Tags))
                throw new ArgumentException(ServiceRef.Localizer[nameof(AppResources.InvalidIoTDiscoClaimUri)], nameof(DiscoUri));
 
            TaskCompletionSource<NodeResultEventArgs> Result = new();
 
            this.ThingRegistryClient.Mine(MakePublic, Tags, (sender, e) =>
            {
                Result.TrySetResult(e);
                return Task.CompletedTask;
            }, null);
 
            return Result.Task;
        }
 
        public Task<bool> Disown(string RegistryJid, string ThingJid, string SourceId, string Partition, string NodeId)
        {
            TaskCompletionSource<bool> Result = new();
 
            this.ThingRegistryClient.Disown(RegistryJid, ThingJid, NodeId, SourceId, Partition, (sender, e) =>
            {
                Result.TrySetResult(e.Ok);
                return Task.CompletedTask;
            }, null);
 
            return Result.Task;
        }
 
        public async Task<(SearchResultThing[], string?, bool)> Search(int Offset, int MaxCount, string DiscoUri)
        {
            if (!this.TryDecodeIoTDiscoSearchURI(DiscoUri, out SearchOperator[]? Operators, out string? RegistryJid))
                return (Array.Empty<SearchResultThing>(), RegistryJid, false);
 
            (SearchResultThing[] Things, bool More) = await this.Search(Offset, MaxCount, RegistryJid, Operators);
 
            return (Things, RegistryJid, More);
        }
 
        public Task<(SearchResultThing[], bool)> Search(int Offset, int MaxCount, string? RegistryJid, params SearchOperator[] Operators)
        {
            TaskCompletionSource<(SearchResultThing[], bool)> Result = new();
 
            this.ThingRegistryClient.Search(RegistryJid ?? ServiceRef.TagProfile.RegistryJid, Offset, MaxCount, Operators, (sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult((e.Things, e.More));
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to perform search."));
 
                return Task.CompletedTask;
            }, null);
 
            return Result.Task;
        }
 
        public async Task<(SearchResultThing[], string?)> SearchAll(string DiscoUri)
        {
            if (!this.TryDecodeIoTDiscoSearchURI(DiscoUri, out SearchOperator[]? Operators, out string? RegistryJid))
                return (Array.Empty<SearchResultThing>(), RegistryJid);
 
            SearchResultThing[] Things = await this.SearchAll(RegistryJid ?? ServiceRef.TagProfile.RegistryJid, Operators);
 
            return (Things, RegistryJid);
        }
 
        public async Task<SearchResultThing[]> SearchAll(string? RegistryJid, params SearchOperator[] Operators)
        {
            (SearchResultThing[] Things, bool More) = await this.Search(0, Constants.BatchSizes.DeviceBatchSize, RegistryJid, Operators);
            if (!More)
                return Things;
 
            List<SearchResultThing> Result = [];
            int Offset = Things.Length;
 
            Result.AddRange(Things);
 
            while (More)
            {
                (Things, More) = await this.Search(Offset, Constants.BatchSizes.DeviceBatchSize, RegistryJid, Operators);
                Result.AddRange(Things);
                Offset += Things.Length;
            }
 
            return [.. Result];
        }
 
        #endregion
 
        #region Legal Identities
 
        public async Task GenerateNewKeys()
        {
            await this.ContractsClient.GenerateNewKeys();
 
            if (this.ContractsClient.Client.State == XmppState.Connected)
                await this.ContractsClient.Client.SetPresenceAsync(Availability.Online);
        }
 
        public async Task<IdApplicationAttributesEventArgs> GetIdApplicationAttributes()
        {
            return await this.ContractsClient.GetIdApplicationAttributesAsync();
        }
 
        public async Task<LegalIdentity> AddLegalIdentity(RegisterIdentityModel Model, bool GenerateNewKeys,
            params LegalIdentityAttachment[] Attachments)
        {
            if (GenerateNewKeys)
                await this.GenerateNewKeys();
 
            LegalIdentity Identity = await this.ContractsClient.ApplyAsync(Model.ToProperties(ServiceRef.XmppService));
 
            foreach (LegalIdentityAttachment Attachment in Attachments)
            {
                HttpFileUploadEventArgs e2 = await ServiceRef.XmppService.RequestUploadSlotAsync(
                    Path.GetFileName(Attachment.FileName!)!, Attachment.ContentType!, Attachment.ContentLength);
 
                if (!e2.Ok)
                    throw e2.StanzaError ?? new Exception(e2.ErrorText);
 
                await e2.PUT(Attachment.Data, Attachment.ContentType, (int)Constants.Timeouts.UploadFile.TotalMilliseconds);
                byte[] Signature = await this.ContractsClient.SignAsync(Attachment.Data, SignWith.CurrentKeys);
 
                Identity = await this.ContractsClient.AddLegalIdAttachmentAsync(Identity.Id, e2.GetUrl, Signature);
            }
 
            await this.ContractsClient.ReadyForApprovalAsync(Identity.Id);
 
            return Identity;
        }
 
        public async Task<LegalIdentity[]> GetLegalIdentities(XmppClient? client = null)
        {
            if (client is null)
                return await this.ContractsClient.GetLegalIdentitiesAsync();
            else
            {
                using ContractsClient cc = new(client, ServiceRef.TagProfile.LegalJid);  // No need to load keys for this operation.
                return await cc.GetLegalIdentitiesAsync();
            }
        }
 
        public async Task<LegalIdentity> GetLegalIdentity(CaseInsensitiveString legalIdentityId)
        {
            ContactInfo Info = await ContactInfo.FindByLegalId(legalIdentityId);
 
            if (Info is not null && Info.LegalIdentity is not null)
                return Info.LegalIdentity;
 
            return await this.ContractsClient.GetLegalIdentityAsync(legalIdentityId);
        }
 
        public async Task<bool> IsContact(CaseInsensitiveString legalIdentityId)
        {
            ContactInfo Info = await ContactInfo.FindByLegalId(legalIdentityId);
            return (Info is not null && Info.LegalIdentity is not null);
        }
 
        public Task<bool> HasPrivateKey(CaseInsensitiveString LegalIdentityId)
        {
            return this.ContractsClient.HasPrivateKey(LegalIdentityId);
        }
 
        public Task<LegalIdentity> ObsoleteLegalIdentity(CaseInsensitiveString legalIdentityId)
        {
            return this.ContractsClient.ObsoleteLegalIdentityAsync(legalIdentityId);
        }
 
        public Task<LegalIdentity> CompromiseLegalIdentity(CaseInsensitiveString legalIdentityId)
        {
            return this.ContractsClient.CompromisedLegalIdentityAsync(legalIdentityId);
        }
 
        public async Task PetitionIdentity(CaseInsensitiveString LegalId, string PetitionId, string Purpose)
        {
            if (ServiceRef.TagProfile.LegalIdentity is null)
                throw new Exception("No Legal Identity registered.");
 
            await this.ContractsClient.AuthorizeAccessToIdAsync(ServiceRef.TagProfile.LegalIdentity.Id, LegalId, true);
 
            this.StartPetition(PetitionId);
            await this.ContractsClient.PetitionIdentityAsync(LegalId, PetitionId, Purpose);
        }
 
        private void StartPetition(string PetitionId)
        {
            lock (this.currentPetitions)
            {
                this.currentPetitions[PetitionId] = true;
            }
        }
 
        private bool EndPetition(string PetitionId)
        {
            lock (this.currentPetitions)
            {
                return this.currentPetitions.Remove(PetitionId);
            }
        }
 
        public Task SendPetitionIdentityResponse(CaseInsensitiveString LegalId, string PetitionId, string RequestorFullJid, bool Response)
        {
            return this.ContractsClient.PetitionIdentityResponseAsync(LegalId, PetitionId, RequestorFullJid, Response);
        }
 
        public event LegalIdentityEventHandler? LegalIdentityChanged;
 
        public event LegalIdentityEventHandler? IdentityApplicationChanged;
 
        private async Task ContractsClient_IdentityUpdated(object? Sender, LegalIdentityEventArgs e)
        {
            try
            {
                if (ServiceRef.TagProfile.LegalIdentity is not null && ServiceRef.TagProfile.LegalIdentity.Id == e.Identity.Id)
                {
                    if (ServiceRef.TagProfile.LegalIdentity.Created > e.Identity.Created)
                        return;
 
                    await ServiceRef.TagProfile.SetLegalIdentity(e.Identity, true);
                    this.LegalIdentityChanged?.Invoke(this, e);
 
                    if (e.Identity.IsDiscarded() && Shell.Current.CurrentState.Location.OriginalString != Constants.Pages.RegistrationPage)
                    {
                        MainThread.BeginInvokeOnMainThread(async () =>
                        {
                            try
                            {
                                await ServiceRef.TagProfile.ClearLegalIdentity();
                                ServiceRef.TagProfile.GoToStep(RegistrationStep.ValidatePhone, true);
                                await Shell.Current.GoToAsync(Constants.Pages.RegistrationPage);
                            }
                            catch (Exception ex)
                            {
                                ServiceRef.LogService.LogException(ex);
                                await App.Stop();
                            }
                        });
                    }
                }
                else if (ServiceRef.TagProfile.IdentityApplication is not null && ServiceRef.TagProfile.IdentityApplication.Id == e.Identity.Id)
                {
                    if (ServiceRef.TagProfile.IdentityApplication.Created > e.Identity.Created)
                        return;
 
                    if (e.Identity.IsDiscarded())
                    {
                        await ServiceRef.TagProfile.SetIdentityApplication(null, true);
                        this.IdentityApplicationChanged?.Invoke(this, e);
                    }
                    else if (e.Identity.IsApproved())
                    {
                        LegalIdentity? ToObsolete = ServiceRef.TagProfile.LegalIdentity;
 
                        await ServiceRef.TagProfile.SetLegalIdentity(e.Identity, true);
                        await ServiceRef.TagProfile.SetIdentityApplication(null, false);
 
                        this.LegalIdentityChanged?.Invoke(this, e);
                        this.IdentityApplicationChanged?.Invoke(this, e);
 
                        if (ToObsolete is not null && !ToObsolete.IsDiscarded())
                            await this.ObsoleteLegalIdentity(ToObsolete.Id);
                    }
                    else
                    {
                        await ServiceRef.TagProfile.SetIdentityApplication(e.Identity, false);
                        this.IdentityApplicationChanged?.Invoke(this, e);
                    }
                }
                else if (ServiceRef.TagProfile.LegalIdentity is null)
                {
                    if (e.Identity.IsDiscarded())
                        return;
 
                    await ServiceRef.TagProfile.SetLegalIdentity(e.Identity, true);
                    this.LegalIdentityChanged?.Invoke(this, e);
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        public event LegalIdentityPetitionEventHandler? PetitionForIdentityReceived;
 
        private async Task ContractsClient_PetitionForIdentityReceived(object? Sender, LegalIdentityPetitionEventArgs e)
        {
            try
            {
                this.PetitionForIdentityReceived?.Invoke(this, e);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        public event LegalIdentityPetitionResponseEventHandler? PetitionedIdentityResponseReceived;
 
        private async Task ContractsClient_PetitionedIdentityResponseReceived(object? Sender, LegalIdentityPetitionResponseEventArgs e)
        {
            try
            {
                this.EndPetition(e.PetitionId);
                this.PetitionedIdentityResponseReceived?.Invoke(this, e);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        public Task ExportSigningKeys(XmlWriter Output)
        {
            return this.ContractsClient.ExportKeys(Output);
        }
 
        public Task<bool> ImportSigningKeys(XmlElement Xml)
        {
            return this.ContractsClient.ImportKeys(Xml);
        }
 
        public Task<IdentityStatus> ValidateIdentity(LegalIdentity Identity)
        {
            return this.ContractsClient.ValidateAsync(Identity, true);
        }
 
        #endregion
 
        #region Smart Contracts
 
        private readonly Dictionary<CaseInsensitiveString, DateTime> lastContractEvent = [];
 
        public ContractsClient ContractsClient
        {
            get
            {
                if (this.contractsClient is null)
                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.LegalServiceNotFound)]);
 
                return this.contractsClient;
            }
        }
 
        private void RegisterContractsEventHandlers()
        {
            this.ContractsClient.EnableE2eEncryption(true, false);
 
            this.ContractsClient.IdentityUpdated += this.ContractsClient_IdentityUpdated;
            this.ContractsClient.PetitionForIdentityReceived += this.ContractsClient_PetitionForIdentityReceived;
            this.ContractsClient.PetitionedIdentityResponseReceived += this.ContractsClient_PetitionedIdentityResponseReceived;
            this.ContractsClient.PetitionForContractReceived += this.ContractsClient_PetitionForContractReceived;
            this.ContractsClient.PetitionedContractResponseReceived += this.ContractsClient_PetitionedContractResponseReceived;
            this.ContractsClient.PetitionForSignatureReceived += this.ContractsClient_PetitionForSignatureReceived;
            this.ContractsClient.PetitionedSignatureResponseReceived += this.ContractsClient_PetitionedSignatureResponseReceived;
            this.ContractsClient.PetitionForPeerReviewIDReceived += this.ContractsClient_PetitionForPeerReviewIdReceived;
            this.ContractsClient.PetitionedPeerReviewIDResponseReceived += this.ContractsClient_PetitionedPeerReviewIdResponseReceived;
            this.ContractsClient.PetitionClientUrlReceived += this.ContractsClient_PetitionClientUrlReceived;
            this.ContractsClient.ContractProposalReceived += this.ContractsClient_ContractProposalReceived;
            this.ContractsClient.ContractUpdated += this.ContractsClient_ContractUpdated;
            this.ContractsClient.ContractSigned += this.ContractsClient_ContractSigned;
        }
 
        public Task<Contract> GetContract(CaseInsensitiveString ContractId)
        {
            return this.ContractsClient.GetContractAsync(ContractId);
        }
 
        public async Task<string[]> GetCreatedContractReferences()
        {
            List<string> Result = [];
            string[] ContractIds;
            int Offset = 0;
            int Nr;
 
            do
            {
                ContractIds = await this.ContractsClient.GetCreatedContractReferencesAsync(Offset, 20);
                Result.AddRange(ContractIds);
                Nr = ContractIds.Length;
                Offset += Nr;
            }
            while (Nr == 20);
 
            return [.. Result];
        }
 
        public async Task<string[]> GetSignedContractReferences()
        {
            List<string> Result = [];
            string[] ContractIds;
            int Offset = 0;
            int Nr;
 
            do
            {
                ContractIds = await this.ContractsClient.GetSignedContractReferencesAsync(Offset, 20);
                Result.AddRange(ContractIds);
                Nr = ContractIds.Length;
                Offset += Nr;
            }
            while (Nr == 20);
 
            return [.. Result];
        }
 
        public async Task<Contract> SignContract(Contract Contract, string Role, bool Transferable)
        {
            if (Contract.ForMachinesNamespace == Constants.ContractMachineNames.PaymentInstructionsNamespace && (
                Contract.ForMachinesLocalName == Constants.ContractMachineNames.BuyEDaler ||
                Contract.ForMachinesLocalName == Constants.ContractMachineNames.SellEDaler))
            {
                lock (this.currentTransactions)
                {
                    string TransactionId = Contract.ContractId;
                    string Currency = Contract["Currency"]?.ToString() ?? string.Empty;
 
                    this.currentTransactions[Contract.ContractId] = new PaymentTransaction(TransactionId, Currency);
                }
            }
 
            Contract Result = await this.ContractsClient.SignContractAsync(Contract, Role, Transferable);
            await UpdateContractReference(Result);
            return Result;
        }
 
        public async Task<Contract> ObsoleteContract(CaseInsensitiveString ContractId)
        {
            Contract Result = await this.ContractsClient.ObsoleteContractAsync(ContractId);
            await UpdateContractReference(Result);
            return Result;
        }
 
        public async Task<Contract> CreateContract(
            CaseInsensitiveString TemplateId,
            Part[] Parts,
            Parameter[] Parameters,
            ContractVisibility Visibility,
            ContractParts PartsMode,
            Duration Duration,
            Duration ArchiveRequired,
            Duration ArchiveOptional,
            DateTime? SignAfter,
            DateTime? SignBefore,
            bool CanActAsTemplate)
        {
            Contract Result = await this.ContractsClient.CreateContractAsync(TemplateId, Parts, Parameters, Visibility, PartsMode, Duration, ArchiveRequired, ArchiveOptional, SignAfter, SignBefore, CanActAsTemplate);
            await UpdateContractReference(Result);
            return Result;
        }
 
        public async Task<Contract> DeleteContract(CaseInsensitiveString ContractId)
        {
            Contract Contract = await this.ContractsClient.DeleteContractAsync(ContractId);
            await Database.FindDelete<ContractReference>(new FilterFieldEqualTo("ContractId", Contract.ContractId));
            return Contract;
        }
 
        public Task PetitionContract(CaseInsensitiveString ContractId, string PetitionId, string Purpose)
        {
            this.StartPetition(PetitionId);
            return this.ContractsClient.PetitionContractAsync(ContractId, PetitionId, Purpose);
        }
 
        public Task SendPetitionContractResponse(CaseInsensitiveString ContractId, string PetitionId, string RequestorFullJid, bool Response)
        {
            return this.ContractsClient.PetitionContractResponseAsync(ContractId, PetitionId, RequestorFullJid, Response);
        }
 
        public event ContractPetitionEventHandler? PetitionForContractReceived;
 
        private async Task ContractsClient_PetitionForContractReceived(object? Sender, ContractPetitionEventArgs e)
        {
            try
            {
                this.PetitionForContractReceived?.Invoke(this, e);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        public event ContractPetitionResponseEventHandler? PetitionedContractResponseReceived;
 
        private async Task ContractsClient_PetitionedContractResponseReceived(object? Sender, ContractPetitionResponseEventArgs e)
        {
            try
            {
                this.EndPetition(e.PetitionId);
                this.PetitionedContractResponseReceived?.Invoke(this, e);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        public DateTime GetTimeOfLastContractEvent(CaseInsensitiveString ContractId)
        {
            lock (this.lastContractEvent)
            {
                if (this.lastContractEvent.TryGetValue(ContractId, out DateTime TP))
                    return TP;
                else
                    return DateTime.MinValue;
            }
        }
 
        private static async Task UpdateContractReference(Contract Contract)
        {
            ContractReference Ref = await Database.FindFirstDeleteRest<ContractReference>(
                new FilterFieldEqualTo("ContractId", Contract.ContractId));
 
            if (Ref is null)
            {
                Ref = new ContractReference()
                {
                    ContractId = Contract.ContractId
                };
 
                await Ref.SetContract(Contract);
                await Database.Insert(Ref);
            }
            else
            {
                await Ref.SetContract(Contract);
                await Database.Update(Ref);
            }
 
            ServiceRef.TagProfile.CheckContractReference(Ref);
        }
 
        public event ContractProposalEventHandler? ContractProposalReceived;
 
        private async Task ContractsClient_ContractProposalReceived(object? Sender, ContractProposalEventArgs e)
        {
            try
            {
                this.ContractProposalReceived?.Invoke(this, e);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        public event ContractReferenceEventHandler? ContractUpdated;
 
        private async Task ContractsClient_ContractUpdated(object? Sender, ContractReferenceEventArgs e)
        {
            await this.ContractUpdatedOrSigned(e);
 
            try
            {
                this.ContractUpdated?.Invoke(this, e);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService?.LogException(ex);
            }
        }
 
        private Task ContractUpdatedOrSigned(ContractReferenceEventArgs e)
        {
            lock (this.lastContractEvent)
            {
                this.lastContractEvent[e.ContractId] = DateTime.Now;
            }
 
            return Task.CompletedTask;
        }
 
        public event ContractSignedEventHandler? ContractSigned;
 
        private async Task ContractsClient_ContractSigned(object? Sender, ContractSignedEventArgs e)
        {
            await this.ContractUpdatedOrSigned(e);
 
            try
            {
                this.ContractSigned?.Invoke(this, e);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService?.LogException(ex);
            }
        }
 
        public Task SendContractProposal(Contract Contract, string Role, string To, string Message)
        {
            return this.ContractsClient.SendContractProposal(Contract, Role, To, Message);
        }
 
        #endregion
 
        #region Attachments
 
        public Task<KeyValuePair<string, TemporaryFile>> GetAttachment(string Url, SignWith SignWith, TimeSpan Timeout)
        {
            return this.ContractsClient.GetAttachmentAsync(Url, SignWith, (int)Timeout.TotalMilliseconds);
        }
 
        #endregion
 
        #region Peer Review
 
        public async Task PetitionPeerReviewId(CaseInsensitiveString LegalId, LegalIdentity Identity, string PetitionId, string Purpose)
        {
            await this.ContractsClient.AuthorizeAccessToIdAsync(Identity.Id, LegalId, true);
 
            this.StartPetition(PetitionId);
            await this.ContractsClient.PetitionPeerReviewIDAsync(LegalId, Identity, PetitionId, Purpose);
        }
 
        public Task<LegalIdentity> AddPeerReviewIdAttachment(LegalIdentity Identity, LegalIdentity ReviewerLegalIdentity, byte[] PeerSignature)
        {
            return this.ContractsClient.AddPeerReviewIDAttachment(Identity, ReviewerLegalIdentity, PeerSignature);
        }
 
        public event SignaturePetitionEventHandler? PetitionForPeerReviewIdReceived;
 
        private async Task ContractsClient_PetitionForPeerReviewIdReceived(object? Sender, SignaturePetitionEventArgs e)
        {
            try
            {
                this.PetitionForPeerReviewIdReceived?.Invoke(this, e);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        public event SignaturePetitionResponseEventHandler? PetitionedPeerReviewIdResponseReceived;
 
        private async Task ContractsClient_PetitionedPeerReviewIdResponseReceived(object? Sender, SignaturePetitionResponseEventArgs e)
        {
            try
            {
                this.EndPetition(e.PetitionId);
                this.PetitionedPeerReviewIdResponseReceived?.Invoke(this, e);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        public async Task<ServiceProviderWithLegalId[]> GetServiceProvidersForPeerReviewAsync()
        {
            return await this.ContractsClient.GetPeerReviewIdServiceProvidersAsync();
        }
 
        public async Task SelectPeerReviewService(string ServiceId, string ServiceProvider)
        {
            await this.ContractsClient.SelectPeerReviewServiceAsync(ServiceProvider, ServiceId);
        }
 
        private readonly Dictionary<string, bool> currentPetitions = [];
 
        private async Task ContractsClient_PetitionClientUrlReceived(object? Sender, PetitionClientUrlEventArgs e)
        {
            lock (this.currentPetitions)
            {
                if (!this.currentPetitions.ContainsKey(e.PetitionId))
                {
                    ServiceRef.LogService.LogWarning("Client URL message for a petition is ignored. Petition ID not recognized.",
                        new KeyValuePair<string, object?>("PetitionId", e.PetitionId),
                        new KeyValuePair<string, object?>("ClientUrl", e.ClientUrl));
                    return;
                }
            }
 
            await App.OpenUrlAsync(e.ClientUrl);
        }
 
        #endregion
 
        #region Signatures
 
        public Task<byte[]> Sign(byte[] data, SignWith signWith)
        {
            return this.ContractsClient.SignAsync(data, signWith);
        }
 
        public bool? ValidateSignature(LegalIdentity legalIdentity, byte[] data, byte[] signature)
        {
            return this.ContractsClient.ValidateSignature(legalIdentity, data, signature);
        }
 
        public Task SendPetitionSignatureResponse(CaseInsensitiveString LegalId, byte[] Content, byte[] Signature, string PetitionId, string RequestorFullJid, bool Response)
        {
            return this.ContractsClient.PetitionSignatureResponseAsync(LegalId, Content, Signature, PetitionId, RequestorFullJid, Response);
        }
 
        public event SignaturePetitionEventHandler? PetitionForSignatureReceived;
 
        private async Task ContractsClient_PetitionForSignatureReceived(object? Sender, SignaturePetitionEventArgs e)
        {
            try
            {
                this.PetitionForSignatureReceived?.Invoke(this, e);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        public event SignaturePetitionResponseEventHandler? SignaturePetitionResponseReceived;
 
        private async Task ContractsClient_PetitionedSignatureResponseReceived(object? Sender, SignaturePetitionResponseEventArgs e)
        {
            try
            {
                this.EndPetition(e.PetitionId);
                this.SignaturePetitionResponseReceived?.Invoke(this, e);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        #endregion
 
        #region Provisioning
 
        private ProvisioningClient ProvisioningClient
        {
            get
            {
                if (this.provisioningClient is null)
                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.ProvisioningServiceNotFound)]);
 
                return this.provisioningClient;
            }
        }
 
        private async Task ProvisioningClient_IsFriendQuestion(object? Sender, IsFriendEventArgs e)
        {
            if (e.From.IndexOfAny(clientChars) < 0)
                await ServiceRef.NotificationService.NewEvent(new IsFriendNotificationEvent(e));
        }
 
        private async Task ProvisioningClient_CanReadQuestion(object? Sender, CanReadEventArgs e)
        {
            if (e.From.IndexOfAny(clientChars) < 0)
                await ServiceRef.NotificationService.NewEvent(new CanReadNotificationEvent(e));
        }
 
        private async Task ProvisioningClient_CanControlQuestion(object? Sender, CanControlEventArgs e)
        {
            if (e.From.IndexOfAny(clientChars) < 0)
                await ServiceRef.NotificationService.NewEvent(new CanControlNotificationEvent(e));
        }
 
        private static readonly char[] clientChars = ['@', '/'];
 
        public string ProvisioningServiceJid => this.ProvisioningClient.ProvisioningServerAddress;
 
        public void IsFriendResponse(string ProvisioningServiceJID, string JID, string RemoteJID, string Key, bool IsFriend,
            RuleRange Range, IqResultEventHandlerAsync Callback, object? State)
        {
            this.ProvisioningClient.IsFriendResponse(ProvisioningServiceJID, JID, RemoteJID, Key, IsFriend, Range, Callback, State);
        }
 
        public void CanControlResponseAll(string ProvisioningServiceJID, string JID, string RemoteJID, string Key, bool CanControl,
            string[]? ParameterNames, IThingReference Node, IqResultEventHandlerAsync Callback, object? State)
        {
            this.ProvisioningClient.CanControlResponseAll(ProvisioningServiceJID, JID, RemoteJID, Key, CanControl, ParameterNames,
                Node, Callback, State);
        }
 
        public void CanControlResponseCaller(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanControl, string[]? ParameterNames, IThingReference Node, IqResultEventHandlerAsync Callback, object? State)
        {
            this.ProvisioningClient.CanControlResponseCaller(ProvisioningServiceJID, JID, RemoteJID, Key, CanControl,
                ParameterNames, Node, Callback, State);
        }
 
        public void CanControlResponseDomain(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanControl, string[]? ParameterNames, IThingReference Node, IqResultEventHandlerAsync Callback, object? State)
        {
            this.ProvisioningClient.CanControlResponseDomain(ProvisioningServiceJID, JID, RemoteJID, Key, CanControl,
                ParameterNames, Node, Callback, State);
        }
 
        public void CanControlResponseDevice(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanControl, string[]? ParameterNames, string Token, IThingReference Node, IqResultEventHandlerAsync Callback,
            object? State)
        {
            this.ProvisioningClient.CanControlResponseDevice(ProvisioningServiceJID, JID, RemoteJID, Key, CanControl,
                ParameterNames, Token, Node, Callback, State);
        }
 
        public void CanControlResponseService(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanControl, string[]? ParameterNames, string Token, IThingReference Node, IqResultEventHandlerAsync Callback,
            object? State)
        {
            this.ProvisioningClient.CanControlResponseService(ProvisioningServiceJID, JID, RemoteJID, Key, CanControl,
                ParameterNames, Token, Node, Callback, State);
        }
 
        public void CanControlResponseUser(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanControl, string[]? ParameterNames, string Token, IThingReference Node, IqResultEventHandlerAsync Callback,
            object? State)
        {
            this.ProvisioningClient.CanControlResponseUser(ProvisioningServiceJID, JID, RemoteJID, Key, CanControl,
                ParameterNames, Token, Node, Callback, State);
        }
 
        public void CanReadResponseAll(string ProvisioningServiceJID, string JID, string RemoteJID, string Key, bool CanRead,
            FieldType FieldTypes, string[]? FieldNames, IThingReference Node, IqResultEventHandlerAsync Callback, object? State)
        {
            this.ProvisioningClient.CanReadResponseAll(ProvisioningServiceJID, JID, RemoteJID, Key, CanRead, FieldTypes, FieldNames,
                Node, Callback, State);
        }
 
        public void CanReadResponseCaller(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanRead, FieldType FieldTypes, string[]? FieldNames, IThingReference Node, IqResultEventHandlerAsync Callback, object? State)
        {
            this.ProvisioningClient.CanReadResponseCaller(ProvisioningServiceJID, JID, RemoteJID, Key, CanRead,
                FieldTypes, FieldNames, Node, Callback, State);
        }
 
        public void CanReadResponseDomain(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanRead, FieldType FieldTypes, string[]? FieldNames, IThingReference Node, IqResultEventHandlerAsync Callback, object? State)
        {
            this.ProvisioningClient.CanReadResponseDomain(ProvisioningServiceJID, JID, RemoteJID, Key, CanRead,
                FieldTypes, FieldNames, Node, Callback, State);
        }
 
        public void CanReadResponseDevice(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanRead, FieldType FieldTypes, string[]? FieldNames, string Token, IThingReference Node, IqResultEventHandlerAsync Callback,
            object? State)
        {
            this.ProvisioningClient.CanReadResponseDevice(ProvisioningServiceJID, JID, RemoteJID, Key, CanRead,
                FieldTypes, FieldNames, Token, Node, Callback, State);
        }
 
        public void CanReadResponseService(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanRead, FieldType FieldTypes, string[]? FieldNames, string Token, IThingReference Node, IqResultEventHandlerAsync Callback,
            object? State)
        {
            this.ProvisioningClient.CanReadResponseService(ProvisioningServiceJID, JID, RemoteJID, Key, CanRead,
                FieldTypes, FieldNames, Token, Node, Callback, State);
        }
 
        public void CanReadResponseUser(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanRead, FieldType FieldTypes, string[]? FieldNames, string Token, IThingReference Node, IqResultEventHandlerAsync Callback,
            object? State)
        {
            this.ProvisioningClient.CanReadResponseUser(ProvisioningServiceJID, JID, RemoteJID, Key, CanRead,
                FieldTypes, FieldNames, Token, Node, Callback, State);
        }
 
        public void DeleteDeviceRules(string ServiceJID, string DeviceJID, string NodeId, string SourceId, string Partition,
            IqResultEventHandlerAsync Callback, object? State)
        {
            this.ProvisioningClient.DeleteDeviceRules(ServiceJID, DeviceJID, NodeId, SourceId, Partition, Callback, State);
        }
 
        #endregion
 
        #region IoT
 
        private SensorClient SensorClient
        {
            get
            {
                if (this.sensorClient is null)
                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.SensorServiceNotFound)]);
 
                return this.sensorClient;
            }
        }
 
        private ControlClient ControlClient
        {
            get
            {
                if (this.controlClient is null)
                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.ControlServiceNotFound)]);
 
                return this.controlClient;
            }
        }
 
        private ConcentratorClient ConcentratorClient
        {
            get
            {
                if (this.concentratorClient is null)
                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.ConcentratorServiceNotFound)]);
 
                return this.concentratorClient;
            }
        }
 
        public Task<(SearchResultThing[], bool)> GetMyDevices(int Offset, int MaxCount)
        {
            TaskCompletionSource<(SearchResultThing[], bool)> Result = new();
 
            this.ProvisioningClient.GetDevices(Offset, MaxCount, (sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult((e.Things, e.More));
                else
                    Result.TrySetException(e.StanzaError ?? new Exception(ServiceRef.Localizer[nameof(AppResources.UnableToGetListOfMyDevices)]));
 
                return Task.CompletedTask;
            }, null);
 
            return Result.Task;
        }
 
        public async Task<SearchResultThing[]> GetAllMyDevices()
        {
            (SearchResultThing[] Things, bool More) = await this.GetMyDevices(0, Constants.BatchSizes.DeviceBatchSize);
            if (!More)
                return Things;
 
            List<SearchResultThing> Result = [];
            int Offset = Things.Length;
 
            Result.AddRange(Things);
 
            while (More)
            {
                (Things, More) = await this.GetMyDevices(Offset, Constants.BatchSizes.DeviceBatchSize);
                Result.AddRange(Things);
                Offset += Things.Length;
            }
 
            return [.. Result];
        }
 
        public void GetCertificate(string Token, CertificateCallback Callback, object? State)
        {
            this.ProvisioningClient.GetCertificate(Token, Callback, State);
        }
 
        public void GetControlForm(string To, string Language, DataFormResultEventHandler Callback, object? State,
            params ThingReference[] Nodes)
        {
            this.ControlClient.GetForm(To, Language, Callback, State, Nodes);
        }
 
        public SensorDataClientRequest RequestSensorReadout(string Destination, FieldType Types)
        {
            return this.SensorClient.RequestReadout(Destination, Types);
        }
 
        public SensorDataClientRequest RequestSensorReadout(string Destination, ThingReference[] Nodes, FieldType Types)
        {
            return this.SensorClient.RequestReadout(Destination, Nodes, Types);
        }
 
        #endregion
 
        #region e-Daler
 
        private readonly Dictionary<string, Wallet.Transaction> currentTransactions = [];
        private Balance? lastBalance = null;
        private DateTime lastEDalerEvent = DateTime.MinValue;
 
        private EDalerClient EDalerClient
        {
            get
            {
                if (this.eDalerClient is null)
                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.EDalerServiceNotFound)]);
 
                return this.eDalerClient;
            }
        }
 
        private void RegisterEDalerEventHandlers(EDalerClient Client)
        {
            Client.BalanceUpdated += this.EDalerClient_BalanceUpdated;
            Client.BuyEDalerOptionsClientUrlReceived += this.NeuroWallet_BuyEDalerOptionsClientUrlReceived;
            Client.BuyEDalerOptionsCompleted += this.NeuroWallet_BuyEDalerOptionsCompleted;
            Client.BuyEDalerOptionsError += this.NeuroWallet_BuyEDalerOptionsError;
            Client.BuyEDalerClientUrlReceived += this.NeuroWallet_BuyEDalerClientUrlReceived;
            Client.BuyEDalerCompleted += this.NeuroWallet_BuyEDalerCompleted;
            Client.BuyEDalerError += this.NeuroWallet_BuyEDalerError;
            Client.SellEDalerOptionsClientUrlReceived += this.NeuroWallet_SellEDalerOptionsClientUrlReceived;
            Client.SellEDalerOptionsCompleted += this.NeuroWallet_SellEDalerOptionsCompleted;
            Client.SellEDalerOptionsError += this.NeuroWallet_SellEDalerOptionsError;
            Client.SellEDalerClientUrlReceived += this.NeuroWallet_SellEDalerClientUrlReceived;
            Client.SellEDalerCompleted += this.NeuroWallet_SellEDalerCompleted;
            Client.SellEDalerError += this.NeuroWallet_SellEDalerError;
        }
 
        private async Task EDalerClient_BalanceUpdated(object? _, BalanceEventArgs e)
        {
            this.lastBalance = e.Balance;
            this.lastEDalerEvent = DateTime.Now;
 
            BalanceEventHandler? h = this.EDalerBalanceUpdated;
            if (h is not null)
            {
                try
                {
                    await h(this, e);
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex);
                }
            }
        }
 
        public event BalanceEventHandler? EDalerBalanceUpdated;
 
        public Balance? LastEDalerBalance => this.lastBalance;
 
        public DateTime LastEDalerEvent => this.lastEDalerEvent;
 
        public bool TryParseEDalerUri(string Uri, out EDalerUri Parsed, out string Reason)
        {
            return EDalerUri.TryParse(Uri, out Parsed, out Reason);
        }
 
        public async Task<string> TryDecryptMessage(byte[] EncryptedMessage, byte[] PublicKey, Guid TransactionId, string RemoteEndpoint)
        {
            try
            {
                return await this.EDalerClient.DecryptMessage(EncryptedMessage, PublicKey, TransactionId, RemoteEndpoint);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                return string.Empty;
            }
        }
 
        public Task<EDaler.Transaction> SendEDalerUri(string Uri)
        {
            return this.EDalerClient.SendEDalerUriAsync(Uri);
        }
 
        public Task<(AccountEvent[], bool)> GetEDalerAccountEvents(int MaxCount)
        {
            return this.EDalerClient.GetAccountEventsAsync(MaxCount);
        }
 
        public Task<(AccountEvent[], bool)> GetEDalerAccountEvents(int MaxCount, DateTime From)
        {
            return this.EDalerClient.GetAccountEventsAsync(MaxCount, From);
        }
 
        public Task<Balance> GetEDalerBalance()
        {
            return this.EDalerClient.GetBalanceAsync();
        }
 
        public Task<(decimal, string, PendingPayment[])> GetPendingEDalerPayments()
        {
            return this.EDalerClient.GetPendingPayments();
        }
 
        public Task<string> CreateFullEDalerPaymentUri(string ToBareJid, decimal Amount, decimal? AmountExtra, string Currency, int ValidNrDays)
        {
            this.lastEDalerEvent = DateTime.Now;
            return this.EDalerClient.CreateFullPaymentUri(ToBareJid, Amount, AmountExtra, Currency, ValidNrDays);
        }
 
        public Task<string> CreateFullEDalerPaymentUri(string ToBareJid, decimal Amount, decimal? AmountExtra, string Currency, int ValidNrDays, string Message)
        {
            this.lastEDalerEvent = DateTime.Now;
            return this.EDalerClient.CreateFullPaymentUri(ToBareJid, Amount, AmountExtra, Currency, ValidNrDays, Message);
        }
 
        public Task<string> CreateFullEDalerPaymentUri(LegalIdentity To, decimal Amount, decimal? AmountExtra, string Currency, int ValidNrDays)
        {
            this.lastEDalerEvent = DateTime.Now;
            return this.EDalerClient.CreateFullPaymentUri(To, Amount, AmountExtra, Currency, ValidNrDays);
        }
 
        public Task<string> CreateFullEDalerPaymentUri(LegalIdentity To, decimal Amount, decimal? AmountExtra, string Currency, int ValidNrDays, string PrivateMessage)
        {
            this.lastEDalerEvent = DateTime.Now;
            return this.EDalerClient.CreateFullPaymentUri(To, Amount, AmountExtra, Currency, ValidNrDays, PrivateMessage);
        }
 
        public string CreateIncompleteEDalerPayMeUri(string BareJid, decimal? Amount, decimal? AmountExtra, string Currency, string Message)
        {
            return this.EDalerClient.CreateIncompletePayMeUri(BareJid, Amount, AmountExtra, Currency, Message);
        }
 
        public string CreateIncompleteEDalerPayMeUri(LegalIdentity To, decimal? Amount, decimal? AmountExtra, string Currency, string PrivateMessage)
        {
            return this.EDalerClient.CreateIncompletePayMeUri(To, Amount, AmountExtra, Currency, PrivateMessage);
        }
 
        public async Task<IBuyEDalerServiceProvider[]> GetServiceProvidersForBuyingEDalerAsync()
        {
            return await this.EDalerClient.GetServiceProvidersForBuyingEDalerAsync();
        }
 
        public async Task<OptionsTransaction> InitiateBuyEDalerGetOptions(string ServiceId, string ServiceProvider)
        {
            string TransactionId = Guid.NewGuid().ToString();
            string SuccessUrl = GenerateNeuroAccessUrl(
                new KeyValuePair<string, object?>("cmd", "beos"),
                new KeyValuePair<string, object?>("tid", TransactionId),
                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),
                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));
            string FailureUrl = GenerateNeuroAccessUrl(
                new KeyValuePair<string, object?>("cmd", "beof"),
                new KeyValuePair<string, object?>("tid", TransactionId),
                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),
                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));
            string CancelUrl = GenerateNeuroAccessUrl(
                new KeyValuePair<string, object?>("cmd", "beoc"),
                new KeyValuePair<string, object?>("tid", TransactionId),
                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),
                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));
 
            TransactionId = await this.EDalerClient.InitiateGetOptionsBuyEDalerAsync(ServiceId, ServiceProvider, TransactionId, SuccessUrl, FailureUrl, CancelUrl);
            OptionsTransaction Result = new(TransactionId);
 
            lock (this.currentTransactions)
            {
                this.currentTransactions[TransactionId] = Result;
            }
 
            return Result;
        }
 
        private async Task NeuroWallet_BuyEDalerOptionsClientUrlReceived(object? Sender, BuyEDalerClientUrlEventArgs e)
        {
            lock (this.currentTransactions)
            {
                if (!this.currentTransactions.ContainsKey(e.TransactionId))
                {
                    ServiceRef.LogService.LogWarning("Client URL message for getting options for buying eDaler ignored. Transaction ID not recognized.",
                        new KeyValuePair<string, object?>("TransactionId", e.TransactionId),
                        new KeyValuePair<string, object?>("ClientUrl", e.ClientUrl));
                    return;
                }
            }
 
            await Wallet.Transaction.OpenUrl(e.ClientUrl);
        }
 
        private Task NeuroWallet_BuyEDalerOptionsCompleted(object? _, PaymentOptionsEventArgs e)
        {
            this.BuyEDalerGetOptionsCompleted(e.TransactionId, e.Options);
            return Task.CompletedTask;
        }
 
        public void BuyEDalerGetOptionsCompleted(string TransactionId, IDictionary<CaseInsensitiveString, object>[] Options)
        {
            Wallet.Transaction? Transaction;
 
            lock (this.currentTransactions)
            {
                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))
                    return;
 
                this.currentTransactions.Remove(TransactionId);
            }
 
            if (Transaction is OptionsTransaction OptionsTransaction)
                OptionsTransaction.Completed(Options);
        }
 
        private Task NeuroWallet_BuyEDalerOptionsError(object? _, PaymentErrorEventArgs e)
        {
            this.BuyEDalerGetOptionsFailed(e.TransactionId, e.Message);
            return Task.CompletedTask;
        }
 
        public void BuyEDalerGetOptionsFailed(string TransactionId, string Message)
        {
            Wallet.Transaction? Transaction;
 
            lock (this.currentTransactions)
            {
                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))
                    return;
 
                this.currentTransactions.Remove(TransactionId);
            }
 
            Transaction.ErrorReported(Message);
        }
 
        public async Task<PaymentTransaction> InitiateBuyEDaler(string ServiceId, string ServiceProvider, decimal Amount, string Currency)
        {
            string TransactionId = Guid.NewGuid().ToString();
            string SuccessUrl = GenerateNeuroAccessUrl(
                new KeyValuePair<string, object?>("cmd", "bes"),
                new KeyValuePair<string, object?>("tid", TransactionId),
                new KeyValuePair<string, object?>("amt", Amount),
                new KeyValuePair<string, object?>("cur", Currency),
                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),
                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));
            string FailureUrl = GenerateNeuroAccessUrl(
                new KeyValuePair<string, object?>("cmd", "bef"),
                new KeyValuePair<string, object?>("tid", TransactionId),
                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),
                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));
            string CancelUrl = GenerateNeuroAccessUrl(
                new KeyValuePair<string, object?>("cmd", "bec"),
                new KeyValuePair<string, object?>("tid", TransactionId),
                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),
                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));
 
            TransactionId = await this.EDalerClient.InitiateBuyEDalerAsync(ServiceId, ServiceProvider, Amount, Currency, TransactionId, SuccessUrl, FailureUrl, CancelUrl);
            PaymentTransaction Result = new(TransactionId, Currency);
 
            lock (this.currentTransactions)
            {
                this.currentTransactions[TransactionId] = Result;
            }
 
            return Result;
        }
 
        private static string GenerateNeuroAccessUrl(params KeyValuePair<string, object?>[] Claims)
        {
            string Token = ServiceRef.CryptoService.GenerateJwtToken(Claims);
            return Constants.UriSchemes.NeuroAccess + ":" + Token;
        }
 
        private async Task NeuroWallet_BuyEDalerClientUrlReceived(object? Sender, BuyEDalerClientUrlEventArgs e)
        {
            lock (this.currentTransactions)
            {
                if (!this.currentTransactions.ContainsKey(e.TransactionId))
                {
                    ServiceRef.LogService.LogWarning("Client URL message for buying eDaler ignored. Transaction ID not recognized.",
                        new KeyValuePair<string, object?>("TransactionId", e.TransactionId),
                        new KeyValuePair<string, object?>("ClientUrl", e.ClientUrl));
                    return;
                }
            }
 
            await Wallet.Transaction.OpenUrl(e.ClientUrl);
        }
 
        private Task NeuroWallet_BuyEDalerCompleted(object? _, PaymentCompletedEventArgs e)
        {
            this.BuyEDalerCompleted(e.TransactionId, e.Amount, e.Currency);
            return Task.CompletedTask;
        }
 
        public void BuyEDalerCompleted(string TransactionId, decimal Amount, string Currency)
        {
            Wallet.Transaction? Transaction;
 
            lock (this.currentTransactions)
            {
                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))
                    return;
 
                this.currentTransactions.Remove(TransactionId);
            }
 
            if (Transaction is PaymentTransaction PaymentTransaction)
                PaymentTransaction.Completed(Amount, Currency);
        }
 
        private Task NeuroWallet_BuyEDalerError(object? _, PaymentErrorEventArgs e)
        {
            this.BuyEDalerFailed(e.TransactionId, e.Message);
            return Task.CompletedTask;
        }
 
        public void BuyEDalerFailed(string TransactionId, string Message)
        {
            Wallet.Transaction? Transaction;
 
            lock (this.currentTransactions)
            {
                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))
                    return;
 
                this.currentTransactions.Remove(TransactionId);
            }
 
            Transaction.ErrorReported(Message);
        }
 
        public async Task<ISellEDalerServiceProvider[]> GetServiceProvidersForSellingEDalerAsync()
        {
            return await this.EDalerClient.GetServiceProvidersForSellingEDalerAsync();
        }
 
        public async Task<OptionsTransaction> InitiateSellEDalerGetOptions(string ServiceId, string ServiceProvider)
        {
            string TransactionId = Guid.NewGuid().ToString();
            string SuccessUrl = GenerateNeuroAccessUrl(
                new KeyValuePair<string, object?>("cmd", "seos"),
                new KeyValuePair<string, object?>("tid", TransactionId),
                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),
                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));
            string FailureUrl = GenerateNeuroAccessUrl(
                new KeyValuePair<string, object?>("cmd", "seof"),
                new KeyValuePair<string, object?>("tid", TransactionId),
                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),
                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));
            string CancelUrl = GenerateNeuroAccessUrl(
                new KeyValuePair<string, object?>("cmd", "seoc"),
                new KeyValuePair<string, object?>("tid", TransactionId),
                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),
                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));
 
            TransactionId = await this.EDalerClient.InitiateGetOptionsSellEDalerAsync(ServiceId, ServiceProvider, TransactionId, SuccessUrl, FailureUrl, CancelUrl);
            OptionsTransaction Result = new(TransactionId);
 
            lock (this.currentTransactions)
            {
                this.currentTransactions[TransactionId] = Result;
            }
 
            return Result;
        }
 
        private async Task NeuroWallet_SellEDalerOptionsClientUrlReceived(object? Sender, SellEDalerClientUrlEventArgs e)
        {
            lock (this.currentTransactions)
            {
                if (!this.currentTransactions.ContainsKey(e.TransactionId))
                {
                    ServiceRef.LogService.LogWarning("Client URL message for getting options for selling eDaler ignored. Transaction ID not recognized.",
                        new KeyValuePair<string, object?>("TransactionId", e.TransactionId),
                        new KeyValuePair<string, object?>("ClientUrl", e.ClientUrl));
                    return;
                }
            }
 
            await Wallet.Transaction.OpenUrl(e.ClientUrl);
        }
 
        private Task NeuroWallet_SellEDalerOptionsCompleted(object? _, PaymentOptionsEventArgs e)
        {
            this.SellEDalerGetOptionsCompleted(e.TransactionId, e.Options);
            return Task.CompletedTask;
        }
 
        public void SellEDalerGetOptionsCompleted(string TransactionId, IDictionary<CaseInsensitiveString, object>[] Options)
        {
            Wallet.Transaction? Transaction;
 
            lock (this.currentTransactions)
            {
                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))
                    return;
 
                this.currentTransactions.Remove(TransactionId);
            }
 
            if (Transaction is OptionsTransaction OptionsTransaction)
                OptionsTransaction.Completed(Options);
        }
 
        private Task NeuroWallet_SellEDalerOptionsError(object? _, PaymentErrorEventArgs e)
        {
            this.SellEDalerGetOptionsFailed(e.TransactionId, e.Message);
            return Task.CompletedTask;
        }
 
        public void SellEDalerGetOptionsFailed(string TransactionId, string Message)
        {
            Wallet.Transaction? Transaction;
 
            lock (this.currentTransactions)
            {
                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))
                    return;
 
                this.currentTransactions.Remove(TransactionId);
            }
 
            Transaction.ErrorReported(Message);
        }
 
        public async Task<PaymentTransaction> InitiateSellEDaler(string ServiceId, string ServiceProvider, decimal Amount, string Currency)
        {
            string TransactionId = Guid.NewGuid().ToString();
            string SuccessUrl = GenerateNeuroAccessUrl(
                new KeyValuePair<string, object?>("cmd", "ses"),
                new KeyValuePair<string, object?>("tid", TransactionId),
                new KeyValuePair<string, object?>("amt", Amount),
                new KeyValuePair<string, object?>("cur", Currency),
                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),
                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));
            string FailureUrl = GenerateNeuroAccessUrl(
                new KeyValuePair<string, object?>("cmd", "sef"),
                new KeyValuePair<string, object?>("tid", TransactionId),
                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),
                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));
            string CancelUrl = GenerateNeuroAccessUrl(
                new KeyValuePair<string, object?>("cmd", "sec"),
                new KeyValuePair<string, object?>("tid", TransactionId),
                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),
                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),
                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));
 
            TransactionId = await this.EDalerClient.InitiateSellEDalerAsync(ServiceId, ServiceProvider, Amount, Currency, TransactionId, SuccessUrl, FailureUrl, CancelUrl);
            PaymentTransaction Result = new(TransactionId, Currency);
 
            lock (this.currentTransactions)
            {
                this.currentTransactions[TransactionId] = Result;
            }
 
            return Result;
        }
 
        private async Task NeuroWallet_SellEDalerClientUrlReceived(object? Sender, SellEDalerClientUrlEventArgs e)
        {
            lock (this.currentTransactions)
            {
                if (!this.currentTransactions.ContainsKey(e.TransactionId))
                {
                    ServiceRef.LogService.LogWarning("Client URL message ignored. Transaction ID not recognized.",
                        new KeyValuePair<string, object?>("TransactionId", e.TransactionId),
                        new KeyValuePair<string, object?>("ClientUrl", e.ClientUrl));
                    return;
                }
            }
 
            await Wallet.Transaction.OpenUrl(e.ClientUrl);
        }
 
        private Task NeuroWallet_SellEDalerError(object? _, PaymentErrorEventArgs e)
        {
            this.SellEDalerFailed(e.TransactionId, e.Message);
            return Task.CompletedTask;
        }
 
        public void SellEDalerFailed(string TransactionId, string Message)
        {
            Wallet.Transaction? Transaction;
 
            lock (this.currentTransactions)
            {
                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))
                    return;
 
                this.currentTransactions.Remove(TransactionId);
            }
 
            Transaction.ErrorReported(Message);
        }
 
        private Task NeuroWallet_SellEDalerCompleted(object? _, PaymentCompletedEventArgs e)
        {
            this.SellEDalerCompleted(e.TransactionId, e.Amount, e.Currency);
            return Task.CompletedTask;
        }
 
        public void SellEDalerCompleted(string TransactionId, decimal Amount, string Currency)
        {
            Wallet.Transaction? Transaction;
 
            lock (this.currentTransactions)
            {
                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))
                    return;
 
                this.currentTransactions.Remove(TransactionId);
            }
 
            if (Transaction is PaymentTransaction PaymentTransaction)
                PaymentTransaction.Completed(Amount, Currency);
        }
 
        #endregion
 
        #region Neuro-Features
 
        private DateTime lastTokenEvent = DateTime.MinValue;
 
        private NeuroFeaturesClient NeuroFeaturesClient
        {
            get
            {
                if (this.neuroFeaturesClient is null)
                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.NeuroFeaturesServiceNotFound)]);
 
                return this.neuroFeaturesClient;
            }
        }
 
        private void RegisterNeuroFeatureEventHandlers(NeuroFeaturesClient Client)
        {
            Client.TokenAdded += this.NeuroFeaturesClient_TokenAdded;
            Client.TokenRemoved += this.NeuroFeaturesClient_TokenRemoved;
 
            Client.StateUpdated += this.NeuroFeaturesClient_StateUpdated;
            Client.VariablesUpdated += this.NeuroFeaturesClient_VariablesUpdated;
        }
 
        public DateTime LastNeuroFeatureEvent => this.lastTokenEvent;
 
        private async Task NeuroFeaturesClient_TokenRemoved(object _, NeuroFeatures.TokenEventArgs e)
        {
            this.lastTokenEvent = DateTime.Now;
 
            NeuroFeatures.TokenEventHandler? h = this.NeuroFeatureRemoved;
            if (h is not null)
            {
                try
                {
                    await h(this, e);
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex);
                }
            }
        }
 
        public event NeuroFeatures.TokenEventHandler? NeuroFeatureRemoved;
 
        private async Task NeuroFeaturesClient_TokenAdded(object _, NeuroFeatures.TokenEventArgs e)
        {
            this.lastTokenEvent = DateTime.Now;
 
            NeuroFeatures.TokenEventHandler? h = this.NeuroFeatureAdded;
            if (h is not null)
            {
                try
                {
                    await h(this, e);
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex);
                }
            }
        }
 
        public event NeuroFeatures.TokenEventHandler? NeuroFeatureAdded;
 
        private async Task NeuroFeaturesClient_VariablesUpdated(object? _, VariablesUpdatedEventArgs e)
        {
            VariablesUpdatedEventHandler? h = this.NeuroFeatureVariablesUpdated;
            if (h is not null)
            {
                try
                {
                    await h(this, e);
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex);
                }
            }
        }
 
        public event VariablesUpdatedEventHandler? NeuroFeatureVariablesUpdated;
 
        private async Task NeuroFeaturesClient_StateUpdated(object? _, NewStateEventArgs e)
        {
            NewStateEventHandler? h = this.NeuroFeatureStateUpdated;
            if (h is not null)
            {
                try
                {
                    await h(this, e);
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex);
                }
            }
        }
 
        public event NewStateEventHandler? NeuroFeatureStateUpdated;
 
        public Task<TokensEventArgs> GetNeuroFeatures()
        {
            return this.GetNeuroFeatures(0, int.MaxValue);
        }
 
        public Task<TokensEventArgs> GetNeuroFeatures(int Offset, int MaxCount)
        {
            return this.NeuroFeaturesClient.GetTokensAsync(Offset, MaxCount);
        }
 
        public Task<string[]> GetNeuroFeatureReferences()
        {
            return this.GetNeuroFeatureReferences(0, int.MaxValue);
        }
 
        public Task<string[]> GetNeuroFeatureReferences(int Offset, int MaxCount)
        {
            return this.NeuroFeaturesClient.GetTokenReferencesAsync(Offset, MaxCount);
        }
 
        public Task<TokenTotalsEventArgs> GetNeuroFeatureTotals()
        {
            return this.NeuroFeaturesClient.GetTotalsAsync();
        }
 
        public Task<TokensEventArgs> GetNeuroFeaturesForContract(string ContractId)
        {
            return this.NeuroFeaturesClient.GetContractTokensAsync(ContractId);
        }
 
        public Task<TokensEventArgs> GetNeuroFeaturesForContract(string ContractId, int Offset, int MaxCount)
        {
            return this.NeuroFeaturesClient.GetContractTokensAsync(ContractId, Offset, MaxCount);
        }
 
        public Task<string[]> GetNeuroFeatureReferencesForContract(string ContractId)
        {
            return this.NeuroFeaturesClient.GetContractTokenReferencesAsync(ContractId);
        }
 
        public Task<string[]> GetNeuroFeatureReferencesForContract(string ContractId, int Offset, int MaxCount)
        {
            return this.NeuroFeaturesClient.GetContractTokenReferencesAsync(ContractId, Offset, MaxCount);
        }
 
        public Task<Token> GetNeuroFeature(string TokenId)
        {
            return this.NeuroFeaturesClient.GetTokenAsync(TokenId);
        }
 
        public Task<TokenEvent[]> GetNeuroFeatureEvents(string TokenId)
        {
            return this.GetNeuroFeatureEvents(TokenId, 0, int.MaxValue);
        }
 
        public Task<TokenEvent[]> GetNeuroFeatureEvents(string TokenId, int Offset, int MaxCount)
        {
            return this.NeuroFeaturesClient.GetEventsAsync(TokenId, Offset, MaxCount);
        }
 
        public Task AddNeuroFeatureTextNote(string TokenId, string TextNote)
        {
            return this.AddNeuroFeatureTextNote(TokenId, TextNote, false);
        }
 
        public Task AddNeuroFeatureTextNote(string TokenId, string TextNote, bool Personal)
        {
            this.lastTokenEvent = DateTime.Now;
 
            return this.NeuroFeaturesClient.AddTextNoteAsync(TokenId, TextNote, Personal);
        }
 
        public Task AddNeuroFeatureXmlNote(string TokenId, string XmlNote)
        {
            return this.AddNeuroFeatureXmlNote(TokenId, XmlNote, false);
        }
 
        public Task AddNeuroFeatureXmlNote(string TokenId, string XmlNote, bool Personal)
        {
            this.lastTokenEvent = DateTime.Now;
 
            return this.NeuroFeaturesClient.AddXmlNoteAsync(TokenId, XmlNote, Personal);
        }
 
        public Task<CreationAttributesEventArgs> GetNeuroFeatureCreationAttributes()
        {
            return this.NeuroFeaturesClient.GetCreationAttributesAsync();
        }
 
        public async Task<string> GenerateNeuroFeatureStateDiagramReport(string TokenId)
        {
            ReportEventArgs e = await this.NeuroFeaturesClient.GenerateStateDiagramAsync(TokenId, ReportFormat.Markdown);
            if (!e.Ok)
                throw e.StanzaError ?? new Exception(ServiceRef.Localizer[nameof(AppResources.UnableToGetStateDiagram)]);
 
            return await e.ReportText.MarkdownToXaml();
        }
 
        public async Task<string> GenerateNeuroFeatureProfilingReport(string TokenId)
        {
            ReportEventArgs e = await this.NeuroFeaturesClient.GenerateProfilingReportAsync(TokenId, ReportFormat.Markdown);
            if (!e.Ok)
                throw e.StanzaError ?? new Exception(ServiceRef.Localizer[nameof(AppResources.UnableToGetProfiling)]);
 
            return await e.ReportText.MarkdownToXaml();
        }
 
        public async Task<string> GenerateNeuroFeaturePresentReport(string TokenId)
        {
            ReportEventArgs e = await this.NeuroFeaturesClient.GeneratePresentReportAsync(TokenId, ReportFormat.Markdown);
            if (!e.Ok)
                throw e.StanzaError ?? new Exception(ServiceRef.Localizer[nameof(AppResources.UnableToGetPresent)]);
 
            return await e.ReportText.MarkdownToXaml();
        }
 
        public async Task<string> GenerateNeuroFeatureHistoryReport(string TokenId)
        {
            ReportEventArgs e = await this.NeuroFeaturesClient.GenerateHistoryReportAsync(TokenId, ReportFormat.Markdown);
            if (!e.Ok)
                throw e.StanzaError ?? new Exception(ServiceRef.Localizer[nameof(AppResources.UnableToGetHistory)]);
 
            return await e.ReportText.MarkdownToXaml();
        }
 
        public Task<CurrentStateEventArgs> GetNeuroFeatureCurrentState(string TokenId)
        {
            return this.NeuroFeaturesClient.GetCurrentStateAsync(TokenId);
        }
 
        #endregion
 
        #region Private XML
 
        public Task SavePrivateXml(string Xml)
        {
            return this.xmppClient?.SetPrivateXmlElementAsync(Xml)
                ?? throw new Exception("Not connected to XMPP network.");
        }
 
        public Task SavePrivateXml(XmlElement Xml)
        {
            return this.xmppClient?.SetPrivateXmlElementAsync(Xml)
                ?? throw new Exception("Not connected to XMPP network.");
        }
 
        public async Task<XmlElement?> LoadPrivateXml(string LocalName, string Namespace)
        {
            return await this.XmppClient.GetPrivateXmlElementAsync(LocalName, Namespace);
        }
 
        public Task DeletePrivateXml(string LocalName, string Namespace)
        {
            StringBuilder Xml = new();
 
            Xml.Append('<');
            Xml.Append(XML.Encode(LocalName));
            Xml.Append(" xmlns='");
            Xml.Append(XML.Encode(Namespace));
            Xml.Append("'/>");
            return this.SavePrivateXml(Xml.ToString());
        }
 
        #endregion
 
    }
}