PubSubComponent.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Xml;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.DataForms;
using Waher.Networking.XMPP.DataForms.DataTypes;
using Waher.Networking.XMPP.DataForms.FieldTypes;
using Waher.Networking.XMPP.DataForms.ValidationMethods;
using Waher.Networking.XMPP.Provisioning;
using Waher.Networking.XMPP.Server;
using Waher.Networking.XMPP.Server.ResultSetManagement;
using Waher.Persistence;
using Waher.Persistence.Files;
using Waher.Persistence.Filters;
using Waher.Persistence.Serialization;
using Waher.Runtime.Cache;
using Waher.Runtime.Inventory;
using Waher.Runtime.Settings;
 
namespace Waher.Service.IoTBroker.PubSub
{
    public class PubSubComponent : Component
    {
        public const string NamespacePubSub = "http://jabber.org/protocol/pubsub";
 
        public const string NamespacePubSubOwner = "http://jabber.org/protocol/pubsub#owner";
 
        public const string NamespacePubSubEvents = "http://jabber.org/protocol/pubsub#event";
 
        public const string NamespaceStanzaHeaders = "http://jabber.org/protocol/shim";
 
        public const string FormTypeNodeConfig = "http://jabber.org/protocol/pubsub#node_config";
 
        public const string FormTypeSubscribeOptions = "http://jabber.org/protocol/pubsub#subscribe_options";
 
        public const string FormTypeSubscriptionAuthorization = "http://jabber.org/protocol/pubsub#subscribe_authorization";
 
        public const string FormTypeNodeMetaData = "http://jabber.org/protocol/pubsub#meta-data";
 
        public const string NamespacePubSubAccessAuthorize = "http://jabber.org/protocol/pubsub#access-authorize";
 
        public const string NamespacePubSubAccessOpen = "http://jabber.org/protocol/pubsub#access-open";
 
        public const string NamespacePubSubAccessPresence = "http://jabber.org/protocol/pubsub#access-presence";
 
        public const string NamespacePubSubAccessRoster = "http://jabber.org/protocol/pubsub#access-roster";
 
        public const string NamespacePubSubAccessWhitelist = "http://jabber.org/protocol/pubsub#access-whitelist";
 
        public const string NamespacePubSubCollections = "http://jabber.org/protocol/pubsub#collections";
 
        public const string NamespacePubSubNodeConfiguration = "http://jabber.org/protocol/pubsub#config-node";
 
        public const string NamespacePubSubCreateAndConfigure = "http://jabber.org/protocol/pubsub#create-and-configure";
 
        public const string NamespacePubSubCreateNodes = "http://jabber.org/protocol/pubsub#create-nodes";
 
        public const string NamespacePubSubDeleteItems = "http://jabber.org/protocol/pubsub#delete-items";
 
        public const string NamespacePubSubDeleteNodes = "http://jabber.org/protocol/pubsub#delete-nodes";
 
        public const string NamespacePubSubItemIds = "http://jabber.org/protocol/pubsub#item-ids";
 
        public const string NamespacePubSubLastPublished = "http://jabber.org/protocol/pubsub#last-published";
 
        public const string NamespacePubSubLeasedSubscription = "http://jabber.org/protocol/pubsub#leased-subscription";
 
        public const string NamespacePubSubManageSubscriptions = "http://jabber.org/protocol/pubsub#manage-subscriptions";
 
        public const string NamespacePubSubemberAffiliation = "http://jabber.org/protocol/pubsub#member-affiliation";
 
        public const string NamespacePubSubMetaData = "http://jabber.org/protocol/pubsub#meta-data";
 
        public const string NamespacePubSubModifyAffiliations = "http://jabber.org/protocol/pubsub#modify-affiliations";
 
        public const string NamespacePubSubMultiCollecton = "http://jabber.org/protocol/pubsub#multi-collection";
 
        public const string NamespacePubSubMultiItems = "http://jabber.org/protocol/pubsub#multi-items";
 
        public const string NamespacePubSubOutcastAffiliation = "http://jabber.org/protocol/pubsub#outcast-affiliation";
 
        public const string NamespacePubSubPersistentItems = "http://jabber.org/protocol/pubsub#persistent-items";
 
        public const string NamespacePubSubPresenceSubscribe = "http://jabber.org/protocol/pubsub#presence-subscribe";
 
        public const string NamespacePubSubPublish = "http://jabber.org/protocol/pubsub#publish";
 
        public const string NamespacePubSubPublishOnlyAffiliation = "http://jabber.org/protocol/pubsub#publish-only-affiliation";
 
        public const string NamespacePubSubPublisheAffiliation = "http://jabber.org/protocol/pubsub#publisher-affiliation";
 
        public const string NamespacePubSubPurgeNodes = "http://jabber.org/protocol/pubsub#purge-nodes";
 
        public const string NamespacePubSubRetractItems = "http://jabber.org/protocol/pubsub#retract-items";
 
        public const string NamespacePubSubRetrieveAffiliations = "http://jabber.org/protocol/pubsub#retrieve-affiliations";
 
        public const string NamespacePubSubRetrieveDefault = "http://jabber.org/protocol/pubsub#retrieve-default";
 
        public const string NamespacePubSubRetrieveDefaultSub = "http://jabber.org/protocol/pubsub#retrieve-default-sub";
 
        public const string NamespacePubSubRetrieveItems = "http://jabber.org/protocol/pubsub#retrieve-items";
 
        public const string NamespacePubSubRetrieveSubscriptions = "http://jabber.org/protocol/pubsub#retrieve-subscriptions";
 
        public const string NamespacePubSubSubscribe = "http://jabber.org/protocol/pubsub#subscribe";
 
        public const string NamespacePubSubSubscriptionOptions = "http://jabber.org/protocol/pubsub#subscription-options";
 
        public const string NamespacePubSubSubscriptionNotifications = "http://jabber.org/protocol/pubsub#subscription-notifications";
 
        public const string NamespacePubSubAutoCreate = "http://jabber.org/protocol/pubsub#auto-create";
 
        public const string NamespacePubSubAutoSubscribe = "http://jabber.org/protocol/pubsub#auto-subscribe";
 
 
        private static ProvisioningClient provisioningClient = null;
 
        private readonly Dictionary<CaseInsensitiveString, Nodes> nodesByServiceAndName = new Dictionary<CaseInsensitiveString, Nodes>();
        private readonly Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Subscription>>> subscriptionsByServiceAndNodeAndJid = new Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Subscription>>>();
        private readonly Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Subscription>>> subscriptionsByJidAndServiceAndNode = new Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Subscription>>>();
        private readonly Dictionary<CaseInsensitiveString, NodeVerInfo> nodeVerByFullJidByBareJid = new Dictionary<CaseInsensitiveString, NodeVerInfo>();
        private Cache<string, Dictionary<string, bool>> featuresByNodeVer = new Cache<string, Dictionary<string, bool>>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromDays(1));
        private Cache<CaseInsensitiveString, PubSubItem> items = new Cache<CaseInsensitiveString, PubSubItem>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromMinutes(1));
        private ObjectSerializer itemSerializer;
 
        private class Nodes
        {
            public Dictionary<string, PubSubNode> NodesByName;
            public PubSubNode[] NodesArray;
        }
 
        private PubSubComponent(XmppServer Server, CaseInsensitiveString Subdomain, string Name)
            : base(Server, Subdomain, Name)
        {
            this.RegisterIqGetHandler("pubsub", NamespacePubSub, this.PubSubGetHandler, true);
            Server.RegisterIqGetHandler("pubsub", NamespacePubSub, this.PepGetHandler, false);
            Server.Accounts.RegisterIqGetHandler("pubsub", NamespacePubSub, this.PepGetHandler, true);
 
            this.RegisterIqSetHandler("pubsub", NamespacePubSub, this.PubSubSetHandler, false);
            Server.RegisterIqSetHandler("pubsub", NamespacePubSub, this.PepSetHandler, false);
            Server.Accounts.RegisterIqSetHandler("pubsub", NamespacePubSub, this.PepSetHandler, false);
 
            this.RegisterIqGetHandler("pubsub", NamespacePubSubOwner, this.PubSubOwnerGetHandler, true);
            Server.RegisterIqGetHandler("pubsub", NamespacePubSubOwner, this.PepOwnerGetHandler, false);
            Server.Accounts.RegisterIqGetHandler("pubsub", NamespacePubSubOwner, this.PepOwnerGetHandler, true);
 
            this.RegisterIqSetHandler("pubsub", NamespacePubSubOwner, this.PubSubOwnerSetHandler, false);
            Server.RegisterIqSetHandler("pubsub", NamespacePubSubOwner, this.PepOwnerSetHandler, false);
            Server.Accounts.RegisterIqSetHandler("pubsub", NamespacePubSubOwner, this.PepOwnerSetHandler, false);
 
            this.RegisterMessageHandler("x", Networking.XMPP.XmppClient.NamespaceData, this.MessageFormHandler, true);
            Server.RegisterMessageHandler("x", Networking.XMPP.XmppClient.NamespaceData, this.PepMessageFormHandler, false);
            Server.Accounts.RegisterMessageHandler("x", Networking.XMPP.XmppClient.NamespaceData, this.PepMessageFormHandler, true);
 
            Server.Accounts.OnDiscoveryQueryNodeGet += this.PepDiscoveryQueryGet;
            Server.Accounts.OnDiscoveryQueryNodeItemsGet += this.PepDiscoveryQueryItemsGet;
            Server.Accounts.DiscoverIdentities += this.PepDiscoverIdentities;
 
            // TODO: http://jabber.org/protocol/pubsub#get-pending
 
            this.AddFeatures(this, pubSubFeatures);
            this.AddFeatures(Server.Accounts, pepFeatures);
 
            if (provisioningClient is null)
            {
                if (Types.TryGetModuleParameter("Provisioning", out object Obj))
                    provisioningClient = Obj as ProvisioningClient;
                else
                    provisioningClient = null;
            }
 
            Server.OnPresenceLocalRecipient += this.Server_OnPresenceLocalRecipient;
        }
 
        public static async Task<PubSubComponent> Create(XmppServer Server, CaseInsensitiveString Subdomain, string Name)
        {
            PubSubComponent Result = new PubSubComponent(Server, Subdomain, Name);
 
            if (Database.Provider is FilesProvider FilesProvider)
                Result.itemSerializer = await FilesProvider.GetObjectSerializerEx(typeof(PubSubItem));
            else
                Result.itemSerializer = null;
 
            return Result;
        }
 
        private static readonly DefaultFeatures pubSubFeatures = new DefaultFeatures()
        {
            AutoCreate = false,
            AutoSubscribe = false
        };
 
        private static readonly DefaultFeatures pepFeatures = new DefaultFeatures()
        {
            AutoCreate = true,
            AutoSubscribe = true
        };
 
        private void AddFeatures(Component Component, DefaultFeatures Features)
        {
            Component.RegisterFeature(NamespacePubSubAccessAuthorize);
            Component.RegisterFeature(NamespacePubSubAccessOpen);
            Component.RegisterFeature(NamespacePubSubAccessPresence);
            Component.RegisterFeature(NamespacePubSubAccessRoster);
            Component.RegisterFeature(NamespacePubSubAccessWhitelist);
            Component.RegisterFeature(NamespacePubSubCollections);
            Component.RegisterFeature(NamespacePubSubNodeConfiguration);
            Component.RegisterFeature(NamespacePubSubCreateAndConfigure);
            Component.RegisterFeature(NamespacePubSubCreateNodes);
            Component.RegisterFeature(NamespacePubSubDeleteItems);
            Component.RegisterFeature(NamespacePubSubDeleteNodes);
            Component.RegisterFeature(NamespacePubSubItemIds);
            Component.RegisterFeature(NamespacePubSubLastPublished);
            Component.RegisterFeature(NamespacePubSubLeasedSubscription);
            Component.RegisterFeature(NamespacePubSubManageSubscriptions);
            Component.RegisterFeature(NamespacePubSubemberAffiliation);
            Component.RegisterFeature(NamespacePubSubMetaData);
            Component.RegisterFeature(NamespacePubSubModifyAffiliations);
            Component.RegisterFeature(NamespacePubSubMultiCollecton);
            Component.RegisterFeature(NamespacePubSubMultiItems);
            Component.RegisterFeature(NamespacePubSubOutcastAffiliation);
            Component.RegisterFeature(NamespacePubSubPersistentItems);
            Component.RegisterFeature(NamespacePubSubPresenceSubscribe);
            Component.RegisterFeature(NamespacePubSubPublish);
            Component.RegisterFeature(NamespacePubSubPublishOnlyAffiliation);
            Component.RegisterFeature(NamespacePubSubPublisheAffiliation);
            Component.RegisterFeature(NamespacePubSubPurgeNodes);
            Component.RegisterFeature(NamespacePubSubRetractItems);
            Component.RegisterFeature(NamespacePubSubRetrieveAffiliations);
            Component.RegisterFeature(NamespacePubSubRetrieveDefault);
            Component.RegisterFeature(NamespacePubSubRetrieveDefaultSub);
            Component.RegisterFeature(NamespacePubSubRetrieveItems);
            Component.RegisterFeature(NamespacePubSubRetrieveSubscriptions);
            Component.RegisterFeature(NamespacePubSubSubscribe);
            Component.RegisterFeature(NamespacePubSubSubscriptionOptions);
            Component.RegisterFeature(NamespacePubSubSubscriptionNotifications);
            Component.RegisterFeature(RestrictedQuery.NamespaceResultSetManagement);
 
            if (Features.AutoCreate)
                Component.RegisterFeature(NamespacePubSubAutoCreate);
 
            if (Features.AutoSubscribe)
                Component.RegisterFeature(NamespacePubSubAutoSubscribe);
        }
 
        public override void Dispose()
        {
            this.UnregisterIqGetHandler("pubsub", NamespacePubSub, this.PubSubGetHandler, true);
            this.Server.UnregisterIqGetHandler("pubsub", NamespacePubSub, this.PepGetHandler, false);
            this.Server.Accounts.UnregisterIqGetHandler("pubsub", NamespacePubSub, this.PepGetHandler, true);
 
            this.UnregisterIqSetHandler("pubsub", NamespacePubSub, this.PubSubSetHandler, false);
            this.Server.UnregisterIqSetHandler("pubsub", NamespacePubSub, this.PepSetHandler, false);
            this.Server.Accounts.UnregisterIqSetHandler("pubsub", NamespacePubSub, this.PepSetHandler, false);
 
            this.UnregisterIqGetHandler("pubsub", NamespacePubSubOwner, this.PubSubOwnerGetHandler, true);
            this.Server.UnregisterIqGetHandler("pubsub", NamespacePubSubOwner, this.PepOwnerGetHandler, false);
            this.Server.Accounts.UnregisterIqGetHandler("pubsub", NamespacePubSubOwner, this.PepOwnerGetHandler, true);
 
            this.UnregisterIqSetHandler("pubsub", NamespacePubSubOwner, this.PubSubOwnerSetHandler, false);
            this.Server.UnregisterIqSetHandler("pubsub", NamespacePubSubOwner, this.PepOwnerSetHandler, false);
            this.Server.Accounts.UnregisterIqSetHandler("pubsub", NamespacePubSubOwner, this.PepOwnerSetHandler, false);
 
            this.UnregisterMessageHandler("x", Networking.XMPP.XmppClient.NamespaceData, this.MessageFormHandler, true);
            this.Server.UnregisterMessageHandler("x", Networking.XMPP.XmppClient.NamespaceData, this.PepMessageFormHandler, false);
            this.Server.Accounts.UnregisterMessageHandler("x", Networking.XMPP.XmppClient.NamespaceData, this.PepMessageFormHandler, true);
 
            this.Server.Accounts.OnDiscoveryQueryNodeGet -= this.PepDiscoveryQueryGet;
            this.Server.Accounts.OnDiscoveryQueryNodeItemsGet -= this.PepDiscoveryQueryItemsGet;
 
            this.RemoveFeatures(this);
            this.RemoveFeatures(this.Server.Accounts);
 
            this.itemSerializer = null;
 
            this.Server.OnPresenceLocalRecipient -= this.Server_OnPresenceLocalRecipient;
 
            this.featuresByNodeVer?.Dispose();
            this.featuresByNodeVer = null;
 
            this.items?.Dispose();
            this.items = null;
 
            base.Dispose();
        }
 
        private void RemoveFeatures(Component Component)
        {
            Component.UnregisterFeature(NamespacePubSubAccessAuthorize);
            Component.UnregisterFeature(NamespacePubSubAccessOpen);
            Component.UnregisterFeature(NamespacePubSubAccessPresence);
            Component.UnregisterFeature(NamespacePubSubAccessRoster);
            Component.UnregisterFeature(NamespacePubSubAccessWhitelist);
            Component.UnregisterFeature(NamespacePubSubCollections);
            Component.UnregisterFeature(NamespacePubSubNodeConfiguration);
            Component.UnregisterFeature(NamespacePubSubCreateAndConfigure);
            Component.UnregisterFeature(NamespacePubSubCreateNodes);
            Component.UnregisterFeature(NamespacePubSubDeleteItems);
            Component.UnregisterFeature(NamespacePubSubDeleteNodes);
            Component.UnregisterFeature(NamespacePubSubItemIds);
            Component.UnregisterFeature(NamespacePubSubLastPublished);
            Component.UnregisterFeature(NamespacePubSubLeasedSubscription);
            Component.UnregisterFeature(NamespacePubSubManageSubscriptions);
            Component.UnregisterFeature(NamespacePubSubemberAffiliation);
            Component.UnregisterFeature(NamespacePubSubMetaData);
            Component.UnregisterFeature(NamespacePubSubModifyAffiliations);
            Component.UnregisterFeature(NamespacePubSubMultiCollecton);
            Component.UnregisterFeature(NamespacePubSubMultiItems);
            Component.UnregisterFeature(NamespacePubSubOutcastAffiliation);
            Component.UnregisterFeature(NamespacePubSubPersistentItems);
            Component.UnregisterFeature(NamespacePubSubPresenceSubscribe);
            Component.UnregisterFeature(NamespacePubSubPublish);
            Component.UnregisterFeature(NamespacePubSubPublishOnlyAffiliation);
            Component.UnregisterFeature(NamespacePubSubPublisheAffiliation);
            Component.UnregisterFeature(NamespacePubSubPurgeNodes);
            Component.UnregisterFeature(NamespacePubSubRetractItems);
            Component.UnregisterFeature(NamespacePubSubRetrieveAffiliations);
            Component.UnregisterFeature(NamespacePubSubRetrieveDefault);
            Component.UnregisterFeature(NamespacePubSubRetrieveDefaultSub);
            Component.UnregisterFeature(NamespacePubSubRetrieveItems);
            Component.UnregisterFeature(NamespacePubSubRetrieveSubscriptions);
            Component.UnregisterFeature(NamespacePubSubSubscribe);
            Component.UnregisterFeature(NamespacePubSubSubscriptionOptions);
            Component.UnregisterFeature(NamespacePubSubSubscriptionNotifications);
            Component.UnregisterFeature(RestrictedQuery.NamespaceResultSetManagement);
        }
 
        public override bool SupportsAccounts => false;
 
        public async Task<PubSubNode> GetNodeAsync(CaseInsensitiveString Service, CaseInsensitiveString NodeName,
            NodeAccessModel? AutoCreateAccess, XmppAddress From, CaseInsensitiveString Domain)
        {
            Nodes NodesOnService;
            PubSubNode Node;
            bool FirstRequestOnService = false;
 
            lock (this.nodesByServiceAndName)
            {
                if (!this.nodesByServiceAndName.TryGetValue(Service, out NodesOnService))
                {
                    FirstRequestOnService = true;
                    NodesOnService = new Nodes()
                    {
                        NodesByName = new Dictionary<string, PubSubNode>(),
                        NodesArray = new PubSubNode[0]
                    };
 
                    this.nodesByServiceAndName[Service] = NodesOnService;
                }
 
                if (NodesOnService.NodesByName.TryGetValue(NodeName, out Node))
                    return Node;
            }
 
            if (FirstRequestOnService && !string.IsNullOrEmpty(Service))
            {
                foreach (PubSubNode Node2 in await Database.Find<PubSubNode>(
                    new FilterFieldEqualTo("Service", Service)))
                {
                    lock (this.nodesByServiceAndName)
                    {
                        NodesOnService.NodesByName[NodeName] = Node2;
                    }
 
                    if (Node2.Name == NodeName)
                        Node = Node2;
                }
 
                lock (this.nodesByServiceAndName)
                {
                    NodesOnService.NodesArray = new PubSubNode[NodesOnService.NodesByName.Count];
                    NodesOnService.NodesByName.Values.CopyTo(NodesOnService.NodesArray, 0);
                }
            }
            else
            {
                Node = await Database.FindFirstDeleteRest<PubSubNode>(new FilterAnd(
                    new FilterFieldEqualTo("Service", Service),
                    new FilterFieldEqualTo("Name", NodeName)));
            }
 
            if (Node is null)
            {
                if (!AutoCreateAccess.HasValue)
                    return null;
 
                CaseInsensitiveString Creator = From.BareJid;
 
                Node = new PubSubNode()
                {
                    Service = Service,
                    Name = NodeName,
                    Domain = Domain,
                    Creator = Creator,
                    Created = DateTime.Now,
                    Owners = new CaseInsensitiveString[] { Creator },
                    IsRoot = true,
                    AccessModel = AutoCreateAccess.Value,
                    PublisherModel = PublisherModel.publishers,
                    SendLastPublishedItem = SendLastPublishedItem.on_sub_and_presence,
                    NotificationType = NotificationType.normal,
                    MaxItems = 10,
                    AutoSubscribe = true,
                    AutoDelete = true,
                    NodeType = NodeType.leaf
                };
 
                await Database.InsertLazy(Node);
            }
 
            lock (this.nodesByServiceAndName)
            {
                NodesOnService.NodesByName[NodeName] = Node;
 
                NodesOnService.NodesArray = new PubSubNode[NodesOnService.NodesByName.Count];
                NodesOnService.NodesByName.Values.CopyTo(NodesOnService.NodesArray, 0);
            }
 
            return Node;
        }
 
        public async Task<Subscription> GetSubscriptionAsync(CaseInsensitiveString Service, CaseInsensitiveString Node, CaseInsensitiveString Jid)
        {
            Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Subscription>> SubscriptionsByServiceAndNode;
            Dictionary<CaseInsensitiveString, Subscription> SubscriptionsByNode;
            Subscription Result;
 
            lock (this.subscriptionsByJidAndServiceAndNode)
            {
                if (!this.subscriptionsByJidAndServiceAndNode.TryGetValue(Jid, out SubscriptionsByServiceAndNode))
                {
                    SubscriptionsByServiceAndNode = new Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Subscription>>();
                    this.subscriptionsByJidAndServiceAndNode[Jid] = SubscriptionsByServiceAndNode;
                }
 
                if (SubscriptionsByServiceAndNode.TryGetValue(Service, out SubscriptionsByNode))
                {
                    if (SubscriptionsByNode.TryGetValue(Node, out Result))
                        return Result;
                    else
                        return null;
                }
            }
 
            SubscriptionsByNode = new Dictionary<CaseInsensitiveString, Subscription>();
 
            foreach (Subscription Subscription in await Database.Find<Subscription>(new FilterAnd(
                new FilterFieldEqualTo("Jid", Jid), new FilterFieldEqualTo("Service", Service))))
            {
                SubscriptionsByNode[Subscription.Node] = Subscription;
            }
 
            lock (this.subscriptionsByJidAndServiceAndNode)
            {
                SubscriptionsByServiceAndNode[Service] = SubscriptionsByNode;
 
                if (SubscriptionsByNode.TryGetValue(Node, out Result))
                    return Result;
                else
                    return null;
            }
        }
 
        public async Task<Subscription[]> GetSubscriptionsByJid(CaseInsensitiveString Service, CaseInsensitiveString Jid)
        {
            Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Subscription>> SubscriptionsByServiceAndNode;
            Dictionary<CaseInsensitiveString, Subscription> SubscriptionsByNode;
            Subscription[] Result;
 
            lock (this.subscriptionsByJidAndServiceAndNode)
            {
                if (!this.subscriptionsByJidAndServiceAndNode.TryGetValue(Jid, out SubscriptionsByServiceAndNode))
                {
                    SubscriptionsByServiceAndNode = new Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Subscription>>();
                    this.subscriptionsByJidAndServiceAndNode[Jid] = SubscriptionsByServiceAndNode;
                }
 
                if (SubscriptionsByServiceAndNode.TryGetValue(Service, out SubscriptionsByNode))
                {
                    Result = new Subscription[SubscriptionsByNode.Count];
                    SubscriptionsByNode.Values.CopyTo(Result, 0);
                    return Result;
                }
            }
 
            SubscriptionsByNode = new Dictionary<CaseInsensitiveString, Subscription>();
 
            foreach (Subscription Subscription in await Database.Find<Subscription>(new FilterAnd(
                new FilterFieldEqualTo("Jid", Jid), new FilterFieldEqualTo("Service", Service))))
            {
                SubscriptionsByNode[Subscription.Node] = Subscription;
            }
 
            Result = new Subscription[SubscriptionsByNode.Count];
            SubscriptionsByNode.Values.CopyTo(Result, 0);
 
            lock (this.subscriptionsByJidAndServiceAndNode)
            {
                SubscriptionsByServiceAndNode[Service] = SubscriptionsByNode;
            }
 
            return Result;
        }
 
        public async Task<Subscription[]> GetSubscriptionsOnNode(CaseInsensitiveString Service, CaseInsensitiveString Node)
        {
            Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Subscription>> SubscriptionsByNodeAndJid;
            Dictionary<CaseInsensitiveString, Subscription> SubscriptionsByJid;
            Subscription[] Result;
 
            lock (this.subscriptionsByServiceAndNodeAndJid)
            {
                if (!this.subscriptionsByServiceAndNodeAndJid.TryGetValue(Service, out SubscriptionsByNodeAndJid))
                {
                    SubscriptionsByNodeAndJid = new Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Subscription>>();
                    this.subscriptionsByServiceAndNodeAndJid[Service] = SubscriptionsByNodeAndJid;
                }
 
                if (SubscriptionsByNodeAndJid.TryGetValue(Node, out SubscriptionsByJid))
                {
                    Result = new Subscription[SubscriptionsByJid.Count];
                    SubscriptionsByJid.Values.CopyTo(Result, 0);
                    return Result;
                }
            }
 
            SubscriptionsByJid = new Dictionary<CaseInsensitiveString, Subscription>();
 
            foreach (Subscription Subscription in await Database.Find<Subscription>(new FilterAnd(
                new FilterFieldEqualTo("Service", Service), new FilterFieldEqualTo("Node", Node))))
            {
                SubscriptionsByJid[Subscription.Jid] = Subscription;
            }
 
            Result = new Subscription[SubscriptionsByJid.Count];
            SubscriptionsByJid.Values.CopyTo(Result, 0);
 
            lock (this.subscriptionsByServiceAndNodeAndJid)
            {
                SubscriptionsByNodeAndJid[Node] = SubscriptionsByJid;
            }
 
            return Result;
        }
 
        private Task PubSubGetHandler(object Sender, IqEventArgs e)
        {
            return this.PubSubGetHandler(string.Empty, e, pubSubFeatures);
        }
 
        private Task PepGetHandler(object Sender, IqEventArgs e)
        {
            return this.PubSubGetHandler((e.To.IsEmpty ? e.From : e.To).BareJid, e, pepFeatures);
        }
 
        private async Task PubSubGetHandler(CaseInsensitiveString Service, IqEventArgs e, DefaultFeatures _)
        {
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    switch (E.LocalName)
                    {
                        case "options":
                            string NodeName = XML.Attribute(E, "node");
                            if (string.IsNullOrEmpty(NodeName))
                            {
                                await e.IqError("modify", "<not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<nodeid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Node name required.", "en");
                                return;
                            }
 
                            CaseInsensitiveString Jid = XML.Attribute(E, "jid");
                            if (CaseInsensitiveString.IsNullOrEmpty(Jid))
                            {
                                await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<jid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "JID not specified.", "en");
                                return;
                            }
 
                            XmppAddress Address = new XmppAddress(Jid);
 
                            if (Address.BareJid != e.From.BareJid)
                            {
                                await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<invalid-jid xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Invalid JID", "en");
                            }
 
                            PubSubNode Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                            if (Node is null)
                            {
                                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                return;
                            }
 
                            Subscription Subscription = await this.GetSubscriptionAsync(Service, NodeName, Jid);
 
                            if (Subscription is null)
                            {
                                await e.IqError("modify", "<unexpected-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<not-subscribed xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "No such subscriber.", "en");
                                return;
                            }
 
                            string SubID = XML.Attribute(E, "subid");
                            /*if (string.IsNullOrEmpty(SubID))
                            {
                                await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<subid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Subscription ID required.", "en");
                                return;
                            }*/
 
                            if (!string.IsNullOrEmpty(SubID) && SubID != Subscription.ObjectId)
                            {
                                await e.IqError("modify", "<not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<invalid-subid xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Invalid subscription ID.", "en");
                                return;
                            }
 
                            DataForm Form = this.GetForm(Node, Subscription, e);
                            StringBuilder Xml = new StringBuilder();
 
                            Xml.Append("<pubsub xmlns='");
                            Xml.Append(NamespacePubSub);
                            Xml.Append("'><options node='");
                            Xml.Append(XML.Encode(NodeName));
                            Xml.Append("' jid='");
                            Xml.Append(XML.Encode(Jid));
                            Xml.Append("'>");
                            Form.SerializeForm(Xml);
                            Xml.Append("</options></pubsub>");
 
                            await e.IqResult(Xml.ToString(), e.To);
                            return;
 
                        case "default":
                            NodeName = XML.Attribute(E, "node");
                            if (!string.IsNullOrEmpty(NodeName))
                            {
                                Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                                if (Node is null)
                                {
                                    await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                    return;
                                }
                            }
                            else
                                Node = null;
 
                            Subscription = new Subscription();
                            Form = this.GetForm(Node, Subscription, e);
                            Xml = new StringBuilder();
 
                            Xml.Append("<pubsub xmlns='");
                            Xml.Append(NamespacePubSub);
                            Xml.Append("'><default");
 
                            if (!string.IsNullOrEmpty(NodeName))
                            {
                                Xml.Append(" node='");
                                Xml.Append(XML.Encode(NodeName));
                                Xml.Append('\'');
                            }
 
                            Xml.Append('>');
                            Form.SerializeForm(Xml);
                            Xml.Append("</default></pubsub>");
 
                            await e.IqResult(Xml.ToString(), e.To);
                            return;
 
                        case "items":
                            NodeName = XML.Attribute(E, "node");
                            if (string.IsNullOrEmpty(NodeName))
                            {
                                await e.IqError("modify", "<not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<nodeid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Node name required.", "en");
                                return;
                            }
 
                            Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                            if (Node is null)
                            {
                                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                return;
                            }
 
                            if (!(XmppServerModule.PersistenceLayer is null) &&
                                await XmppServerModule.PersistenceLayer.IsBlocked(e.From.BareJid, Node.Creator))
                            {
                                await e.IqErrorForbidden(e.To, "Account has been blocked.", "en");
                                return;
                                // TODO: When blocking an account, remove subscriptions of nodes of owner performing the block.
                            }
 
                            if (!await Node.CanRetrieveItems(e.From.BareJid, Node.AccessModel != NodeAccessModel.whitelist))
                            {
                                await e.IqErrorForbidden(e.To, "Not authoried to retrieve items.", "en");
                                return;
                            }
 
                            switch (Node.AccessModel)
                            {
                                case NodeAccessModel.open:
                                    break;
 
                                case NodeAccessModel.presence:
                                    XmppAddress Owner = new XmppAddress(Node.Creator);
                                    IRosterItem RosterItem;
 
                                    if (this.Server.IsServerDomain(Owner.Domain, true))
                                        RosterItem = await XmppServerModule.GetRosterItemAsync(Owner.Account, e.From.BareJid);
                                    else
                                        RosterItem = null;
 
                                    if (RosterItem is null || (RosterItem.Subscription != SubscriptionStatus.both &&
                                        RosterItem.Subscription != SubscriptionStatus.from))
                                    {
                                        await e.IqError("auth", "<not-authorized xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                            "<presence-subscription-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To,
                                            "Presence subscription required to get item.", "en");
                                        return;
                                    }
                                    break;
 
                                case NodeAccessModel.authorize:
                                case NodeAccessModel.roster:
                                case NodeAccessModel.whitelist:
                                default:
                                    Subscription = await this.GetSubscriptionAsync(Service, NodeName, e.From.Address);
                                    if (Subscription is null)
                                        Subscription = await this.GetSubscriptionAsync(Service, NodeName, e.From.BareJid);
 
                                    if (Subscription is null || Subscription.Status == NodeSubscriptionStatus.none)
                                    {
                                        await e.IqError("auth", "<not-authorized xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                            "<not-subscribed xmlns='http://jabber.org/protocol/pubsub#errors'/>",
                                            e.To, "Not subscribed.", "en");
                                        return;
                                    }
                                    else if (Subscription.Status == NodeSubscriptionStatus.pending)
                                    {
                                        await e.IqError("auth", "<not-authorized xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                            "<pending-subscription xmlns='http://jabber.org/protocol/pubsub#errors'/>",
                                            e.To, "Pending subscription.", "en");
                                        return;
                                    }
                                    else if (Subscription.Status == NodeSubscriptionStatus.unconfigured)
                                    {
                                        await e.IqError("auth", "<not-authorized xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                            "<configuration-required xmlns='http://jabber.org/protocol/pubsub#errors'/>",
                                            e.To, "Configuration required.", "en");
                                        return;
                                    }
                                    break;
                            }
 
                            RestrictedQuery RestrictedQuery = RestrictedQuery.IsRestricted(E.NextSibling);
                            List<PubSubItem> RequestedItems = null;
                            IEnumerable<PubSubItem> Items;
                            Filter Filter;
                            bool NewestFirst = !(RestrictedQuery is null) && RestrictedQuery.Max.HasValue;
                            int Offset = 0;
                            int Max;
                            bool OneExtra = RestrictedQuery is null;
                            bool Paginated = !(RestrictedQuery is null);
                            bool ReverseOrder = false;
 
                            if (Node.DeliverPayloads)
                                Max = 10;
                            else
                                Max = 100;
 
                            if (E.HasAttribute("max_items"))
                            {
                                NewestFirst = true;
                                OneExtra = false;
                                Paginated = true;
                                ReverseOrder = true;
 
                                int i = XML.Attribute(E, "max_items", Max);
                                if (i < Max)
                                    Max = i;
                            }
 
                            if (Node.PersistItems)
                            {
                                foreach (XmlNode N2 in E.ChildNodes)
                                {
                                    if (N2 is XmlElement E2 && E2.LocalName == "item")
                                    {
                                        if (RequestedItems is null)
                                            RequestedItems = new List<PubSubItem>();
 
                                        try
                                        {
                                            PubSubItem Item = await this.LoadItem(Service, NodeName, XML.Attribute(E2, "id"));
                                            if (!(Item is null) && Item.Node == NodeName)
                                                RequestedItems.Add(Item);
                                        }
                                        catch (Exception)
                                        {
                                            // Erroneous node references should just be ignored (§ 6.5.9.12)
                                        }
                                    }
                                }
 
                                if (!(RequestedItems is null))
                                    Items = RequestedItems.ToArray();
                                else
                                {
                                    List<Filter> Filters = new List<Filter>()
                                    {
                                        new FilterFieldEqualTo("Service", Service),
                                        new FilterFieldEqualTo("Node", NodeName)
                                    };
 
                                    if (!(RestrictedQuery is null))
                                    {
                                        if (RestrictedQuery.Max.HasValue && RestrictedQuery.Max.Value < Max)
                                            Max = RestrictedQuery.Max.Value;
 
                                        if (RestrictedQuery.Index.HasValue && RestrictedQuery.Index.Value >= 0)
                                            Offset = RestrictedQuery.Index.Value;
 
                                        if (!(RestrictedQuery.Before is null))
                                        {
                                            NewestFirst = false;
                                            ReverseOrder = true;
 
                                            if (!string.IsNullOrEmpty(RestrictedQuery.Before))
                                            {
                                                PubSubItem Item = await this.LoadItem(Service, NodeName, RestrictedQuery.Before);
                                                if (Item is null)
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Before item not found.", "en");
                                                    return;
                                                }
 
                                                if (Item.Node != NodeName)
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Before item identity points to item belonging to another node.", "en");
                                                    return;
                                                }
 
                                                Filters.Add(new FilterFieldGreaterThan("Created", Item.Created));
                                            }
                                        }
 
                                        if (!string.IsNullOrEmpty(RestrictedQuery.After))
                                        {
                                            try
                                            {
                                                PubSubItem Item = await this.LoadItem(Service, NodeName, RestrictedQuery.After);
                                                if (Item is null)
                                                {
                                                    await e.IqErrorBadRequest(e.To, "After item not found.", "en");
                                                    return;
                                                }
 
                                                if (Item.Node != NodeName)
                                                {
                                                    await e.IqErrorBadRequest(e.To, "After item identity points to item belonging to another node.", "en");
                                                    return;
                                                }
 
                                                NewestFirst = true;
                                                Filters.Add(new FilterFieldLesserThan("Created", Item.Created));
                                            }
                                            catch (Exception)
                                            {
                                                await e.IqErrorBadRequest(e.To, "After item not found.", "en");
                                                return;
                                            }
                                        }
                                    }
 
                                    Filter = new FilterAnd(Filters.ToArray());
 
                                    if (NewestFirst)
                                        Items = await Database.Find<PubSubItem>(Offset, OneExtra ? Max + 1 : Max, Filter, "-Service", "-Node", "-Created");
                                    else
                                        Items = await Database.Find<PubSubItem>(Offset, OneExtra ? Max + 1 : Max, Filter, "Service", "Node", "Created");
 
                                    if (ReverseOrder)
                                    {
                                        if (Items is PubSubItem[] ItemArray)
                                            Array.Reverse(ItemArray);
                                        else
                                        {
                                            List<PubSubItem> ItemList = new List<PubSubItem>();
                                            ItemList.AddRange(Items);
                                            ItemList.Reverse();
                                            Items = ItemList;
                                        }
                                    }
                                }
                            }
                            else if (!(RestrictedQuery is null))
                            {
                                await e.IqError("cancel", "<feature-not-implemented xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<unsupported xmlns='http://jabber.org/protocol/pubsub#errors' feature='persistent-items'/>",
                                    e.To, "Node does not support persisted items and pagination.", "en");
                                return;
                            }
                            else if (Node.NodeType == NodeType.collection || Node.TransientNode)
                            {
                                await e.IqError("cancel", "<feature-not-implemented xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<unsupported xmlns='http://jabber.org/protocol/pubsub#errors' feature='retrieve-items'/>",
                                    e.To, "Collection and transient nodes do not support item retrieval.", "en");
                                return;
                            }
                            else if (!(Node.LastPublished is null))
                                Items = new PubSubItem[] { Node.LastPublished };
                            else
                                Items = new PubSubItem[0];
 
                            Xml = new StringBuilder();
 
                            Xml.Append("<pubsub xmlns='");
                            Xml.Append(NamespacePubSub);
                            Xml.Append("'><items node='");
                            Xml.Append(XML.Encode(NodeName));
                            Xml.Append("'>");
 
                            string First = null;
                            string Last = null;
                            int Left = Max;
 
                            foreach (PubSubItem Item in Items)
                            {
                                if (Left-- <= 0)
                                {
                                    Paginated = true;
                                    break;
                                }
 
                                if (First is null)
                                    First = Item.ItemIdOrObjectId;
 
                                Last = Item.ItemIdOrObjectId;
 
                                Xml.Append("<item id='");
                                Xml.Append(XML.Encode(Item.ItemIdOrObjectId));
 
                                if (Node.DeliverPayloads || !(RequestedItems is null))
                                {
                                    Xml.Append("' publisher='");
                                    Xml.Append(XML.Encode(Item.Publisher));
                                    Xml.Append("'>");
 
                                    if (XML.IsValidXml(Item.Payload, true, true, true, true, false, false))
                                        Xml.Append(Item.Payload);
 
                                    Xml.Append("</item>");
                                }
                                else
                                    Xml.Append("'/>");
                            }
 
                            Xml.Append("</items>");
 
                            if (Paginated)
                                ResultPage.Append(Xml, First, null, Last, null);
 
                            Xml.Append("</pubsub>");
 
                            await e.IqResult(Xml.ToString(), e.To);
                            return;
 
                        case "subscriptions":
                            Xml = new StringBuilder();
 
                            Xml.Append("<pubsub xmlns='");
                            Xml.Append(NamespacePubSub);
 
                            if (E.HasAttribute("node"))
                            {
                                NodeName = E.GetAttribute("node");
 
                                Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                                if (Node is null)
                                {
                                    await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                    return;
                                }
 
                                Xml.Append("'><subscriptions node='");
                                Xml.Append(XML.Encode(NodeName));
                                Xml.Append("'>");
 
                                Serialize(Subset(await this.GetSubscriptionsByJid(Service, e.From.Address), NodeName), Xml);
                                if (e.From.IsFullJID)
                                    Serialize(Subset(await this.GetSubscriptionsByJid(Service, e.From.BareJid), NodeName), Xml);
                            }
                            else
                            {
                                Xml.Append("'><subscriptions>");
 
                                Serialize(await this.GetSubscriptionsByJid(Service, e.From.Address), Xml);
                                if (e.From.IsFullJID)
                                    Serialize(await this.GetSubscriptionsByJid(Service, e.From.BareJid), Xml);
                            }
 
                            Xml.Append("</subscriptions></pubsub>");
 
                            await e.IqResult(Xml.ToString(), e.To);
                            return;
 
                        case "affiliations":
                            Xml = new StringBuilder();
 
                            Xml.Append("<pubsub xmlns='");
                            Xml.Append(NamespacePubSub);
 
                            if (E.HasAttribute("node"))
                            {
                                NodeName = E.GetAttribute("node");
 
                                Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                                if (Node is null)
                                {
                                    await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                    return;
                                }
 
                                Xml.Append("'><affiliations node='");
                                Xml.Append(XML.Encode(NodeName));
 
                                if (Node.TryGetAffiliation(e.From.BareJid, out AffiliationStatus Affiliation))
                                {
                                    Xml.Append("'>");
                                    Xml.Append("<affiliation node='");
                                    Xml.Append(XML.Encode(NodeName));
                                    Xml.Append("' affiliation='");
                                    Xml.Append(ToString(Affiliation));
                                    Xml.Append("'/></affiliations>");
                                }
                                else
                                    Xml.Append("'/>");
                            }
                            else
                            {
                                Xml.Append("'><affiliations>");
 
                                // TODO: Search on affiliations
 
                                foreach (PubSubNode Node2 in await Database.Find<PubSubNode>(new FilterFieldEqualTo("Service", Service)))
                                {
                                    if (Node2.TryGetAffiliation(e.From.BareJid, out AffiliationStatus Affiliation))
                                    {
                                        Xml.Append("<affiliation node='");
                                        Xml.Append(XML.Encode(Node2.Name));
                                        Xml.Append("' affiliation='");
                                        Xml.Append(ToString(Affiliation));
                                        Xml.Append("'/>");
                                    }
                                }
 
                                Xml.Append("</affiliations>");
                            }
 
                            Xml.Append("</pubsub>");
 
                            await e.IqResult(Xml.ToString(), e.To);
                            return;
 
                        default:
                            await e.IqErrorBadRequest(e.To, "Element not supported.", "en");
                            return;
                    }
                }
            }
 
            await e.IqResult(string.Empty, e.To);
        }
 
        private static IEnumerable<Subscription> Subset(Subscription[] Subscriptions, string NodeName)
        {
            LinkedList<Subscription> Result = new LinkedList<Subscription>();
 
            foreach (Subscription Subscription in Subscriptions)
            {
                if (Subscription.Node == NodeName)
                    Result.AddLast(Subscription);
            }
 
            return Result;
        }
 
        private static void Serialize(IEnumerable<Subscription> Subscriptions, StringBuilder Xml)
        {
            foreach (Subscription Subscription in Subscriptions)
            {
                Xml.Append("<subscription node='");
                Xml.Append(XML.Encode(Subscription.Node));
                Xml.Append("' jid ='");
                Xml.Append(XML.Encode(Subscription.Jid));
                Xml.Append("' subscription='");
                Xml.Append(Subscription.Status.ToString());
                Xml.Append("' subid='");
                Xml.Append(Subscription.ObjectId);
                Xml.Append("'/>");
            }
        }
 
        private DataForm GetForm(PubSubNode Node, Subscription Subscription, IqEventArgs e)
        {
            List<Field> Fields = new List<Field>()
            {
                new HiddenField("FORM_TYPE", FormTypeSubscribeOptions),
                new BooleanField(null, "pubsub#deliver", "Enable notifications.", false, new string[] { Subscription.Deliver ? "1" : "0" }, null,
                    "Whether an entity wants to receive or disable notifications.", BooleanDataType.Instance, new BasicValidation(), string.Empty, false, false, false),
                new BooleanField(null, "pubsub#include_body", "Include message body.", false, new string[] { Subscription.IncludeBody ? "1" : "0" }, null,
                    "Whether an entity wants to receive an XMPP message body in addition to the payload format.", BooleanDataType.Instance, new BasicValidation(), string.Empty, false, false, false),
                new BooleanField(null, "pubsub#digest", "Digest.", false, new string[] { Subscription.Digest ? "1" : "0" }, null,
                    "Whether an entity wants to receive digests (aggregations) of notifications or all notifications individually.", BooleanDataType.Instance, new BasicValidation(), string.Empty, false, false, false),
                new TextSingleField(null, "pubsub#digest_frequency", "Digest interval (ms):", false, new string[] { Subscription.DigestFrequencyMilliseconds.ToString() }, null,
                    "The minimum number of milliseconds between sending any two notification digests.", IntegerDataType.Instance, new RangeValidation("0", int.MaxValue.ToString()), string.Empty, false, false, false),
                new TextSingleField(null, "pubsub#expire", "Expiry time:", false, new string[] { Subscription.Expires == DateTime.MaxValue ? string.Empty : XML.Encode(Subscription.Expires) }, null,
                    "The DateTime at which a leased subscription will end or has ended.", DateTimeDataType.Instance, new BasicValidation(), string.Empty, false, false, false)
            };
 
            if (!(Node is null) && Node.NodeType == NodeType.collection)
            {
                Fields.Add(new ListSingleField(null, "pubsub#subscription_type", "Subcription Type:", false, new string[] { Subscription.Type.ToString() },
                    new KeyValuePair<string, string>[]
                    {
                        new KeyValuePair<string, string>("Receive notification of new items only", "items"),
                        new KeyValuePair<string, string>("Receive notification of new nodes only", "nodes")
                    }, "Type of subscription.", null, null, string.Empty, false, false, false));
 
                Fields.Add(new ListSingleField(null, "pubsub#subscription_depth", "Subcription Depth:", false, new string[] { Subscription.Depth == SubscriptonDepth.one ? "1" : Subscription.Depth.ToString() },
                    new KeyValuePair<string, string>[]
                    {
                        new KeyValuePair<string, string>("Receive notification from direct child nodes only", "1"),
                        new KeyValuePair<string, string>("Receive notification from all descendent nodes", "all")
                    }, "Type of subscription.", null, null, string.Empty, false, false, false));
            }
 
            return new DataForm(null, FormType.Form, e.To.Address, e.From.Address, Fields.ToArray());
        }
 
        private Task PubSubSetHandler(object Sender, IqEventArgs e)
        {
            return this.PubSubSetHandler(string.Empty, e, pubSubFeatures);
        }
 
        private Task PepSetHandler(object Sender, IqEventArgs e)
        {
            return this.PubSubSetHandler((e.To.IsEmpty ? e.From : e.To).BareJid, e, pepFeatures);
        }
 
        private async Task PubSubSetHandler(CaseInsensitiveString Service, IqEventArgs e, DefaultFeatures Features)
        {
            XmppAddress FromBareJid = string.IsNullOrEmpty(Service) ? e.To : e.From.ToBareJID();
            Dictionary<CaseInsensitiveString, Subscription> List;
            Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Subscription>> List2;
            Subscription Subscription = null;
            PubSubNode Node = null;
            StringBuilder Xml;
            string NodeName = null;
            CaseInsensitiveString Jid = null;
            bool InsertNode = false;
            bool NodeUpdated = false;
            bool InsertSubscription = false;
            bool SubscriptionUpdated = false;
            bool SubscriptionDeleted = false;
            bool IncludeOptions = false;
            bool NotificationToOwner = false;
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    switch (E.LocalName)
                    {
                        case "create":
                            if (!this.Server.IsServerDomain(e.From.Domain, true))
                            {
                                await e.IqErrorForbidden(e.To, "Only accounts registered on the broker are allowed to create nodes.", "en");
                                return;
                            }
                            // Persistence layer
                            IAccount Account = await XmppServerModule.GetAccountAsync(e.From.Account);
                            if (Account is null)
                            {
                                await e.IqError("auth", "<registration-required xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>", e.To,
                                    "Only accounts registered on the broker are allowed to create nodes.", "en");
                                return;
                            }
 
                            if (!await RuntimeSettings.GetAsync(e.From.BareJid + ".PubSub.CanCreate", true))
                            {
                                await e.IqErrorForbidden(e.To, "Account not permitted to create nodes.", "en");
                                return;
                            }
 
                            NodeName = XML.Attribute(E, "node");
                            if (string.IsNullOrEmpty(NodeName))
                            {
                                await e.IqError("modify", "<not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<nodeid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Node name required.", "en");
                                return;
                            }
 
                            Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                            if (!(Node is null))
                            {
                                await e.IqErrorConflict(e.To, "Node already exists.", "en");
                                return;
                            }
 
                            if (string.IsNullOrEmpty(Service))
                            {
                                if (NodeName != e.From.Account && !(await XmppServerModule.GetAccountAsync(NodeName) is null))
                                {
                                    await e.IqErrorConflict(e.To, "Node name conflict: Conflicts with existing account.", "en");
                                    return;
                                }
 
                                if (!(IoTGateway.Gateway.RootFolder is null))
                                {
                                    try
                                    {
                                        string s = Path.Combine(IoTGateway.Gateway.RootFolder, NodeName);
 
                                        if (File.Exists(s))
                                        {
                                            await e.IqErrorConflict(e.To, "Node name conflict: Conflicts with existing web file.", "en");
                                            return;
                                        }
                                        else if (Directory.Exists(s))
                                        {
                                            await e.IqErrorConflict(e.To, "Node name conflict: Conflicts with existing web folder.", "en");
                                            return;
                                        }
                                    }
                                    catch (Exception)
                                    {
                                        // Ignore.
                                    }
                                }
                            }
 
                            Node = new PubSubNode()
                            {
                                Service = Service,
                                Name = NodeName,
                                Domain = e.To.Address,
                                Creator = e.From.BareJid,
                                Created = DateTime.Now,
                                Owners = new CaseInsensitiveString[] { e.From.BareJid },
                                IsRoot = true
                            };
 
                            InsertNode = true;
                            break;
 
                        case "configure":
                            if (await this.ConfigureNode(E, Node, e))
                                NodeUpdated = true;
                            else
                                return;
                            break;
 
                        case "subscribe":
                            NodeName = XML.Attribute(E, "node");
                            if (string.IsNullOrEmpty(NodeName))
                            {
                                await e.IqError("modify", "<not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<nodeid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Node name required.", "en");
                                return;
                            }
 
                            Jid = XML.Attribute(E, "jid");
                            XmppAddress Address = new XmppAddress(Jid);
 
                            if (Address.BareJid != e.From.BareJid)
                            {
                                await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<invalid-jid xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Invalid JID", "en");
                            }
 
                            Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                            if (Node is null)
                            {
                                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                return;
                            }
 
                            if (!Node.AllowSubscriptions)
                            {
                                await e.IqError("cancel", "<feature-not-implemented xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<unsupported xmlns='http://jabber.org/protocol/pubsub#errors' feature='subscribe'/>", e.To, "Node does not support subscriptions.", "en");
                                return;
                            }
 
                            if (!(XmppServerModule.PersistenceLayer is null) &&
                                await XmppServerModule.PersistenceLayer.IsBlocked(e.From.BareJid, Node.Creator))
                            {
                                await e.IqErrorForbidden(e.To, "Account has been blocked.", "en");
                                return;
                                // TODO: When blocking an account, remove subscriptions of nodes of owner performing the block.
                            }
 
                            if (!await Node.CanSubscribe(e.From.BareJid))
                            {
                                await e.IqErrorForbidden(e.To, "Not authorized to subscribe to node.", "en");
                                return;
                            }
 
                            switch (Node.AccessModel)
                            {
                                case NodeAccessModel.open:
                                    break;
 
                                case NodeAccessModel.whitelist:
                                    if (!await Node.IsOnWhiteList(e.From.BareJid))
                                    {
                                        await e.IqError("cancel", "<not-allowed xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                            "<closed-node xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Not on whitelist.", "en");
                                        return;
                                    }
                                    break;
 
                                case NodeAccessModel.roster:
                                    bool Found = false;
                                    IRosterItem RosterItem;
                                    XmppAddress Owner = new XmppAddress(Node.Creator);
 
                                    if (this.Server.IsServerDomain(Owner.Domain, true))
                                        RosterItem = await XmppServerModule.GetRosterItemAsync(Owner.Account, e.From.BareJid);
                                    else
                                        RosterItem = null;
 
                                    if (!(Node.RosterGroupsAllowed is null) && !(RosterItem is null) && !(RosterItem.Groups is null))
                                    {
                                        foreach (string s in Node.RosterGroupsAllowed)
                                        {
                                            foreach (string s2 in RosterItem.Groups)
                                            {
                                                if (string.Compare(s, s2, true) == 0)
                                                {
                                                    Found = true;
                                                    break;
                                                }
                                            }
 
                                            if (Found)
                                                break;
                                        }
                                    }
 
                                    if (!Found)
                                    {
                                        await e.IqError("auth", "<not-authorized xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                            "<not-in-roster-group xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To,
                                            "Not in corresponding roster group.", "en");
                                        return;
                                    }
                                    break;
 
                                case NodeAccessModel.presence:
                                    Owner = new XmppAddress(Node.Creator);
 
                                    if (this.Server.IsServerDomain(Owner.Domain, true))
                                        RosterItem = await XmppServerModule.GetRosterItemAsync(Owner.Account, e.From.BareJid);
                                    else
                                        RosterItem = null;
 
                                    if (RosterItem is null || (RosterItem.Subscription != SubscriptionStatus.both &&
                                        RosterItem.Subscription != SubscriptionStatus.from))
                                    {
                                        await e.IqError("auth", "<not-authorized xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                            "<presence-subscription-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To,
                                            "Presence subscription required to subscribe to node.", "en");
                                        return;
                                    }
                                    break;
 
                                case NodeAccessModel.authorize:
                                    Subscription = await this.GetSubscriptionAsync(Service, NodeName, Jid);
 
                                    if (Subscription is null)
                                    {
                                        Subscription = new Subscription()
                                        {
                                            Service = Service,
                                            Node = NodeName,
                                            Jid = Jid,
                                            IsFullJid = Address.IsFullJID,
                                            Status = NodeSubscriptionStatus.pending
                                        };
 
                                        InsertSubscription = true;
                                    }
                                    else
                                    {
                                        if (Subscription.Status == NodeSubscriptionStatus.none)
                                        {
                                            Subscription.Status = NodeSubscriptionStatus.pending;
                                            SubscriptionUpdated = true;
                                        }
                                    }
 
                                    NotificationToOwner = true;
                                    break;
                            }
 
                            if (Subscription is null)
                            {
                                Subscription = await this.GetSubscriptionAsync(Service, NodeName, Jid);
 
                                if (Subscription is null)
                                {
                                    Subscription = new Subscription()
                                    {
                                        Service = Service,
                                        Node = NodeName,
                                        Jid = Jid,
                                        IsFullJid = Address.IsFullJID,
                                        Status = NodeSubscriptionStatus.subscribed
                                    };
 
                                    InsertSubscription = true;
                                }
                                else
                                {
                                    if (Subscription.Status != NodeSubscriptionStatus.subscribed)
                                    {
                                        Subscription.Status = NodeSubscriptionStatus.subscribed;
                                        SubscriptionUpdated = true;
                                    }
                                }
                            }
                            break;
 
                        case "unsubscribe":
                            NodeName = XML.Attribute(E, "node");
                            if (string.IsNullOrEmpty(NodeName))
                            {
                                await e.IqError("modify", "<not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<nodeid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Node name required.", "en");
                                return;
                            }
 
                            Jid = XML.Attribute(E, "jid");
                            Address = new XmppAddress(Jid);
 
                            if (Address.BareJid != e.From.BareJid)
                            {
                                await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<invalid-jid xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Invalid JID", "en");
                            }
 
                            Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                            if (Node is null)
                            {
                                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                return;
                            }
 
                            string SubId = XML.Attribute(E, "subid");
 
                            Subscription = await this.GetSubscriptionAsync(Service, NodeName, Jid);
                            if (Subscription is null)
                            {
                                await e.IqError("cancel", "<unexpected-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<not-subscribed xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Not subscribed.", "en");
                                return;
                            }
 
                            if (!string.IsNullOrEmpty(SubId) && SubId != Subscription.ObjectId)
                            {
                                await e.IqError("modify", "<not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<invalid-subid xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Invalid subscription ID.", "en");
                                return;
                            }
 
                            lock (this.subscriptionsByJidAndServiceAndNode)
                            {
                                if (this.subscriptionsByJidAndServiceAndNode.TryGetValue(Jid, out List2) &&
                                    List2.TryGetValue(Service, out List))
                                {
                                    List.Remove(NodeName);
                                }
                            }
 
                            lock (this.subscriptionsByServiceAndNodeAndJid)
                            {
                                if (this.subscriptionsByServiceAndNodeAndJid.TryGetValue(Service, out List2) &&
                                    List2.TryGetValue(NodeName, out List))
                                {
                                    List.Remove(Jid);
                                }
                            }
 
                            Subscription.Status = NodeSubscriptionStatus.none;
                            SubscriptionDeleted = true;
                            break;
 
                        case "options":
                            if (Subscription is null)
                            {
                                NodeName = XML.Attribute(E, "node");
                                if (string.IsNullOrEmpty(NodeName))
                                {
                                    await e.IqError("modify", "<not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                        "<nodeid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Node name required.", "en");
                                    return;
                                }
 
                                Jid = XML.Attribute(E, "jid");
                                Address = new XmppAddress(Jid);
 
                                if (Address.BareJid != e.From.BareJid)
                                {
                                    await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                        "<invalid-jid xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Invalid JID", "en");
                                }
 
                                Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                                if (Node is null)
                                {
                                    await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                    return;
                                }
 
                                SubId = XML.Attribute(E, "subid");
 
                                Subscription = await this.GetSubscriptionAsync(Service, NodeName, Jid);
                                if (Subscription is null)
                                {
                                    await e.IqError("cancel", "<unexpected-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                        "<not-subscribed xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Not subscribed.", "en");
                                    return;
                                }
 
                                if (!string.IsNullOrEmpty(SubId) && SubId != Subscription.ObjectId)
                                {
                                    await e.IqError("modify", "<not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                        "<invalid-subid xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Invalid subscription ID.", "en");
                                    return;
                                }
                            }
 
                            if (!await this.ConfigureSubscription(E, Subscription, e))
                                return;
                            else
                                SubscriptionUpdated = true;
 
                            IncludeOptions = true;
                            break;
 
                        case "publish":
                            NodeName = XML.Attribute(E, "node");
                            if (string.IsNullOrEmpty(NodeName))
                            {
                                await e.IqError("modify", "<not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<nodeid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Node name required.", "en");
                                return;
                            }
 
                            Node = await this.GetNodeAsync(Service, NodeName,
                                Features.AutoCreate ? NodeAccessModel.presence : (NodeAccessModel?)null,
                                e.From, e.To.Address);
 
                            if (Node is null)
                            {
                                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                return;
                            }
 
                            if (!await Node.CanPublishItems(e.From.BareJid))
                            {
                                await e.IqErrorForbidden(e.To, "Access denied. Not authorized to publish item on node.", "en");
                                return;
                            }
 
                            if (Node.NodeType == NodeType.collection)
                            {
                                await e.IqError("cancel", "<feature-not-implemented xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<unsupported xmlns='http://jabber.org/protocol/pubsub#errors' feature='publish'/>", e.To,
                                    "Publishing items on collection nodes is not supported.", "en");
                                return;
                            }
 
                            foreach (XmlNode N2 in E.ChildNodes)
                            {
                                if (N2 is XmlElement E2 && E2.LocalName == "item" && E2.NamespaceURI == E.NamespaceURI)
                                {
                                    if (Node.TransientNode)
                                    {
                                        await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                            "<item-forbidden xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Transient nodes do not accept items.", "en");
                                        return;
                                    }
 
                                    CaseInsensitiveString ItemId = XML.Attribute(E2, "id");
                                    PubSubItem Item = null;
 
                                    if (!CaseInsensitiveString.IsNullOrEmpty(ItemId) && Node.PersistItems)
                                    {
                                        Item = await this.LoadItem(Service, NodeName, ItemId);
 
                                        if (!(Item is null) && Item.Node != NodeName)
                                        {
                                            await e.IqErrorBadRequest(e.To, "Item identity points to item belonging to another node.", "en");
                                            return;
                                        }
                                    }
 
                                    string Content;
 
                                    if (Node.PublishOnWeb && !string.IsNullOrEmpty(ItemId))
                                    {
                                        foreach (XmlNode N3 in E2.ChildNodes)
                                        {
                                            if (N3 is XmlElement E3 &&
                                                E3.LocalName == "markdownContent" &&
                                                E3.NamespaceURI == WebServices.PubSubContent.Content.LilsisNamespace)
                                            {
                                                StringBuilder Link = new StringBuilder();
                                                HttpServer WebServer = IoTGateway.Gateway.HttpServer;
                                                int[] Ports = WebServer.OpenHttpsPorts;
 
                                                if (Ports.Length > 0)
                                                {
                                                    Link.Append("https://");
                                                    Link.Append(IoTGateway.Gateway.Domain);
 
                                                    if (Array.IndexOf(Ports, HttpServer.DefaultHttpsPort) < 0)
                                                    {
                                                        Link.Append(':');
                                                        Link.Append(Ports[0].ToString());
                                                    }
                                                }
                                                else
                                                {
                                                    Ports = WebServer.OpenHttpPorts;
 
                                                    Link.Append("http://");
                                                    Link.Append(IoTGateway.Gateway.Domain);
 
                                                    if (Ports.Length > 0 && Array.IndexOf(Ports, HttpServer.DefaultHttpPort) < 0)
                                                    {
                                                        Link.Append(':');
                                                        Link.Append(Ports[0].ToString());
                                                    }
                                                }
 
                                                Link.Append('/');
                                                Link.Append(System.Web.HttpUtility.UrlEncode(Node.Name));
 
                                                if (!ItemId.StartsWith("/"))
                                                    Link.Append('/');
 
                                                Link.Append(ItemId);
 
                                                E3.SetAttribute("link", Link.ToString());
                                            }
                                        }
                                    }
 
                                    Content = E2.InnerXml.Trim();
 
                                    byte[] ContentBin = Encoding.UTF8.GetBytes(Content);
                                    DateTime Now = DateTime.Now;
 
                                    if (Node.DeliverPayloads && string.IsNullOrEmpty(Content))
                                    {
                                        await e.IqError("modify", "<not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                            "<payload-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To,
                                            "Missing payload.", "en");
                                        return;
                                    }
 
                                    if (ContentBin.Length > Node.MaxPayloadSize)
                                    {
                                        await e.IqError("modify", "<not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                            "<payload-too-big xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To,
                                            "Payload too big.", "en");
                                        return;
                                    }
 
                                    if (!string.IsNullOrEmpty(Node.PayloadType))
                                    {
                                        if (InternetContent.Decodes(Node.PayloadType, out Grade Grade, out IContentDecoder Decoder))
                                        {
                                            try
                                            {
                                                await Decoder.DecodeAsync(Node.PayloadType, ContentBin, Encoding.UTF8,
                                                    new KeyValuePair<string, string>[0], null);
                                            }
                                            catch (Exception)
                                            {
                                                await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                                    "<invalid-payload xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To,
                                                    "Payload does not conform to Internet Content Type " + Node.PayloadType, "en");
                                                return;
                                            }
                                        }
                                        else
                                        {
                                            foreach (XmlNode N3 in E2.ChildNodes)
                                            {
                                                if (N3 is XmlElement E3 && E3.NamespaceURI != Node.PayloadType)
                                                {
                                                    await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                                        "<invalid-payload xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To,
                                                        "Payload does not conform to namespace " + Node.PayloadType, "en");
                                                    return;
                                                }
                                            }
                                        }
                                    }
 
                                    if (!(Item is null))
                                    {
                                        Node.BytesPublished -= await this.GetItemSize(Item);
 
                                        Item.Publisher = e.From.BareJid;
                                        Item.Payload = Content;
                                        Item.Updated = Now;
 
                                        await Database.UpdateLazy(Item);
                                    }
                                    else
                                    {
                                        if (Node.NrItems >= Node.MaxItems)
                                        {
                                            if (Node.AutoDelete)
                                            {
                                                bool Deleted = false;
 
                                                foreach (PubSubItem Item2 in await Database.FindDelete<PubSubItem>(0, 1, new FilterAnd(
                                                    new FilterFieldEqualTo("Service", Service),
                                                    new FilterFieldEqualTo("Node", NodeName)), "Service", "Node", "Created"))
                                                {
                                                    Node.BytesDeleted += await this.GetItemSize(Item2);
 
                                                    Node.NrItems--;
                                                    if (Node.NrItems < 0)
                                                        Node.NrItems = 0;
 
                                                    Deleted = true;
                                                    break;
                                                }
 
                                                if (!Deleted)
                                                    Node.NrItems = 0;
                                            }
 
                                            if (Node.NrItems >= Node.MaxItems)
                                            {
                                                await e.IqErrorNotAcceptable(e.To, "Too many items registered on node.", "en");
                                                return;
                                            }
                                        }
 
                                        Item = new PubSubItem()
                                        {
                                            ItemId = ItemId,
                                            Service = Service,
                                            Node = NodeName,
                                            Publisher = e.From.BareJid,
                                            Payload = Content,
                                            Created = Now,
                                        };
 
                                        if (Node.ItemExpireSeconds != int.MaxValue)
                                            Item.Expires = Now.AddSeconds(Node.ItemExpireSeconds);
 
                                        if (Node.PersistItems)
                                        {
                                            Node.NrItems++;
                                            await Database.Insert(Item);
                                            this.items[Item.Key] = Item;
                                        }
 
                                        Node.LastPublished = Item;
                                    }
 
                                    if (Node.PersistItems)
                                    {
                                        Node.BytesPublished += await this.GetItemSize(Item);
                                        await Database.UpdateLazy(Node);
                                    }
 
                                    Xml = new StringBuilder();
 
                                    Xml.Append("<pubsub xmlns='");
                                    Xml.Append(NamespacePubSub);
                                    Xml.Append("'><publish node='");
                                    Xml.Append(XML.Encode(NodeName));
                                    Xml.Append("'><item id='");
                                    Xml.Append(XML.Encode(Item.ItemIdOrObjectId));
                                    Xml.Append("'/></publish></pubsub>");
 
                                    await e.IqResult(Xml.ToString(), e.To);
 
                                    if (Node.DeliverNotifications)
                                        await this.SendItemEventNotification(Node, Item, e.From, e.Language, Now);
 
                                    return;
                                }
                            }
 
                            if (Node.PersistItems)
                            {
                                await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<item-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Item required.", "en");
                                return;
                            }
                            else
                            {
                                // TODO: Empty notification
                            }
                            break;
 
                        case "retract":
                            NodeName = XML.Attribute(E, "node");
                            if (string.IsNullOrEmpty(NodeName))
                            {
                                await e.IqError("modify", "<not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<nodeid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Node name required.", "en");
                                return;
                            }
 
                            Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                            if (Node is null)
                            {
                                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                return;
                            }
 
                            if (Node.NodeType == NodeType.collection)
                            {
                                await e.IqError("cancel", "<feature-not-implemented xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<unsupported xmlns='http://jabber.org/protocol/pubsub#errors' feature='publish'/>", e.To,
                                    "Publishing items on collection nodes is not supported.", "en");
                                return;
                            }
 
                            if (!Node.PersistItems)
                            {
                                await e.IqError("cancel", "<feature-not-implemented xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<unsupported xmlns='http://jabber.org/protocol/pubsub#errors' feature='persistent-items'/>",
                                    e.To, "Persisted items not supported.", "en");
                                return;
                            }
 
                            foreach (XmlNode N2 in E.ChildNodes)
                            {
                                if (N2 is XmlElement E2 && E2.LocalName == "item" && E2.NamespaceURI == E.NamespaceURI)
                                {
                                    CaseInsensitiveString ItemId = XML.Attribute(E2, "id");
                                    PubSubItem Item = null;
 
                                    Item = await this.LoadItem(Service, NodeName, ItemId);
 
                                    if (Item is null)
                                    {
                                        await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                            "<item-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Item required.", "en");
                                        return;
                                    }
 
                                    if (Item.Node != NodeName)
                                    {
                                        await e.IqErrorBadRequest(e.To, "Item identity points to item belonging to another node.", "en");
                                        return;
                                    }
 
                                    if (!await Node.CanDeleteSingleItem(e.From.BareJid, e.From.BareJid == Item.Publisher))
                                    {
                                        await e.IqErrorForbidden(e.To, "Access denied. Not authorized to delete item on node.", "en");
                                        return;
                                    }
 
                                    Node.BytesDeleted += await this.GetItemSize(Item);
 
                                    Node.NrItems--;
                                    if (Node.NrItems < 0)
                                        Node.NrItems = 0;
 
                                    await Database.DeleteLazy(Item);
                                    await Database.UpdateLazy(Node);
 
                                    await e.IqResult(string.Empty, e.To);
 
                                    if (Node.DeliverNotifications)
                                    {
                                        DateTime Now = DateTime.Now;
                                        Xml = null;
 
                                        foreach (Subscription Rec in await this.GetSubscriptionsOnNode(Service, NodeName))
                                        {
                                            if (Rec.Expires < Now)
                                            {
                                                await this.DeleteSubscription(Service, Rec);
                                                await this.NotifySubscriptionChanged(Rec, FromBareJid);
                                            }
                                            else if (Rec.Deliver &&
                                                Rec.Status == NodeSubscriptionStatus.subscribed &&
                                                Rec.Type == SubscriptionType.items)
                                            {
                                                if (Xml is null)
                                                    Xml = new StringBuilder();
                                                else
                                                    Xml.Clear();
 
                                                Xml.Append("<event xmlns='");
                                                Xml.Append(NamespacePubSubEvents);
                                                Xml.Append("'><items node='");
                                                Xml.Append(XML.Encode(NodeName));
                                                Xml.Append("'><retract id='");
                                                Xml.Append(XML.Encode(Item.ItemIdOrObjectId));
                                                Xml.Append("'/></items></event><headers xmlns='");
                                                Xml.Append(NamespaceStanzaHeaders);
                                                Xml.Append("'><header name='SubID'>");
                                                Xml.Append(Rec.ObjectId);
                                                Xml.Append("</header></headers>");
 
                                                await this.Server.SendMessage(string.Empty,
                                                    Guid.NewGuid().ToString().Replace("-", string.Empty),
                                                    FromBareJid, new XmppAddress(Rec.Jid),
                                                    e.Language, Xml.ToString());
                                            }
                                        }
                                    }
 
                                    return;
                                }
                            }
 
                            await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                "<item-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Item required.", "en");
                            return;
 
                        default:
                            await e.IqErrorBadRequest(e.To, "Element not supported.", "en");
                            return;
                    }
                }
            }
 
            if (InsertNode)
            {
                await Database.InsertLazy(Node);
                Log.Informational("Publish/Subscribe node created.", Node.Name, e.From.BareJid);
 
                lock (this.nodesByServiceAndName)
                {
                    if (this.nodesByServiceAndName.TryGetValue(Service, out Nodes Nodes))
                    {
                        Nodes.NodesByName[Node.Name] = Node;
 
                        Nodes.NodesArray = new PubSubNode[Nodes.NodesByName.Count];
                        Nodes.NodesByName.Values.CopyTo(Nodes.NodesArray, 0);
                    }
                }
 
            }
            else if (NodeUpdated)
            {
                await Database.UpdateLazy(Node);
                Log.Informational("Publish/Subscribe node updated.", Node.Name, e.From.BareJid);
            }
 
            if (!(Subscription is null))
            {
                if (InsertSubscription)
                {
                    lock (this.subscriptionsByJidAndServiceAndNode)
                    {
                        if (this.subscriptionsByJidAndServiceAndNode.TryGetValue(Jid, out List2) &&
                            List2.TryGetValue(Service, out List))
                        {
                            List[NodeName] = Subscription;
                        }
                    }
 
                    lock (this.subscriptionsByServiceAndNodeAndJid)
                    {
                        if (this.subscriptionsByServiceAndNodeAndJid.TryGetValue(Service, out List2) &&
                            List2.TryGetValue(NodeName, out List))
                        {
                            List[Jid] = Subscription;
                        }
                    }
 
                    await Database.InsertLazy(Subscription);
                }
                else if (SubscriptionUpdated)
                    await Database.UpdateLazy(Subscription);
                else if (SubscriptionDeleted)
                    await Database.DeleteLazy(Subscription);
 
                if (e.From.Address != Subscription.Jid)
                    await this.NotifySubscriptionChanged(Subscription, FromBareJid);
 
                Xml = new StringBuilder();
 
                Xml.Append("<pubsub xmlns='");
                Xml.Append(NamespacePubSub);
                Xml.Append("'>");
                Subscription.Serialize(Node, Xml, IncludeOptions);
                Xml.Append("</pubsub>");
 
                await e.IqResult(Xml.ToString(), e.To);
 
                if (Subscription.Status == NodeSubscriptionStatus.subscribed &&
                    Node.SendLastPublishedItem != SendLastPublishedItem.never)
                {
                    await this.SendLastItem(Service, Node, Subscription.Jid, FromBareJid, e.Language);
                }
 
                if (NotificationToOwner)
                {
                    DataForm Form = new DataForm(null, FormType.Form, FromBareJid.Address, Node.Creator,
                        new HiddenField("FORM_TYPE", FormTypeSubscriptionAuthorization),
                        new HiddenField("pubsub#subid", Subscription.ObjectId),
                        new TextSingleField(null, "pubsub#node", "Node:", false,
                            new string[] { NodeName }, null, "Name of node.",
                            null, null, string.Empty, false, false, false),
                        new JidSingleField(null, "pubsub#subscriber_jid", "Subscriber:", false,
                            new string[] { Jid }, null, "JID of subscriber.",
                            null, null, string.Empty, false, false, false),
                        new BooleanField(null, "pubsub#allow", "Authorize subscription request.", true,
                            new string[] { "0" }, null, "Check this box to authorize the subscription.",
                            BooleanDataType.Instance, new BasicValidation(), string.Empty, false, false, false))
                    {
                        Title = "Subscription request",
                        Instructions = new string[]
                        {
                            Jid + " wants to subscribe to " + NodeName + ".",
                            "Approve this subscription request by checking the box below, and click OK.",
                            "Deny this request by leaving the box uncheced, and click OK."
                        }
                    };
 
                    Xml = new StringBuilder();
                    Form.SerializeForm(Xml);
 
                    await this.Server.SendMessage(string.Empty,
                        Guid.NewGuid().ToString().Replace("-", string.Empty),
                        FromBareJid, new XmppAddress(Node.Creator),
                        "en", Xml.ToString());
                }
 
                // TODO: Unregister subscriptions when
                //  * Accounts get deleted
                //  * Full JID subscriptions when account goes offline
            }
            else
                await e.IqResult(string.Empty, e.To);
        }
 
        public Task<string> PublishItem(string Service, string NodeName, string AutoCreateAccess, string From,
            string Domain, string ItemId, string XmlContent, string Language)
        {
            XmlDocument Doc = new XmlDocument()
            {
                PreserveWhitespace = true
            };
 
            Doc.LoadXml(XmlContent);
 
            return this.PublishItem(Service, NodeName, AutoCreateAccess, From, Domain, ItemId, Doc, Language);
        }
 
        public Task<string> PublishItem(string Service, string NodeName, string AutoCreateAccess, string From,
            string Domain, string ItemId, XmlDocument XmlContent, string Language)
        {
            NodeAccessModel? AutoCreateAccess2;
 
            if (string.IsNullOrEmpty(AutoCreateAccess))
                AutoCreateAccess2 = null;
            else if (Enum.TryParse<NodeAccessModel>(AutoCreateAccess, out NodeAccessModel Parsed))
                AutoCreateAccess2 = Parsed;
            else
                throw new ArgumentException("Invalid enum value", nameof(AutoCreateAccess));
 
            return this.PublishItem(Service, NodeName, AutoCreateAccess2, From, Domain, ItemId, XmlContent, Language);
        }
 
        public Task<string> PublishItem(string Service, string NodeName, NodeAccessModel? AutoCreateAccess, string From,
            string Domain, string ItemId, XmlDocument XmlContent, string Language)
        {
            return this.PublishItem(Service, NodeName, AutoCreateAccess, new XmppAddress(From), (CaseInsensitiveString)Domain,
                (CaseInsensitiveString)ItemId, XmlContent, Language);
        }
 
        public async Task<string> PublishItem(string Service, string NodeName, NodeAccessModel? AutoCreateAccess, XmppAddress From,
            CaseInsensitiveString Domain, CaseInsensitiveString ItemId, XmlDocument XmlContent, string Language)
        {
            if (string.IsNullOrEmpty(NodeName))
                throw new ArgumentException("Node name required.", nameof(NodeName));
 
            PubSubNode Node = await this.GetNodeAsync(Service, NodeName, AutoCreateAccess, From, Domain)
                ?? throw new ArgumentException("Node not found.", nameof(NodeName));
 
            if (Node.NodeType == NodeType.collection)
                throw new ArgumentException("Publishing items on collection nodes is not supported.", nameof(NodeName));
 
            if (Node.TransientNode)
                throw new ArgumentException("Transient nodes do not accept items.", nameof(NodeName));
 
            PubSubItem Item = null;
 
            if (!CaseInsensitiveString.IsNullOrEmpty(ItemId) && Node.PersistItems)
            {
                Item = await this.LoadItem(Service, NodeName, ItemId);
 
                if (!(Item is null) && Item.Node != NodeName)
                    throw new ArgumentException("Item identity points to item belonging to another node.", nameof(ItemId));
            }
 
            string Content;
 
            if (Node.PublishOnWeb && !string.IsNullOrEmpty(ItemId))
            {
                if (!(XmlContent.DocumentElement is null) &&
                    XmlContent.DocumentElement.LocalName == "markdownContent" &&
                    XmlContent.DocumentElement.NamespaceURI == WebServices.PubSubContent.Content.LilsisNamespace)
                {
                    StringBuilder Link = new StringBuilder();
                    HttpServer WebServer = IoTGateway.Gateway.HttpServer;
                    int[] Ports = WebServer.OpenHttpsPorts;
 
                    if (Ports.Length > 0)
                    {
                        Link.Append("https://");
                        Link.Append(IoTGateway.Gateway.Domain);
 
                        if (Array.IndexOf(Ports, HttpServer.DefaultHttpsPort) < 0)
                        {
                            Link.Append(':');
                            Link.Append(Ports[0].ToString());
                        }
                    }
                    else
                    {
                        Ports = WebServer.OpenHttpPorts;
 
                        Link.Append("http://");
                        Link.Append(IoTGateway.Gateway.Domain);
 
                        if (Ports.Length > 0 && Array.IndexOf(Ports, HttpServer.DefaultHttpPort) < 0)
                        {
                            Link.Append(':');
                            Link.Append(Ports[0].ToString());
                        }
                    }
 
                    Link.Append('/');
                    Link.Append(System.Web.HttpUtility.UrlEncode(Node.Name));
 
                    if (!ItemId.StartsWith("/"))
                        Link.Append('/');
 
                    Link.Append(ItemId);
 
                    XmlContent.DocumentElement.SetAttribute("link", Link.ToString());
                }
            }
 
            Content = XmlContent.InnerXml.Trim();
 
            byte[] ContentBin = Encoding.UTF8.GetBytes(Content);
            DateTime Now = DateTime.Now;
 
            if (Node.DeliverPayloads && string.IsNullOrEmpty(Content))
                throw new ArgumentException("Missing payload.", nameof(XmlContent));
 
            if (ContentBin.Length > Node.MaxPayloadSize)
                throw new ArgumentException("Payload too big.", nameof(XmlContent));
 
            if (!string.IsNullOrEmpty(Node.PayloadType))
            {
                if (InternetContent.Decodes(Node.PayloadType, out _, out IContentDecoder Decoder))
                {
                    try
                    {
                        await Decoder.DecodeAsync(Node.PayloadType, ContentBin, Encoding.UTF8,
                            new KeyValuePair<string, string>[0], null);
                    }
                    catch (Exception)
                    {
                        throw new ArgumentException("Payload does not conform to Internet Content Type " + Node.PayloadType, nameof(XmlContent));
                    }
                }
                else if (XmlContent.DocumentElement is null || XmlContent.DocumentElement.NamespaceURI != Node.PayloadType)
                    throw new ArgumentException("Payload does not conform to namespace " + Node.PayloadType, nameof(XmlContent));
            }
 
            if (!(Item is null))
            {
                Node.BytesPublished -= await this.GetItemSize(Item);
 
                Item.Publisher = From.BareJid;
                Item.Payload = Content;
                Item.Updated = Now;
 
                await Database.UpdateLazy(Item);
            }
            else
            {
                if (Node.NrItems >= Node.MaxItems)
                {
                    if (Node.AutoDelete)
                    {
                        bool Deleted = false;
 
                        foreach (PubSubItem Item2 in await Database.FindDelete<PubSubItem>(0, 1, new FilterAnd(
                            new FilterFieldEqualTo("Service", Service),
                            new FilterFieldEqualTo("Node", NodeName)), "Service", "Node", "Created"))
                        {
                            Node.BytesDeleted += await this.GetItemSize(Item2);
 
                            Node.NrItems--;
                            if (Node.NrItems < 0)
                                Node.NrItems = 0;
 
                            Deleted = true;
                            break;
                        }
 
                        if (!Deleted)
                            Node.NrItems = 0;
                    }
 
                    if (Node.NrItems >= Node.MaxItems)
                        throw new ForbiddenException("Too many items registered on node.");
                }
 
                Item = new PubSubItem()
                {
                    ItemId = ItemId,
                    Service = Service,
                    Node = NodeName,
                    Publisher = From.BareJid,
                    Payload = Content,
                    Created = Now,
                };
 
                if (Node.ItemExpireSeconds != int.MaxValue)
                    Item.Expires = Now.AddSeconds(Node.ItemExpireSeconds);
 
                if (Node.PersistItems)
                {
                    Node.NrItems++;
                    await Database.Insert(Item);
                    this.items[Item.Key] = Item;
                }
 
                Node.LastPublished = Item;
            }
 
            if (Node.PersistItems)
            {
                Node.BytesPublished += await this.GetItemSize(Item);
                await Database.UpdateLazy(Node);
            }
 
            if (Node.DeliverNotifications)
                await this.SendItemEventNotification(Node, Item, From, Language, Now);
 
            return Item.ObjectId;
        }
 
        private async Task SendItemEventNotification(PubSubNode Node, PubSubItem Item, XmppAddress From, string Language, DateTime Now)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<event xmlns='");
            Xml.Append(NamespacePubSubEvents);
            Xml.Append("'><items node='");
            Xml.Append(XML.Encode(Node.Name));
            Xml.Append("'><item id='");
            Xml.Append(XML.Encode(Item.ItemIdOrObjectId));
            Xml.Append("' publisher='");
            Xml.Append(XML.Encode(Item.Publisher));
 
            if (Node.DeliverPayloads)
            {
                Xml.Append("'>");
 
                if (XML.IsValidXml(Item.Payload, true, true, true, true, false, false))
                    Xml.Append(Item.Payload);
 
                Xml.Append("</item>");
            }
            else
                Xml.Append("'/>");
 
            Xml.Append("</items></event>");
 
            // TODO: include body, if transform exists
 
            string EventXml;
 
            if (Node.AutoSubscribe && Node.AccessModel == NodeAccessModel.presence)
            {
                if (From.IsFullJID)
                {
                    Xml.Append("<addresses xmlns='");
                    Xml.Append(XmppServer.ExtendedAddressingNamespace);
                    Xml.Append("'><address type='replyto' jid='");
                    Xml.Append(From.Address);
                    Xml.Append("'/></addresses>");
                }
 
                EventXml = Xml.ToString();
 
                IEnumerable<IRosterItem> Roster = await XmppServerModule.GetRosterAsync(From.Account);
                if (!(Roster is null))
                {
                    foreach (IRosterItem RosterItem in Roster)
                    {
                        if (RosterItem.Subscription == SubscriptionStatus.both ||
                            RosterItem.Subscription == SubscriptionStatus.from)
                        {
                            CaseInsensitiveString[] Jids = this.FilterNotifiations(new XmppAddress(RosterItem.BareJid), Node);
                            if (!(Jids is null))
                            {
                                foreach (CaseInsensitiveString Jid2 in Jids)
                                {
                                    await this.Server.SendMessage(Node.NotificationType.ToString(),
                                        Guid.NewGuid().ToString().Replace("-", string.Empty),
                                        From.BareJid, Jid2, Language, EventXml);
                                }
                            }
                        }
                    }
 
                    await this.Server.SendMessage(Node.NotificationType.ToString(),
                        Guid.NewGuid().ToString().Replace("-", string.Empty),
                        From.BareJid, From.BareJid, Language, EventXml);
                }
            }
            else
            {
                XmppAddress FromBareJid = string.IsNullOrEmpty(Node.Service) ? this.MainDomain : From.ToBareJID();
                EventXml = Xml.ToString();
 
                foreach (Subscription Rec in await this.GetSubscriptionsOnNode(Node.Service, Node.Name))
                {
                    if (Rec.Expires < Now)
                    {
                        await this.DeleteSubscription(Node.Service, Rec);
                        await this.NotifySubscriptionChanged(Rec, FromBareJid);
                    }
                    else if (Rec.Deliver &&
                        Rec.Status == NodeSubscriptionStatus.subscribed &&
                        Rec.Type == SubscriptionType.items)
                    {
                        Xml.Clear();
 
                        Xml.Append(EventXml);
                        Xml.Append("<headers xmlns='");
                        Xml.Append(NamespaceStanzaHeaders);
                        Xml.Append("'><header name='SubID'>");
                        Xml.Append(Rec.ObjectId);
                        Xml.Append("</header></headers>");
 
                        await this.Server.SendMessage(Node.NotificationType.ToString(),
                            Guid.NewGuid().ToString().Replace("-", string.Empty),
                            FromBareJid, new XmppAddress(Rec.Jid), Language, Xml.ToString());
                    }
                }
            }
        }
 
        private async Task SendLastItem(CaseInsensitiveString Service, PubSubNode Node, CaseInsensitiveString Jid,
            XmppAddress FromBareJid, string Language)
        {
            if (!Node.LastPublishedKnown)
            {
                foreach (PubSubItem Item in await Database.Find<PubSubItem>(0, 1, new FilterAnd(
                    new FilterFieldEqualTo("Service", Service),
                    new FilterFieldEqualTo("Node", Node.Name)), "-Service", "-Node", "-Created"))
                {
                    Node.LastPublished = Item;
                }
 
                Node.LastPublishedKnown = true;
            }
 
            PubSubItem LastItem = Node.LastPublished;
            if (!(LastItem is null))
            {
                StringBuilder Xml = new StringBuilder();
 
                Xml.Append("<event xmlns='");
                Xml.Append(NamespacePubSubEvents);
                Xml.Append("'><items node='");
                Xml.Append(XML.Encode(Node.Name));
                Xml.Append("'><item id='");
                Xml.Append(XML.Encode(LastItem.ItemIdOrObjectId));
                Xml.Append("' publisher='");
                Xml.Append(XML.Encode(LastItem.Publisher));
 
                if (Node.DeliverPayloads)
                {
                    Xml.Append("'>");
 
                    if (XML.IsValidXml(LastItem.Payload, true, true, true, true, false, false))
                        Xml.Append(LastItem.Payload);
 
                    Xml.Append("</item>");
                }
                else
                    Xml.Append("'/>");
 
                Xml.Append("</items></event>");
                Xml.Append("<delay xmlns='");
                Xml.Append(XmppServer.DelayedDeliveryNamespace);
                Xml.Append("' stamp='");
                Xml.Append(XML.Encode(LastItem.Created));
                Xml.Append("'/>");
 
                await this.Server.SendMessage(string.Empty,
                    Guid.NewGuid().ToString().Replace("-", string.Empty),
                    FromBareJid, new XmppAddress(Jid),
                    Language, Xml.ToString());
            }
        }
 
        public async Task<Tuple<PubSubItem[], bool, string>> LoadItems(CaseInsensitiveString Service, CaseInsensitiveString NodeName,
            CaseInsensitiveString From, int MaxCount)
        {
            List<Filter> Filters = new List<Filter>()
            {
                new FilterFieldEqualTo("Service", Service),
                new FilterFieldEqualTo("Node", NodeName)
            };
 
            if (!string.IsNullOrEmpty(From))
            {
                try
                {
                    PubSubItem Item = await this.LoadItem(Service, NodeName, From);
                    if (Item is null || Item.Node != NodeName)
                        return null;
 
                    Filters.Add(new FilterFieldLesserThan("Created", Item.Created));
                }
                catch (Exception)
                {
                    return null;
                }
            }
 
            List<PubSubItem> Result = new List<PubSubItem>();
            bool More = false;
            string Last = string.Empty;
 
            foreach (PubSubItem Item in await Database.Find<PubSubItem>(0, MaxCount + 1, new FilterAnd(Filters.ToArray()), "-Service", "-Node", "-Created"))
            {
                if (MaxCount-- <= 0)
                {
                    More = true;
                    break;
                }
 
                Last = Item.ItemIdOrObjectId;
                Result.Add(Item);
            }
 
            return new Tuple<PubSubItem[], bool, string>(Result.ToArray(), More, Last);
        }
 
        public async Task<PubSubItem> LoadItem(CaseInsensitiveString Service, CaseInsensitiveString NodeName, CaseInsensitiveString ItemId)
        {
            StringBuilder Key = new StringBuilder();
 
            Key.Append(Service);
            Key.Append('/');
            Key.Append(NodeName);
            if (!ItemId.StartsWith("/"))
                Key.Append('/');
            Key.Append(ItemId);
 
            if (this.items.TryGetValue(Key.ToString(), out PubSubItem Item))
                return Item;
 
            foreach (PubSubItem Item2 in await Database.Find<PubSubItem>(new FilterAnd(
                new FilterFieldEqualTo("Service", Service),
                new FilterFieldEqualTo("Node", NodeName),
                new FilterFieldEqualTo("ItemId", ItemId))))
            {
                return Item2;
            }
 
            if (ItemId.StartsWith("/"))
                ItemId = ItemId.Substring(1);
 
            if (Guid.TryParse(ItemId, out Guid Guid2))
                return await Database.TryLoadObject<PubSubItem>(Guid2);
 
            return null;
        }
 
        private async Task DeleteSubscription(CaseInsensitiveString Service, Subscription Subscription)
        {
            Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Subscription>> List2;
            Dictionary<CaseInsensitiveString, Subscription> List;
 
            lock (this.subscriptionsByJidAndServiceAndNode)
            {
                if (this.subscriptionsByJidAndServiceAndNode.TryGetValue(Subscription.Jid, out List2) &&
                    List2.TryGetValue(Service, out List))
                {
                    List.Remove(Subscription.Node);
                }
            }
 
            lock (this.subscriptionsByServiceAndNodeAndJid)
            {
                if (this.subscriptionsByServiceAndNodeAndJid.TryGetValue(Service, out List2) &&
                    List2.TryGetValue(Subscription.Node, out List))
                {
                    List.Remove(Subscription.Jid);
                }
            }
 
            await Database.DeleteLazy(Subscription);
        }
 
        private async Task<int> GetItemSize(PubSubItem Item)
        {
            if (!(this.itemSerializer is null))
            {
                BinarySerializer Serializer = new BinarySerializer("PubSubItems", Encoding.UTF8);
                await this.itemSerializer.Serialize(Serializer, false, false, Item, null);
                Serializer.FlushBits();
                byte[] Binary = Serializer.GetSerialization();
                return Binary.Length;
            }
            else
            {
                return
                    Encoding.UTF8.GetBytes(Item.ObjectId).Length +
                    Encoding.UTF8.GetBytes(Item.ItemId).Length +
                    Encoding.UTF8.GetBytes(Item.Node).Length +
                    Encoding.UTF8.GetBytes(Item.Publisher).Length +
                    Encoding.UTF8.GetBytes(Item.Payload).Length +
                    8 + 8 + 5;
            }
        }
 
        private Task PubSubOwnerGetHandler(object Sender, IqEventArgs e)
        {
            return this.PubSubOwnerGetHandler(string.Empty, e, pubSubFeatures);
        }
 
        private Task PepOwnerGetHandler(object Sender, IqEventArgs e)
        {
            return this.PubSubOwnerGetHandler((e.To.IsEmpty ? e.From : e.To).BareJid, e, pepFeatures);
        }
 
        private async Task PubSubOwnerGetHandler(CaseInsensitiveString Service, IqEventArgs e, DefaultFeatures _)
        {
            PubSubNode Node;
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    switch (E.LocalName)
                    {
                        case "configure":
                            string NodeName = XML.Attribute(E, "node");
                            if (string.IsNullOrEmpty(NodeName))
                            {
                                await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<nodeid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Node name required.", "en");
                                return;
                            }
 
                            Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                            if (Node is null)
                            {
                                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                return;
                            }
 
                            if (!await Node.CanConfigureNode(e.From.BareJid))
                            {
                                await e.IqErrorForbidden(e.To, "Not authorized to configure node.", "en");
                                return;
                            }
 
                            DataForm Form = this.GetForm(Node, e);
                            StringBuilder Xml = new StringBuilder();
 
                            Xml.Append("<pubsub xmlns='");
                            Xml.Append(NamespacePubSubOwner);
                            Xml.Append("'><configure node='");
                            Xml.Append(XML.Encode(NodeName));
                            Xml.Append("'>");
                            Form.SerializeForm(Xml);
                            Xml.Append("</configure></pubsub>");
 
                            await e.IqResult(Xml.ToString(), e.To);
                            return;
 
                        case "default":
                            Node = new PubSubNode()
                            {
                                Domain = e.To.Address
                            };
                            Form = this.GetForm(Node, e);
                            Xml = new StringBuilder();
 
                            Xml.Append("<pubsub xmlns='");
                            Xml.Append(NamespacePubSubOwner);
                            Xml.Append("'><default>");
                            Form.SerializeForm(Xml);
                            Xml.Append("</default></pubsub>");
 
                            await e.IqResult(Xml.ToString(), e.To);
                            return;
 
                        case "subscriptions":
                            NodeName = XML.Attribute(E, "node");
                            if (string.IsNullOrEmpty(NodeName))
                            {
                                await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<nodeid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Node name required.", "en");
                                return;
                            }
 
                            Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                            if (Node is null)
                            {
                                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                return;
                            }
 
                            if (!await Node.CanConfigureNode(e.From.BareJid))
                            {
                                await e.IqErrorForbidden(e.To, "Not authorized to configure node.", "en");
                                return;
                            }
 
                            Xml = new StringBuilder();
 
                            Xml.Append("<pubsub xmlns='");
                            Xml.Append(NamespacePubSubOwner);
                            Xml.Append("'><subscriptions node='");
                            Xml.Append(XML.Encode(NodeName));
                            Xml.Append("'>");
 
                            Subscription[] Subscriptions = await this.GetSubscriptionsOnNode(Service, NodeName);
 
                            foreach (Subscription Subscription in Subscriptions)
                            {
                                Xml.Append("<subscription jid='");
                                Xml.Append(XML.Encode(Subscription.Jid));
                                Xml.Append("' subscription='");
                                Xml.Append(Subscription.Status.ToString());
                                Xml.Append("'/>");
                            }
 
                            Xml.Append("</subscriptions></pubsub>");
 
                            await e.IqResult(Xml.ToString(), e.To);
                            return;
 
                        case "affiliations":
                            NodeName = XML.Attribute(E, "node");
                            if (string.IsNullOrEmpty(NodeName))
                            {
                                await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<nodeid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Node name required.", "en");
                                return;
                            }
 
                            Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                            if (Node is null)
                            {
                                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                return;
                            }
 
                            if (!await Node.CanConfigureNode(e.From.BareJid))
                            {
                                await e.IqErrorForbidden(e.To, "Not authorized to configure node.", "en");
                                return;
                            }
 
                            Xml = new StringBuilder();
 
                            Xml.Append("<pubsub xmlns='");
                            Xml.Append(NamespacePubSubOwner);
                            Xml.Append("'><affiliations node='");
                            Xml.Append(XML.Encode(NodeName));
                            Xml.Append("'>");
 
                            foreach (KeyValuePair<CaseInsensitiveString, AffiliationStatus> Affiliation in Node.GetAffiliations())
                            {
                                Xml.Append("<affiliation jid='");
                                Xml.Append(XML.Encode(Affiliation.Key));
                                Xml.Append("' affiliation='");
                                Xml.Append(ToString(Affiliation.Value));
                                Xml.Append("'/>");
                            }
 
                            Xml.Append("</affiliations></pubsub>");
 
                            await e.IqResult(Xml.ToString(), e.To);
                            return;
 
                        default:
                            await e.IqErrorBadRequest(e.To, "Element not supported.", "en");
                            return;
                    }
                }
            }
 
            await e.IqErrorBadRequest(e.To, "Missing element.", "en");
        }
 
        private static string ToString(AffiliationStatus Affiliation)
        {
            if (Affiliation == AffiliationStatus.publishOnly)
                return "publish-only";
            else
                return Affiliation.ToString();
        }
 
        private DataForm GetForm(PubSubNode Node, IqEventArgs e)
        {
            return new DataForm(null, FormType.Form, e.To.Address, e.From.Address,
                new HiddenField("FORM_TYPE", FormTypeNodeConfig),
                new TextSingleField(null, "pubsub#title", "Title:", false, new string[] { Node.Title }, null,
                    "A friendly name for the node.", StringDataType.Instance, null, string.Empty, false, false, false),
                new BooleanField(null, "pubsub#deliver_notifications", "Event notifications.", false,
                    new string[] { Node.DeliverNotifications ? "1" : "0" }, null,
                    "Whether to deliver event notifications.", BooleanDataType.Instance, null, string.Empty, false, false, false),
                new BooleanField(null, "pubsub#deliver_payloads", "Deliver payloads.", false,
                    new string[] { Node.DeliverPayloads ? "1" : "0" }, null,
                    "Whether to deliver payloads with event notifications.", BooleanDataType.Instance, null, string.Empty, false, false, false),
                new BooleanField(null, "pubsub#notify_config", "Notify configurations.", false,
                    new string[] { Node.NotifyConfig ? "1" : "0" }, null,
                    "Notify subscribers when the node configuration changes.", BooleanDataType.Instance, null, string.Empty, false, false, false),
                new BooleanField(null, "pubsub#notify_delete", "Notify delete.", false,
                    new string[] { Node.NotifyDelete ? "1" : "0" }, null,
                    "Notify subscribers when the node is deleted.", BooleanDataType.Instance, null, string.Empty, false, false, false),
                new BooleanField(null, "pubsub#notify_retract", "Notify retract.", false,
                    new string[] { Node.NotifyRetract ? "1" : "0" }, null,
                    "Notify subscribers when items are removed from the node.", BooleanDataType.Instance, null, string.Empty, false, false, false),
                new BooleanField(null, "pubsub#notify_sub", "Notify subscriptions.", false,
                    new string[] { Node.NotifySubscriptions ? "1" : "0" }, null,
                    "Notify owners about new subscribers and unsubscribes.", BooleanDataType.Instance, null, string.Empty, false, false, false),
                new BooleanField(null, "pubsub#persist_items", "Persist items.", false,
                    new string[] { Node.PersistItems ? "1" : "0" }, null,
                    "Persist items to storage.", BooleanDataType.Instance, null, string.Empty, false, false, false),
                new TextSingleField(null, "pubsub#max_items", "Items to persist:", false,
                    new string[] { Node.MaxItems.ToString() }, null,
                    "Max # of items to persist.", IntegerDataType.Instance, new RangeValidation("1", int.MaxValue.ToString()),
                    string.Empty, false, false, false),
                new TextSingleField(null, "pubsub#item_expire", "Seconds before items expire:", false,
                    new string[] { Node.ItemExpireSeconds.ToString() }, null,
                    "Time after which to automatically purge items.", IntegerDataType.Instance, new RangeValidation("1", int.MaxValue.ToString()),
                    string.Empty, false, false, false),
                new BooleanField(null, "pubsub#purge_offline", "Purge when publisher offline.", false,
                    new string[] { Node.PurgeOffline ? "1" : "0" }, null,
                    "Purge all items when the relevant publisher goes offline?", BooleanDataType.Instance, null,
                    string.Empty, false, false, false),
                new TextSingleField(null, "pubsub#node_expire", "Date when node expires:", false,       // TODO: Write XEP
                    new string[] { XML.Encode(Node.Expires, true) }, null,
                    "The node and all its items will be purged after this date.", DateDataType.Instance, new RangeValidation(XML.Encode(DateTime.Today, true), XML.Encode(DateTime.MaxValue, true)),
                    string.Empty, false, false, false),
                new BooleanField(null, "pubsub#subscribe", "Allow subscriptions.", false,
                    new string[] { Node.AllowSubscriptions ? "1" : "0" }, null,
                    "Whether to allow subscriptions.", BooleanDataType.Instance, null,
                    string.Empty, false, false, false),
                new ListSingleField(null, "pubsub#access_model", "Access model:", false,
                    new string[] { Node.AccessModel.ToString() }, new KeyValuePair<string, string>[]
                    {
                        new KeyValuePair<string, string>("Everyone has access", "open"),
                        new KeyValuePair<string, string>("Contacts with approved presence subscriptions", "presence"),
                        new KeyValuePair<string, string>("Contacts in specified groups", "roster"),
                        new KeyValuePair<string, string>("Only authorized entities", "authorize"),
                        new KeyValuePair<string, string>("Only if on whitelist", "whitelist")
                    },
                    "Specify the subscriber model.", null, new BasicValidation(),
                    string.Empty, false, false, false),
                new TextMultiField(null, "pubsub#roster_groups_allowed", "Roster groups allowed:", false,
                    Node.RosterGroupsAllowed, null,
                    "Roster groups allowed to subscribe.", StringDataType.Instance, null,
                    string.Empty, false, false, false),
                new ListSingleField(null, "pubsub#publish_model", "Publish model:", false,
                    new string[] { Node.PublisherModel.ToString() }, new KeyValuePair<string, string>[]
                    {
                        new KeyValuePair<string, string>("Only publishers may publish", "publishers"),
                        new KeyValuePair<string, string>("Subscribers may publish", "subscribers"),
                        new KeyValuePair<string, string>("Anyone may publish", "open")
                    },
                    "Specify the publisher model.", null, new BasicValidation(),
                    string.Empty, false, false, false),
                new TextSingleField(null, "pubsub#max_payload_size", "Maximum payload size:", false,
                    new string[] { Node.MaxPayloadSize.ToString() }, null,
                    "Max Payload size in bytes.", IntegerDataType.Instance, new RangeValidation("1", int.MaxValue.ToString()),
                    string.Empty, false, false, false),
                new ListSingleField(null, "pubsub#send_last_published_item", "Send last item:", false,
                    new string[] { Node.SendLastPublishedItem.ToString() }, new KeyValuePair<string, string>[]
                    {
                        new KeyValuePair<string, string>("Never", "never"),
                        new KeyValuePair<string, string>("When a new subscription is processed", "on_sub"),
                        new KeyValuePair<string, string>("When a new subscription is processed and whenever a subscriber comes online", "on_sub_and_presence")
                    },
                    "When to send the last published item.", null, new BasicValidation(),
                    string.Empty, false, false, false),
                new BooleanField(null, "pubsub#presence_based_delivery", "Notifications only to available users.", false,
                    new string[] { Node.PresenceBasedDelivery ? "1" : "0" }, null,
                    "Deliver event notifications only to available users.", BooleanDataType.Instance, null,
                    string.Empty, false, false, false),
                new ListSingleField(null, "pubsub#notification_type", "Notification type:", false,
                    new string[] { Node.NotificationType.ToString() }, new KeyValuePair<string, string>[]
                    {
                        new KeyValuePair<string, string>("Messages of type normal", "normal"),
                        new KeyValuePair<string, string>("Messages of type headline", "headline")
                    },
                    "Specify the delivery style for event notifications.", null, new BasicValidation(),
                    string.Empty, false, false, false),
                new TextSingleField(null, "pubsub#type", "Payload type:", false,
                    new string[] { Node.PayloadType }, null,
                    "Specify the type of payload data to be provided at this node.", StringDataType.Instance, new BasicValidation(),
                    string.Empty, false, false, false),
                new TextSingleField(null, "pubsub#dataform_xslt", "Data Forms XSLT:", false,
                    new string[] { Node.DataFormXsltUrl }, null,
                    "The URL of an XSL transformation which can be applied to the payload format in order to generate a valid Data Forms result that the client could display using a generic Data Forms rendering engine.", StringDataType.Instance, new BasicValidation(),
                    string.Empty, false, false, false),
                new TextSingleField(null, "pubsub#body_xslt", "Message Body XSLT:", false,
                    new string[] { Node.BodyXsltUrl }, null,
                    "The URL of an XSL transformation which can be applied to payloads in order to generate an appropriate message body element.", StringDataType.Instance, new BasicValidation(),
                    string.Empty, false, false, false),
                new TextMultiField(null, "pubsub#collection", "Collections:", false, Node.Collections.ToStringArray(), null,
                    "The collection(s) with which a node is affiliated.", StringDataType.Instance, new BasicValidation(),
                    string.Empty, false, false, false),
                new JidMultiField(null, "pubsub#contact", "Contacts:", false, Node.Contact.ToStringArray(), null,
                    "The JIDs of those to contact with questions.", StringDataType.Instance, new BasicValidation(),
                    string.Empty, false, false, false),
                new ListSingleField(null, "pubsub#itemreply", "Send replies to:", false,
                    new string[] { Node.ItemReply.ToString() }, new KeyValuePair<string, string>[]
                    {
                        new KeyValuePair<string, string>("Statically specify a replyto of the node owner(s)", "owner"),
                        new KeyValuePair<string, string>("Dynamically specify a replyto of the item publisher", "publisher")
                    },
                    "Whether owners or publisher should receive replies to items.", null, new BasicValidation(),
                    string.Empty, false, false, false),
                new ListSingleField(null, "pubsub#children_association_policy", "Who can associate child nodes:", false,
                    new string[] { Node.ChildAssociationPolicy.ToString() }, new KeyValuePair<string, string>[]
                    {
                        new KeyValuePair<string, string>("Anyone may associate leaf nodes with the collection", "all"),
                        new KeyValuePair<string, string>("Only collection node owners may associate leaf nodes with the collection", "owners"),
                        new KeyValuePair<string, string>("Only those on a whitelist may associate leaf nodes with the collection", "whitelist")
                    },
                    "Who may associate leaf nodes with a collection.", null, new BasicValidation(),
                    string.Empty, false, false, false),
                new TextMultiField(null, "pubsub#children_association_whitelist", "Child association whitelist:", false, Node.ChildAssociationWhitelist.ToStringArray(), null,
                    "The list of JIDs that may associate leaf nodes with a collection.", StringDataType.Instance, new BasicValidation(),
                    string.Empty, false, false, false),
                new TextMultiField(null, "pubsub#children", "Child nodes:", false, Node.Children.ToStringArray(), null,
                    "The child nodes (leaf or collection) associated with a collection.", StringDataType.Instance, new BasicValidation(),
                    string.Empty, false, false, false),
                new TextSingleField(null, "pubsub#children_max", "Maximum amount of child nodes:", false, Node.Children.ToStringArray(), null,
                    "The maximum number of child nodes that can be associated with a collection.", IntegerDataType.Instance,
                    new RangeValidation("1", int.MaxValue.ToString()), string.Empty, false, false, false),
                new ListSingleField(null, "pubsub#node_type", "Node type:", false,
                    new string[] { Node.NodeType.ToString() }, new KeyValuePair<string, string>[]
                    {
                        new KeyValuePair<string, string>("The node is a leaf node (default)", "leaf"),
                        new KeyValuePair<string, string>("The node is a collection node", "collection")
                    },
                    "Whether the node is a leaf (default) or a collection.", null, new BasicValidation(),
                    string.Empty, false, false, false),
                new JidMultiField(null, "pubsub#replyroom", "Reply rooms:", false, Node.ReplyRooms.ToStringArray(), null,
                    "The specific multi-user chat rooms to specify for replyroom.", StringDataType.Instance, new BasicValidation(),
                    string.Empty, false, false, false),
                new JidMultiField(null, "pubsub#replyto", "Reply to:", false, Node.ReplyTo.ToStringArray(), null,
                    "The specific JID(s) to specify for replyto.", StringDataType.Instance, new BasicValidation(),
                    string.Empty, false, false, false),
                new TextMultiField(null, "pubsub#description", "Description:", false, Node.Description, null,
                    "A description of the node.", StringDataType.Instance, null, string.Empty, false, false, false),
                new TextSingleField(null, "pubsub#language", "Default language:", false, new string[] { Node.Language }, null,
                    "Default language for the node.", StringDataType.Instance, null, string.Empty, false, false, false));
        }
 
        private Task PubSubOwnerSetHandler(object Sender, IqEventArgs e)
        {
            return this.PubSubOwnerSetHandler(string.Empty, e, pubSubFeatures);
        }
 
        private Task PepOwnerSetHandler(object Sender, IqEventArgs e)
        {
            return this.PubSubOwnerSetHandler((e.To.IsEmpty ? e.From : e.To).BareJid, e, pepFeatures);
        }
 
        private async Task PubSubOwnerSetHandler(CaseInsensitiveString Service, IqEventArgs e, DefaultFeatures _)
        {
            XmppAddress FromBareJid = string.IsNullOrEmpty(Service) ? e.To : e.From.ToBareJID();
            PubSubNode Node = null;
            bool NodeUpdated = false;
 
            foreach (XmlNode N in e.Query.ChildNodes)
            {
                if (N is XmlElement E)
                {
                    switch (E.LocalName)
                    {
                        case "configure":
                            string NodeName = XML.Attribute(E, "node");
                            if (string.IsNullOrEmpty(NodeName))
                            {
                                await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<nodeid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Node name required.", "en");
                                return;
                            }
 
                            Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                            if (Node is null)
                            {
                                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                return;
                            }
 
                            if (await this.ConfigureNode(E, Node, e))
                            {
                                NodeUpdated = true;
                                // TODO: Notify subscribers (Examples 150 & 151)
                            }
                            else
                                return;
                            break;
 
                        case "delete":
                            NodeName = XML.Attribute(E, "node");
                            Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                            if (Node is null)
                            {
                                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                return;
                            }
 
                            if (!await Node.CanDeleteNode(e.From.BareJid))
                            {
                                await e.IqErrorForbidden(e.To, "Not authorized to delete node.", "en");
                                return;
                            }
 
                            string RedirectUri = null;
 
                            foreach (XmlNode N2 in E.ChildNodes)
                            {
                                if (N2 is XmlElement E2 && E2.LocalName == "redirect" && E2.NamespaceURI == E.NamespaceURI)
                                {
                                    RedirectUri = XML.Attribute(E2, "uri");
                                    break;
                                }
                            }
 
                            await this.DeleteNode(Service, Node, FromBareJid);
 
                            await e.IqResult(string.Empty, e.To);
                            return;
 
                        case "purge":
                            NodeName = XML.Attribute(E, "node");
                            Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                            if (Node is null)
                            {
                                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                return;
                            }
 
                            (bool CanPurge, bool OnlyItemsBySameEntity) = await Node.CanPurgeNode(e.From.BareJid);
                            if (!CanPurge)
                            {
                                await e.IqErrorForbidden(e.To, "Not authorized to purge node.", "en");
                                return;
                            }
 
                            Node.LastPublished = null;
 
                            if (!Node.PersistItems)
                            {
                                await e.IqError("cancel", "<feature-not-implemented xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<unsupported xmlns='http://jabber.org/protocol/pubsub#errors' feature='persistent-items'/>",
                                    e.To, "Node does not persist items.", "en");
                                return;
                            }
 
                            if (OnlyItemsBySameEntity)
                            {
                                await Database.FindDelete<PubSubItem>(new FilterAnd(
                                    new FilterFieldEqualTo("Service", Service),
                                    new FilterFieldEqualTo("Publisher", e.From.BareJid),
                                    new FilterFieldEqualTo("Node", NodeName)));
                            }
                            else
                            {
                                await Database.FindDelete<PubSubItem>(new FilterAnd(
                                    new FilterFieldEqualTo("Service", Service), new FilterFieldEqualTo("Node", NodeName)));
                            }
 
                            await e.IqResult(string.Empty, e.To);
 
                            if (Node.DeliverNotifications)
                            {
                                DateTime Now = DateTime.Now;
                                StringBuilder Xml = null;
 
                                foreach (Subscription Rec in await this.GetSubscriptionsOnNode(Service, NodeName))
                                {
                                    if (Rec.Expires < Now)
                                    {
                                        await this.DeleteSubscription(Service, Rec);
                                        await this.NotifySubscriptionChanged(Rec, FromBareJid);
                                    }
                                    else if (Rec.Deliver &&
                                        Rec.Status == NodeSubscriptionStatus.subscribed &&
                                        Rec.Type == SubscriptionType.items)
                                    {
                                        if (Xml is null)
                                            Xml = new StringBuilder();
                                        else
                                            Xml.Clear();
 
                                        Xml.Append("<event xmlns='");
                                        Xml.Append(NamespacePubSubEvents);
                                        Xml.Append("'><purge node='");
                                        Xml.Append(XML.Encode(NodeName));
                                        Xml.Append("'/></event><headers xmlns='");
                                        Xml.Append(NamespaceStanzaHeaders);
                                        Xml.Append("'><header name='SubID'>");
                                        Xml.Append(Rec.ObjectId);
                                        Xml.Append("</header></headers>");
 
                                        await this.Server.SendMessage(string.Empty,
                                            Guid.NewGuid().ToString().Replace("-", string.Empty),
                                            FromBareJid, new XmppAddress(Rec.Jid),
                                            e.Language, Xml.ToString());
                                    }
                                }
                            }
                            return;
 
                        case "subscriptions":
                            NodeName = XML.Attribute(E, "node");
                            if (string.IsNullOrEmpty(NodeName))
                            {
                                await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<nodeid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Node name required.", "en");
                                return;
                            }
 
                            Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                            if (Node is null)
                            {
                                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                return;
                            }
 
                            if (!await Node.CanConfigureNode(e.From.BareJid))
                            {
                                await e.IqErrorForbidden(e.To, "Not authorized to configure node.", "en");
                                return;
                            }
 
                            foreach (XmlNode N2 in E.ChildNodes)
                            {
                                if (N2 is XmlElement E2 && E2.LocalName == "subscription" &&
                                    E2.NamespaceURI == E.NamespaceURI)
                                {
                                    CaseInsensitiveString Jid = XML.Attribute(E2, "jid");
                                    NodeSubscriptionStatus Status = XML.Attribute(E2, "subscription", NodeSubscriptionStatus.none);
                                    Subscription Subscription = await this.GetSubscriptionAsync(Service, NodeName, Jid);
 
                                    if (Subscription is null)
                                    {
                                        if (Status == NodeSubscriptionStatus.none)
                                            continue;
 
                                        XmppAddress Address = new XmppAddress(Jid);
                                        Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Subscription>> List2;
                                        Dictionary<CaseInsensitiveString, Subscription> List = null;
 
                                        Subscription = new Subscription()
                                        {
                                            Jid = Jid,
                                            IsFullJid = Address.IsFullJID,
                                            Service = Service,
                                            Node = NodeName,
                                            Status = Status
                                        };
 
                                        lock (this.subscriptionsByJidAndServiceAndNode)
                                        {
                                            if (this.subscriptionsByJidAndServiceAndNode.TryGetValue(Jid, out List2) &&
                                                List2.TryGetValue(Service, out List))
                                            {
                                                List[NodeName] = Subscription;
                                            }
                                        }
 
                                        lock (this.subscriptionsByServiceAndNodeAndJid)
                                        {
                                            if (this.subscriptionsByServiceAndNodeAndJid.TryGetValue(Service, out List2) &&
                                                List2.TryGetValue(NodeName, out List))
                                            {
                                                List[Jid] = Subscription;
                                            }
                                        }
 
                                        await Database.InsertLazy(Subscription);
                                    }
                                    else if (Subscription.Status == Status)
                                        continue;
                                    else
                                    {
                                        Subscription.Status = Status;
 
                                        if (Status == NodeSubscriptionStatus.none)
                                            await this.DeleteSubscription(Service, Subscription);
                                        else
                                            await Database.UpdateLazy(Subscription);
                                    }
 
                                    await this.NotifySubscriptionChanged(Subscription, FromBareJid);
                                }
                            }
 
                            await e.IqResult(string.Empty, e.To);
                            return;
 
                        case "affiliations":
                            NodeName = XML.Attribute(E, "node");
                            if (string.IsNullOrEmpty(NodeName))
                            {
                                await e.IqError("modify", "<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                    "<nodeid-required xmlns='http://jabber.org/protocol/pubsub#errors'/>", e.To, "Node name required.", "en");
                                return;
                            }
 
                            Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                            if (Node is null)
                            {
                                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                                return;
                            }
 
                            if (!await Node.CanConfigureNode(e.From.BareJid))
                            {
                                await e.IqErrorForbidden(e.To, "Not authorized to configure node.", "en");
                                return;
                            }
 
                            foreach (XmlNode N2 in E.ChildNodes)
                            {
                                if (N2 is XmlElement E2 && E2.LocalName == "affiliation" &&
                                    E2.NamespaceURI == E.NamespaceURI)
                                {
                                    CaseInsensitiveString Jid = XML.Attribute(E2, "jid");
                                    string s = XML.Attribute(E2, "affiliation");
                                    AffiliationStatus Affiliation;
 
                                    if (s == "publish-only")
                                        Affiliation = AffiliationStatus.publishOnly;
                                    else if (!Enum.TryParse<AffiliationStatus>(s, out Affiliation))
                                        continue;
 
                                    Node.SetAffiliation(Jid, Affiliation);
                                    await this.NotifyAffiliationChanged(NodeName, Jid, Affiliation, FromBareJid);
 
                                    NodeUpdated = true;
                                }
                            }
 
                            if (NodeUpdated)
                                await Database.UpdateLazy(Node);
 
                            await e.IqResult(string.Empty, e.To);
                            return;
 
                        default:
                            await e.IqErrorBadRequest(e.To, "Element not supported.", "en");
                            return;
                    }
                }
            }
 
            if (NodeUpdated)
            {
                await Database.UpdateLazy(Node);
                Log.Informational("Publish/Subscribe node updated.", Node.Name, e.From.BareJid);
            }
 
            await e.IqResult(string.Empty, e.To);
        }
 
        internal async Task DeleteNode(CaseInsensitiveString Service, PubSubNode Node, XmppAddress FromBareJid)
        {
            Dictionary<CaseInsensitiveString, Subscription> List = null;
            string NodeName = Node.Name;
 
            lock (this.subscriptionsByServiceAndNodeAndJid)
            {
                if (this.subscriptionsByServiceAndNodeAndJid.TryGetValue(Service, out Dictionary<CaseInsensitiveString, Dictionary<CaseInsensitiveString, Subscription>> List2) &&
                    List2.TryGetValue(NodeName, out List))
                {
                    List2.Remove(NodeName);
                }
                else
                    List = null;
            }
 
            if (!(List is null))
            {
                foreach (Subscription Subscription in List.Values)
                {
                    await Database.DeleteLazy(Subscription);
                    await this.NotifySubscriptionChanged(Subscription, FromBareJid);
                }
            }
            else
            {
                foreach (Subscription Subscription in await Database.FindDelete<Subscription>(new FilterAnd(
                    new FilterFieldEqualTo("Service", Service), new FilterFieldEqualTo("Node", NodeName))))
                {
                    await this.NotifySubscriptionChanged(Subscription, FromBareJid);
                }
            }
 
            await Database.DeleteLazy(Node);
 
            lock (this.nodesByServiceAndName)
            {
                if (this.nodesByServiceAndName.TryGetValue(Service, out Nodes Nodes))
                {
                    Nodes.NodesByName.Remove(NodeName);
 
                    Nodes.NodesArray = new PubSubNode[Nodes.NodesByName.Count];
                    Nodes.NodesByName.Values.CopyTo(Nodes.NodesArray, 0);
                }
            }
 
            await Database.FindDelete<PubSubItem>(new FilterAnd(new FilterFieldEqualTo("Service", Service),
                new FilterFieldEqualTo("Node", NodeName)));
        }
 
        private async Task NotifySubscriptionChanged(Subscription Subscription, XmppAddress FromBareJid)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<event xmlns='");
            Xml.Append(NamespacePubSubEvents);
            Xml.Append("'><subscription node='");
            Xml.Append(XML.Encode(Subscription.Node));
            Xml.Append("' jid='");
            Xml.Append(XML.Encode(Subscription.Jid));
            Xml.Append("' subscription='");
            Xml.Append(Subscription.Status.ToString());
            Xml.Append("'/></event>");
 
            await this.Server.SendMessage(string.Empty,
                Guid.NewGuid().ToString().Replace("-", string.Empty),
                FromBareJid, new XmppAddress(Subscription.Jid),
                string.Empty, Xml.ToString());
        }
 
        private async Task NotifyAffiliationChanged(CaseInsensitiveString Node, CaseInsensitiveString Jid, AffiliationStatus Affiliation, XmppAddress FromBareJid)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<event xmlns='");
            Xml.Append(NamespacePubSubEvents);
            Xml.Append("'><affiliations node='");
            Xml.Append(XML.Encode(Node));
            Xml.Append("'><affiliation jid='");
            Xml.Append(XML.Encode(Jid));
            Xml.Append("' affiliation='");
            Xml.Append(ToString(Affiliation));
            Xml.Append("'/></affiliations></event>");
 
            await this.Server.SendMessage(string.Empty,
                Guid.NewGuid().ToString().Replace("-", string.Empty),
                FromBareJid, new XmppAddress(Jid),
                string.Empty, Xml.ToString());
        }
 
        private async Task<bool> ConfigureNode(XmlElement E, PubSubNode Node, IqEventArgs e)
        {
            foreach (XmlNode N2 in E.ChildNodes)
            {
                if (N2 is XmlElement E2 && E2.LocalName == "x" && E2.NamespaceURI == Networking.XMPP.XmppClient.NamespaceData)
                {
                    DataForm Form = new DataForm(null, E2, null, null, e.From.Address, e.To.Address);
 
                    if (Form.Type == FormType.Submit)
                    {
                        switch (Form["FORM_TYPE"]?.ValueString)
                        {
                            case FormTypeNodeConfig:
                                if (Node is null)
                                {
                                    await e.IqErrorBadRequest(e.To, "No node defined.", "en");
                                    return false;
                                }
 
                                if (!await Node.CanConfigureNode(e.From.BareJid))
                                {
                                    await e.IqErrorForbidden(e.To, "Not authorized to configure node.", "en");
                                    return false;
                                }
 
                                foreach (Field F in Form.Fields)
                                {
                                    switch (F.Var)
                                    {
                                        case "FORM_TYPE":
                                            break;
 
                                        case "pubsub#access_model":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (Enum.TryParse<NodeAccessModel>(F.ValueString, out NodeAccessModel AccessModel))
                                                    Node.AccessModel = AccessModel;
                                                else
                                                {
                                                    await e.IqError("modify", "<not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
                                                        "<unsupported-access-model xmlns='http://jabber.org/protocol/pubsub#errors'/>",
                                                        e.To, "Access model not supported.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#body_xslt":
                                            Node.BodyXsltUrl = F.ValueString;
                                            break;
 
                                        case "pubsub#collection":
                                            Node.Collections = CheckEmpty(F.ValueStrings.ToCaseInsensitiveStringArray());
                                            Node.IsRoot = (Node.Collections is null || Node.Collections.Length == 0);
                                            break;
 
                                        case "pubsub#contact":
                                            Node.Contact = CheckEmpty(F.ValueStrings.ToCaseInsensitiveStringArray());
                                            break;
 
                                        case "pubsub#dataform_xslt":
                                            Node.DataFormXsltUrl = F.ValueString;
                                            break;
 
                                        case "pubsub#deliver_notifications":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (CommonTypes.TryParse(F.ValueString, out bool b))
                                                    Node.DeliverNotifications = b;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported delivery notification.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#deliver_payloads":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (CommonTypes.TryParse(F.ValueString, out bool b))
                                                    Node.DeliverPayloads = b;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported payload delivery.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#itemreply":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (Enum.TryParse(F.ValueString, out NodeItemReply ItemReply))
                                                    Node.ItemReply = ItemReply;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported reply mode.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#children_association_policy":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (Enum.TryParse(F.ValueString, out NodeChildAssociationPolicy ChildAssociationPolicy))
                                                    Node.ChildAssociationPolicy = ChildAssociationPolicy;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported child association policy.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#children_association_whitelist":
                                            Node.ChildAssociationWhitelist = CheckEmpty(F.ValueStrings.ToCaseInsensitiveStringArray());
                                            break;
 
                                        case "pubsub#children":
                                            Node.Children = CheckEmpty(F.ValueStrings.ToCaseInsensitiveStringArray());
                                            break;
 
                                        case "pubsub#children_max":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (int.TryParse(F.ValueString, out int i) && i > 0)
                                                    Node.MaxChildren = i;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Invalid maximum number of children.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#max_items":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (int.TryParse(F.ValueString, out int i) && i > 0)
                                                    Node.MaxItems = i;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Invalid maximum number of items.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#item_expire":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (int.TryParse(F.ValueString, out int i) && i > 0)
                                                    Node.ItemExpireSeconds = i;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Invalid item expiry time.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#node_expire":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (XML.TryParse(F.ValueString, out DateTime TP) && TP >= DateTime.Today)
                                                    Node.Expires = TP;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Invalid note expiry date.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#max_payload_size":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (int.TryParse(F.ValueString, out int i) && i > 0)
                                                    Node.MaxPayloadSize = i;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Invalid maximum payload size.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#node_type":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (Enum.TryParse(F.ValueString, out NodeType NodeType))
                                                    Node.NodeType = NodeType;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported node type.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#notify_config":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (CommonTypes.TryParse(F.ValueString, out bool b))
                                                    Node.NotifyConfig = b;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported configuration notification.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#notify_delete":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (CommonTypes.TryParse(F.ValueString, out bool b))
                                                    Node.NotifyDelete = b;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported delete notification.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#notify_retract":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (CommonTypes.TryParse(F.ValueString, out bool b))
                                                    Node.NotifyRetract = b;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported retraction notification.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#notify_sub":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (CommonTypes.TryParse(F.ValueString, out bool b))
                                                    Node.NotifySubscriptions = b;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported subscription notification.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#persist_items":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (CommonTypes.TryParse(F.ValueString, out bool b))
                                                    Node.PersistItems = b;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported items persistence.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#presence_based_delivery":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (CommonTypes.TryParse(F.ValueString, out bool b))
                                                    Node.PresenceBasedDelivery = b;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported presence based delivery.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#publish_model":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (Enum.TryParse<PublisherModel>(F.ValueString, out PublisherModel PublisherModel))
                                                    Node.PublisherModel = PublisherModel;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported publisher model.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#replyroom":
                                            Node.ReplyRooms = CheckEmpty(F.ValueStrings.ToCaseInsensitiveStringArray());
                                            break;
 
                                        case "pubsub#replyto":
                                            Node.ReplyTo = CheckEmpty(F.ValueStrings.ToCaseInsensitiveStringArray());
                                            break;
 
                                        case "pubsub#roster_groups_allowed":
                                            Node.RosterGroupsAllowed = CheckEmpty(F.ValueStrings);
                                            break;
 
                                        case "pubsub#send_last_published_item":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (Enum.TryParse<SendLastPublishedItem>(F.ValueString, out SendLastPublishedItem SendLastPublishedItem))
                                                    Node.SendLastPublishedItem = SendLastPublishedItem;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported send last published item.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#subscribe":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (CommonTypes.TryParse(F.ValueString, out bool b))
                                                    Node.AllowSubscriptions = b;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported subscription allowance.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#title":
                                            Node.Title = F.ValueString;
                                            break;
 
                                        case "pubsub#description":
                                            Node.Description = CheckEmpty(F.ValueStrings);
                                            break;
 
                                        case "pubsub#language":
                                            Node.Language = F.ValueString;
                                            break;
 
                                        case "pubsub#type":
                                            Node.PayloadType = F.ValueString;
                                            break;
 
                                        case "pubsub#notification_type":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (Enum.TryParse<NotificationType>(F.ValueString, out NotificationType NotificationType))
                                                    Node.NotificationType = NotificationType;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported notification type.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        case "pubsub#purge_offline":
                                            if (!string.IsNullOrEmpty(F.ValueString))
                                            {
                                                if (CommonTypes.TryParse(F.ValueString, out bool b))
                                                    Node.PurgeOffline = b;
                                                else
                                                {
                                                    await e.IqErrorBadRequest(e.To, "Unsupported offline purge.", "en");
                                                    return false;
                                                }
                                            }
                                            break;
 
                                        default:
                                            await e.IqErrorBadRequest(e.To, "Unsupported form field.", "en");
                                            return false;
                                    }
                                }
                                
                                return true;
 
                            default:
                                await e.IqErrorBadRequest(e.To, "Unrecognized FORM_TYPE.", "en");
                                return false;
                        }
                    }
                    else if (Form.Type == FormType.Cancel)
                    {
                        await e.IqResult(string.Empty, e.To);
                        return false;
                    }
                    else
                    {
                        await e.IqErrorBadRequest(e.To, "Unexpected form type.", "en");
                        return false;
                    }
                }
                else
                {
                    await e.IqErrorBadRequest(e.To, "Unrecognized element.", "en");
                    return false;
                }
            }
 
            await e.IqErrorBadRequest(e.To, "Missing form.", "en");
            return false;
        }
 
        private static CaseInsensitiveString[] CheckEmpty(CaseInsensitiveString[] Array)
        {
            if (!(Array is null) && Array.Length == 1 && CaseInsensitiveString.IsNullOrEmpty(Array[0]))
                return new CaseInsensitiveString[0];
            else
                return Array;
        }
 
        private static string[] CheckEmpty(string[] Array)
        {
            if (!(Array is null) && Array.Length == 1 && string.IsNullOrEmpty(Array[0]))
                return new string[0];
            else
                return Array;
        }
 
        private async Task<bool> ConfigureSubscription(XmlElement E, Subscription Subscription, IqEventArgs e)
        {
            foreach (XmlNode N2 in E.ChildNodes)
            {
                if (N2 is XmlElement E2 && E2.LocalName == "x" && E2.NamespaceURI == Networking.XMPP.XmppClient.NamespaceData)
                {
                    DataForm Form = new DataForm(null, E2, null, null, e.From.Address, e.To.Address);
 
                    if (Form.Type == FormType.Submit)
                    {
                        switch (Form["FORM_TYPE"]?.ValueString)
                        {
                            case FormTypeSubscribeOptions:
                                foreach (Field F in Form.Fields)
                                {
                                    switch (F.Var)
                                    {
                                        case "FORM_TYPE":
                                            break;
 
                                        case "pubsub#deliver":
                                            if (CommonTypes.TryParse(F.ValueString, out bool b))
                                                Subscription.Deliver = b;
                                            else
                                            {
                                                await e.IqErrorBadRequest(e.To, "Unsupported delivery value.", "en");
                                                return false;
                                            }
                                            break;
 
                                        case "pubsub#digest":
                                            if (CommonTypes.TryParse(F.ValueString, out b))
                                                Subscription.Digest = b;
                                            else
                                            {
                                                await e.IqErrorBadRequest(e.To, "Unsupported digest value.", "en");
                                                return false;
                                            }
                                            break;
 
                                        case "pubsub#include_body":
                                            if (CommonTypes.TryParse(F.ValueString, out b))
                                                Subscription.IncludeBody = b;
                                            else
                                            {
                                                await e.IqErrorBadRequest(e.To, "Unsupported inclusion value.", "en");
                                                return false;
                                            }
                                            break;
 
                                        case "pubsub#digest_frequency":
                                            if (int.TryParse(F.ValueString, out int i))
                                                Subscription.DigestFrequencyMilliseconds = i;
                                            else
                                            {
                                                await e.IqErrorBadRequest(e.To, "Invalid digest frequency.", "en");
                                                return false;
                                            }
                                            break;
 
                                        case "pubsub#expire":
                                            if (XML.TryParse(F.ValueString, out DateTime TP))
                                                Subscription.Expires = TP;
                                            else if (DateTime.TryParse(F.ValueString, out TP))
                                                Subscription.Expires = TP;
                                            else
                                            {
                                                await e.IqErrorBadRequest(e.To, "Invalid expiry date and time.", "en");
                                                return false;
                                            }
                                            break;
 
                                        case "pubsub#subscription_type":
                                            if (Enum.TryParse(F.ValueString, out SubscriptionType SubscriptionType))
                                                Subscription.Type = SubscriptionType;
                                            else
                                            {
                                                await e.IqErrorNotAcceptable(e.To, "Unsupported subscription type.", "en");
                                                return false;
                                            }
                                            break;
 
                                        case "pubsub#subscription_depth":
                                            if (F.ValueString == "1")
                                                Subscription.Depth = SubscriptonDepth.one;
                                            else if (Enum.TryParse(F.ValueString, out SubscriptonDepth SubscriptonDepth))
                                                Subscription.Depth = SubscriptonDepth;
                                            else
                                            {
                                                await e.IqErrorNotAcceptable(e.To, "Unsupported subscription depth.", "en");
                                                return false;
                                            }
                                            break;
 
                                        default:
                                            await e.IqErrorNotAcceptable(e.To, "Unsupported form field.", "en");
                                            return false;
                                    }
                                }
 
                                return true;
 
                            default:
                                await e.IqErrorBadRequest(e.To, "Unrecognized FORM_TYPE.", "en");
                                return false;
                        }
                    }
                    else if (Form.Type == FormType.Cancel)
                    {
                        await e.IqResult(string.Empty, e.To);
                        return false;
                    }
                    else
                    {
                        await e.IqErrorBadRequest(e.To, "Unexpected form type.", "en");
                        return false;
                    }
                }
                else
                {
                    await e.IqErrorBadRequest(e.To, "Unrecognized element.", "en");
                    return false;
                }
            }
 
            await e.IqErrorBadRequest(e.To, "Missing form.", "en");
            return false;
        }
 
        internal static bool IsOwnerOfBroker(CaseInsensitiveString BareJid)
        {
            return !(provisioningClient is null) && provisioningClient.OwnerJid == BareJid;
        }
 
        private Task MessageFormHandler(object Sender, MessageEventArgs e)
        {
            return this.MessageFormHandler(string.Empty, e, pubSubFeatures);
        }
 
        private Task PepMessageFormHandler(object Sender, MessageEventArgs e)
        {
            return this.MessageFormHandler((e.To.IsEmpty ? e.From : e.To).BareJid, e, pepFeatures);
        }
 
        private async Task MessageFormHandler(CaseInsensitiveString Service, MessageEventArgs e, DefaultFeatures _)
        {
            XmppAddress FromBareJid = CaseInsensitiveString.IsNullOrEmpty(Service) ? e.To : e.From.ToBareJID();
            DataForm Form = new DataForm(null, e.Content, null, null, e.From.Address, e.To.Address);
            Field FormTypeField = Form["FORM_TYPE"];
            if (FormTypeField is null)
                return;
 
            switch (FormTypeField.ValueString)
            {
                case FormTypeSubscriptionAuthorization:
                    if (Form.Type != FormType.Submit)
                        break;
 
                    string SubscriptionId = Form["pubsub#subid"]?.ValueString ?? string.Empty;
                    CaseInsensitiveString NodeName = Form["pubsub#node"]?.ValueString ?? string.Empty;
                    CaseInsensitiveString Jid = Form["pubsub#subscriber_jid"]?.ValueString ?? string.Empty;
 
                    if (!CommonTypes.TryParse(Form["pubsub#allow"]?.ValueString ?? string.Empty, out bool Allow))
                        break;
 
                    Subscription Subscription = await this.GetSubscriptionAsync(Service, NodeName, Jid);
                    if (Subscription is null ||
                        Subscription.ObjectId != SubscriptionId ||
                        Subscription.Node != NodeName ||
                        Subscription.Jid != Jid)
                    {
                        break;
                    }
 
                    PubSubNode Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                    if (Node is null)
                        break;
 
                    if (Node.Creator != e.From.BareJid)
                        break;
 
                    if (Allow)
                        Subscription.Status = NodeSubscriptionStatus.subscribed;
                    else
                        Subscription.Status = NodeSubscriptionStatus.none;
 
                    await Database.UpdateLazy(Subscription);
                    await this.NotifySubscriptionChanged(Subscription, FromBareJid);
 
                    if (Subscription.Status == NodeSubscriptionStatus.subscribed &&
                        Node.SendLastPublishedItem != SendLastPublishedItem.never)
                    {
                        await this.SendLastItem(Service, Node, Subscription.Jid, FromBareJid, e.Language);
                    }
                    break;
            }
        }
 
        protected override Task DiscoveryQueryGet(object Sender, IqEventArgs e)
        {
            return this.DiscoveryQueryGet(Sender, string.Empty, e, pubSubFeatures);
        }
 
        private Task PepDiscoveryQueryGet(object Sender, IqEventArgs e)
        {
            return this.DiscoveryQueryGet(Sender, (e.To.IsEmpty ? e.From : e.To).BareJid, e, pepFeatures);
        }
 
        private Task PepDiscoverIdentities(object Sender, StringBuilder sb)
        {
            sb.Append("<identity category='pubsub' type='pep'/>");
            return Task.CompletedTask;
        }
 
        private async Task DiscoveryQueryGet(object Sender, CaseInsensitiveString Service, IqEventArgs e, DefaultFeatures _)
        {
            XmlElement E = e.Query;
            string NodeName = XML.Attribute(E, "node");
            if (string.IsNullOrEmpty(NodeName))
                await base.DiscoveryQueryGet(Sender, e);
            else
            {
                PubSubNode Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
                if (Node is null)
                    await e.IqErrorItemNotFound(e.To, "Node not found", "en");
                else
                {
                    StringBuilder Xml = new StringBuilder();
 
                    Xml.Append("<query xmlns='");
                    Xml.Append(XmppServer.DiscoveryNamespace);
                    Xml.Append("' node='");
                    Xml.Append(XML.Encode(NodeName));
                    Xml.Append("'><identity category='pubsub' type='");
                    Xml.Append(Node.NodeType.ToString());
 
                    if (!string.IsNullOrEmpty(Node.Title))
                    {
                        Xml.Append("' name='");
                        Xml.Append(XML.Encode(Node.Title));
                    }
                    Xml.Append("'/>");
 
                    int NrSubscribers = 0;
 
                    foreach (Subscription Subscription in await this.GetSubscriptionsOnNode(Service, NodeName))
                    {
                        if (Subscription.Status == NodeSubscriptionStatus.subscribed)
                            NrSubscribers++;
                    }
 
                    DataForm Form = new DataForm(null, FormType.Result, e.To.Address, e.From.Address,
                        new HiddenField("FORM_TYPE", FormTypeNodeMetaData),
                        new TextSingleField("pubsub#type", "Payload type", Node.PayloadType),
                        new JidSingleField("pubsub#creator", "Node creator", Node.Creator),
                        new TextSingleField("pubsub#creation_date", "Creation date", XML.Encode(Node.Created)),
                        new TextSingleField("pubsub#title", "A short name for the node", Node.Title),
                        new TextMultiField("pubsub#description", "A description of the node", Node.Description),
                        new ListSingleField("pubsub#language", "Default language", Node.Language),
                        new JidMultiField("pubsub#contact", "People to contact with questions", Node.Contact.ToStringArray()),
                        new TextSingleField("pubsub#max_items", "Max # of items to persist", Node.MaxItems.ToString()),
                        new JidMultiField("pubsub#owner", "Node owners", Node.Owners.ToStringArray()),
                        new JidMultiField("pubsub#publisher", "Publishers to this node", Node.Publishers.ToStringArray()),
                        new TextSingleField("pubsub#num_subscribers", "Number of subscribers to this node", NrSubscribers.ToString()));
 
                    Form.SerializeResult(Xml);
                    Xml.Append("</query>");
 
                    await e.IqResult(Xml.ToString(), e.To);
                }
            }
        }
 
        protected override Task AppendServiceDiscoveryIdentities(StringBuilder Xml, IqEventArgs e, string Node)
        {
            Xml.Append("<identity category='pubsub' type='service' name='Publish/Subscribe service' />");
            return Task.CompletedTask;
        }
 
        protected override Task DiscoveryQueryItemsGet(object Sender, IqEventArgs e)
        {
            return this.DiscoveryQueryItemsGet(string.Empty, e, pubSubFeatures);
        }
 
        private Task PepDiscoveryQueryItemsGet(object Sender, IqEventArgs e)
        {
            return this.DiscoveryQueryItemsGet((e.To.IsEmpty ? e.From : e.To).BareJid, e, pepFeatures);
        }
 
        private async Task DiscoveryQueryItemsGet(CaseInsensitiveString Service, IqEventArgs e, DefaultFeatures _)
        {
            XmlElement E = e.Query;
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<query xmlns='");
            Xml.Append(XmppServer.DiscoveryItemsNamespace);
 
            if (E.HasAttribute("node"))
            {
                string NodeName = XML.Attribute(E, "node");
                PubSubNode Node = await this.GetNodeAsync(Service, NodeName, null, e.From, e.To.Address);
 
                if (Node is null)
                {
                    await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                    return;
                }
 
                Xml.Append("' node='");
                Xml.Append(XML.Encode(NodeName));
                Xml.Append("'>");
 
                switch (Node.NodeType)
                {
                    case NodeType.collection:
                        if (!(Node.Children is null))
                        {
                            foreach (string Child in Node.Children)
                            {
                                PubSubNode Node2 = await this.GetNodeAsync(Service, Child, null, e.From, e.To.Address);
                                if (Node2 is null)
                                    continue;
 
                                Xml.Append("<item jid='");
                                Xml.Append(XML.Encode(e.To.Address));
                                Xml.Append("' node='");
                                Xml.Append(XML.Encode(Node2.Name));
 
                                if (!string.IsNullOrEmpty(Node2.Title))
                                {
                                    Xml.Append("' name='");
                                    Xml.Append(XML.Encode(Node2.Title));
                                }
 
                                Xml.Append("'/>");
                            }
                        }
                        break;
 
                    case NodeType.leaf:
                        IEnumerable<PubSubItem> Items = await Database.Find<PubSubItem>(new FilterAnd(
                            new FilterFieldEqualTo("Service", Service), new FilterFieldEqualTo("Node", NodeName)), "-Service", "-Node", "-Created");
                        foreach (PubSubItem Item in Items)
                        {
                            Xml.Append("<item jid='");
                            Xml.Append(XML.Encode(e.To.Address));
                            Xml.Append("' name='");
                            Xml.Append(XML.Encode(Item.ItemIdOrObjectId));
                            Xml.Append("'/>");
                        }
                        break;
                }
            }
            else
            {
                Xml.Append("'>");
 
                foreach (PubSubNode Node in await Database.Find<PubSubNode>(new FilterAnd(
                    new FilterFieldEqualTo("Service", Service), new FilterFieldEqualTo("IsRoot", true)), "Name"))
                {
                    Xml.Append("<item jid='");
                    Xml.Append(XML.Encode(e.To.Address));
                    Xml.Append("' node='");
                    Xml.Append(XML.Encode(Node.Name));
 
                    if (!string.IsNullOrEmpty(Node.Title))
                    {
                        Xml.Append("' name='");
                        Xml.Append(XML.Encode(Node.Title));
                    }
 
                    Xml.Append("'/>");
                }
            }
 
            Xml.Append("</query>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private async Task Server_OnPresenceLocalRecipient(object Sender, PresenceEventArgs e)
        {
            try
            {
                switch (e.Type)
                {
                    case "":
                        string NodeVer = null;
 
                        foreach (XmlNode N in e.Stanza.StanzaElement.ChildNodes)
                        {
                            if (N is XmlElement E &&
                                E.LocalName == "c" &&
                                E.NamespaceURI == "http://jabber.org/protocol/caps")
                            {
                                string Node = XML.Attribute(E, "node");
                                string Version = XML.Attribute(E, "ver");
 
                                NodeVer = Node + "#" + Version;
                                break;
                            }
                        }
 
                        if (NodeVer is null)
                            await this.SendLast(e.To, e.From, e.Language);
                        else
                        {
                            lock (this.nodeVerByFullJidByBareJid)
                            {
                                if (!this.nodeVerByFullJidByBareJid.TryGetValue(e.From.BareJid,
                                    out NodeVerInfo NodeVerInfo))
                                {
                                    NodeVerInfo = new NodeVerInfo()
                                    {
                                        NodeVerPerFullJid = new Dictionary<CaseInsensitiveString, string>()
                                    };
 
                                    this.nodeVerByFullJidByBareJid[e.From.BareJid] = NodeVerInfo;
                                }
 
                                NodeVerInfo.NodeVerPerFullJid[e.From.Address] = NodeVer;
                                NodeVerInfo.UpdateStaticLocked();
                            }
 
                            if (this.featuresByNodeVer.ContainsKey(NodeVer))
                                await this.SendLast(e.To, e.From, e.Language);
                            else
                            {
                                await this.Server.SendIqRequest("get", e.To, e.From, e.Language,
                                    "<query xmlns='" + XmppServer.DiscoveryNamespace + "' node='" +
                                    NodeVer + "'/>", async (sender2, e2) =>
                                    {
                                        try
                                        {
                                            XmlElement E2;
 
                                            if (e2.Ok &&
                                                !((E2 = e2.FirstElement) is null) &&
                                                E2.LocalName == "query" &&
                                                E2.NamespaceURI == XmppServer.DiscoveryNamespace &&
                                                XML.Attribute(E2, "node") == NodeVer)
                                            {
                                                Dictionary<string, bool> Features = new Dictionary<string, bool>();
 
                                                foreach (XmlNode N in E2.ChildNodes)
                                                {
                                                    if (N is XmlElement E3 && E3.LocalName == "feature")
                                                        Features[XML.Attribute(E3, "var")] = true;
                                                }
 
                                                this.featuresByNodeVer[NodeVer] = Features;
 
                                                await this.SendLast(e.From, e.To, e.Language);
                                            }
                                            else
                                                await this.SendLast(e.From, e.To, e.Language);
                                        }
                                        catch (Exception ex)
                                        {
                                            Log.Exception(ex);
                                        }
                                    }, null);
                            }
                        }
                        break;
 
                    case "subscribed":
                        await this.SendLast(e.From, e.To, e.Language);
                        break;
 
                    case "unavailable":
                        lock (this.nodeVerByFullJidByBareJid)
                        {
                            if (this.nodeVerByFullJidByBareJid.TryGetValue(e.From.BareJid,
                                out NodeVerInfo NodeVerInfo) &&
                                NodeVerInfo.NodeVerPerFullJid.Remove(e.From.Address))
                            {
                                if (NodeVerInfo.NodeVerPerFullJid.Count == 0)
                                    this.nodeVerByFullJidByBareJid.Remove(e.From.BareJid);
                                else
                                    NodeVerInfo.UpdateStaticLocked();
                            }
                        }
                        break;
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private async Task SendLast(XmppAddress Publisher, XmppAddress Subscriber, string Language)
        {
            string SubscriberBareJid = Subscriber.BareJid;
            IRosterItem RosterItem = await XmppServerModule.GetRosterItemAsync(Publisher.Account, SubscriberBareJid);
            if (RosterItem is null || (RosterItem.Subscription != SubscriptionStatus.both && RosterItem.Subscription != SubscriptionStatus.from))
                return;
 
            PubSubNode[] NodeArray = null;
            Nodes Nodes;
            XmppAddress FromBareJid = Publisher.ToBareJID();
            CaseInsensitiveString Service = FromBareJid.Address;
 
            lock (this.nodesByServiceAndName)
            {
                if (this.nodesByServiceAndName.TryGetValue(Service, out Nodes))
                    NodeArray = Nodes.NodesArray;
                else
                    Nodes = null;
            }
 
            if (Nodes is null)
            {
                await this.GetNodeAsync(Service, string.Empty, null, Publisher.ToBareJID(), null);    // Loads available nodes
 
                lock (this.nodesByServiceAndName)
                {
                    if (!this.nodesByServiceAndName.TryGetValue(Service, out Nodes))
                        return;
 
                    NodeArray = Nodes.NodesArray;
                }
            }
 
            foreach (PubSubNode Node in NodeArray)
            {
                if (Node.AutoSubscribe && Node.AccessModel == NodeAccessModel.presence)
                {
                    CaseInsensitiveString[] Jids = this.FilterNotifiations(Subscriber, Node);
                    if (Jids is null)
                        continue;
 
                    foreach (CaseInsensitiveString Jid in Jids)
                        await this.SendLastItem(Service, Node, Jid, FromBareJid, Language);
                }
            }
        }
 
        private CaseInsensitiveString[] FilterNotifiations(XmppAddress Jid, PubSubNode Node)
        {
            CaseInsensitiveString BareJid = Jid.BareJid;
            KeyValuePair<CaseInsensitiveString, string>[] NodeVerPerFullJid;
 
            lock (this.nodeVerByFullJidByBareJid)
            {
                if (!this.nodeVerByFullJidByBareJid.TryGetValue(BareJid, out NodeVerInfo NodeVerInfo))
                    return new CaseInsensitiveString[] { BareJid };
 
                NodeVerPerFullJid = NodeVerInfo.NodeVerPerFullJidStatic;
            }
 
            string Feature = Node.Name + "+notify";
            List<CaseInsensitiveString> FullJids = null;
 
            foreach (KeyValuePair<CaseInsensitiveString, string> P in NodeVerPerFullJid)
            {
                if (!this.featuresByNodeVer.TryGetValue(P.Value, out Dictionary<string, bool> Features))
                    continue;
 
                if (!Features.ContainsKey(Feature))
                    continue;
 
                if (FullJids is null)
                    FullJids = new List<CaseInsensitiveString>();
 
                FullJids.Add(P.Key);
            }
 
            return FullJids?.ToArray();
        }
 
        private class NodeVerInfo
        {
            public Dictionary<CaseInsensitiveString, string> NodeVerPerFullJid;
            public KeyValuePair<CaseInsensitiveString, string>[] NodeVerPerFullJidStatic;
 
            public void UpdateStaticLocked()
            {
                int i = 0;
 
                this.NodeVerPerFullJidStatic = new KeyValuePair<CaseInsensitiveString, string>[this.NodeVerPerFullJid.Count];
 
                foreach (KeyValuePair<CaseInsensitiveString, string> P in this.NodeVerPerFullJid)
                    this.NodeVerPerFullJidStatic[i++] = P;
            }
        }
 
        public async Task<(int, int)> DeleteExpiredNodes()
        {
            int NrNodes = 0;
            int NrItems = 0;
 
            foreach (PubSubNode Node in await Database.FindDelete<PubSubNode>(new FilterFieldLesserThan("Expires", DateTime.Today.AddDays(-1))))
            {
                NrNodes++;
 
                foreach (PubSubItem Item in await Database.FindDelete<PubSubItem>(new FilterAnd(
                    new FilterFieldEqualTo("Service", Node.Service),
                    new FilterFieldEqualTo("Node", Node.Name))))
                {
                    NrItems++;
                }
            }
 
            return (NrNodes, NrItems);
        }
 
 
        // TODO: Delete expired subscriptions
        // TODO: Delete expired items
    }
}