Component.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Persistence;
using Waher.Runtime.Counters;
 
namespace Waher.Networking.XMPP.Server
{
    public class Component : IComponent, ISender
    {
        protected SortedDictionary<string, bool> features = new SortedDictionary<string, bool>();
 
        protected readonly object synchObject = new object();
 
        private readonly Dictionary<string, EventHandlerAsync<IqEventArgs>> iqGetHandlers = new Dictionary<string, EventHandlerAsync<IqEventArgs>>();
        private readonly Dictionary<string, EventHandlerAsync<IqEventArgs>> iqSetHandlers = new Dictionary<string, EventHandlerAsync<IqEventArgs>>();
        private readonly Dictionary<string, EventHandlerAsync<MessageEventArgs>> messageHandlers = new Dictionary<string, EventHandlerAsync<MessageEventArgs>>();
        private readonly Dictionary<string, EventHandlerAsync<PresenceEventArgs>> presenceHandlers = new Dictionary<string, EventHandlerAsync<PresenceEventArgs>>();
        private readonly IqResponses responses = new IqResponses(TimeSpan.FromMinutes(1), TimeSpan.FromSeconds(10));
        private readonly XmppServer server;
        private readonly CaseInsensitiveString subdomain;
        private readonly CaseInsensitiveString subdomainSuffixed;
        private readonly XmppAddress mainDomain;
        private readonly string name;
 
        public Component(XmppServer Server, string Subdomain, string Name)
            : this(Server, (CaseInsensitiveString)Subdomain, Name)
        {
        }
 
        public Component(XmppServer Server, CaseInsensitiveString Subdomain, string Name)
        {
            this.subdomain = Subdomain;
            this.subdomainSuffixed = Subdomain + ".";
            this.name = Name;
            this.server = Server;
            this.mainDomain = new XmppAddress(this.subdomainSuffixed + this.server.Domain);
 
            if (!string.IsNullOrEmpty(Subdomain) && !(this.server is null))
            {
                if (!this.server.RegisterComponent(this))
                    throw new InvalidOperationException("A component with subdomain " + Subdomain + " has already been registered.");
            }
 
            this.RegisterIqGetHandler("query", XmppServer.DiscoveryNamespace, this.DiscoveryQueryGet, true);   // XEP-0030
            this.RegisterIqGetHandler("query", XmppServer.DiscoveryItemsNamespace, this.DiscoveryQueryItemsGet, true);   // XEP-0030
        }
 
        public CaseInsensitiveString Subdomain => this.subdomain;
 
        public CaseInsensitiveString SubdomainSuffixed => this.subdomainSuffixed;
 
        public XmppAddress MainDomain => this.mainDomain;
 
        public string Name => this.name;
 
        public XmppServer Server => this.server;
 
        public virtual void Dispose()
        {
            if (!string.IsNullOrEmpty(this.subdomain) && !(this.server is null))
                this.server.UnregisterComponent(this);
 
            this.UnregisterIqGetHandler("query", XmppServer.DiscoveryNamespace, this.DiscoveryQueryGet, true);   // XEP-0030
 
            this.responses.Dispose();
        }
 
        public virtual bool SupportsAccounts => false;
 
        public bool IsComponentDomain(CaseInsensitiveString Domain, bool IncludeAlternativeDomains)
        {
            if (Domain == this.subdomainSuffixed + this.server.Domain)
                return true;
 
            if (IncludeAlternativeDomains && !(this.server.AlternativeDomains is null))
            {
                foreach (CaseInsensitiveString s in this.server.AlternativeDomains)
                {
                    if (Domain == this.subdomainSuffixed + s)
                        return true;
                }
            }
 
            return false;
        }
 
        #region Stanzas
 
        public void RegisterIqGetHandler(string LocalName, string Namespace, EventHandlerAsync<IqEventArgs> Handler, bool PublishNamespaceAsFeature)
        {
            this.RegisterIqHandler(this.iqGetHandlers, LocalName, Namespace, Handler, PublishNamespaceAsFeature);
        }
 
        public void RegisterIqSetHandler(string LocalName, string Namespace, EventHandlerAsync<IqEventArgs> Handler, bool PublishNamespaceAsFeature)
        {
            this.RegisterIqHandler(this.iqSetHandlers, LocalName, Namespace, Handler, PublishNamespaceAsFeature);
        }
 
        private void RegisterIqHandler(Dictionary<string, EventHandlerAsync<IqEventArgs>> Handlers, string LocalName, string Namespace, EventHandlerAsync<IqEventArgs> Handler,
            bool PublishNamespaceAsFeature)
        {
            string Key = LocalName + " " + Namespace;
 
            lock (this.synchObject)
            {
                if (Handlers.ContainsKey(Key))
                    throw new ArgumentException("Handler already registered.", nameof(LocalName));
 
                Handlers[Key] = Handler;
 
                if (PublishNamespaceAsFeature)
                    this.features[Namespace] = true;
            }
        }
 
        public void RegisterMessageHandler(string LocalName, string Namespace, EventHandlerAsync<MessageEventArgs> Handler, bool PublishNamespaceAsFeature)
        {
            string Key = LocalName + " " + Namespace;
 
            lock (this.synchObject)
            {
                if (this.messageHandlers.ContainsKey(Key))
                    throw new ArgumentException("Handler already registered.", nameof(LocalName));
 
                this.messageHandlers[Key] = Handler;
 
                if (PublishNamespaceAsFeature)
                    this.features[Namespace] = true;
            }
        }
 
        public void RegisterPresenceHandler(string LocalName, string Namespace, EventHandlerAsync<PresenceEventArgs> Handler, bool PublishNamespaceAsFeature)
        {
            string Key = LocalName + " " + Namespace;
 
            lock (this.synchObject)
            {
                if (this.presenceHandlers.ContainsKey(Key))
                    throw new ArgumentException("Handler already registered.", nameof(LocalName));
 
                this.presenceHandlers[Key] = Handler;
 
                if (PublishNamespaceAsFeature)
                    this.features[Namespace] = true;
            }
        }
 
        public void RegisterFeature(string Namespace)
        {
            lock (this.synchObject)
            {
                this.features[Namespace] = true;
            }
        }
 
        public bool UnregisterIqGetHandler(string LocalName, string Namespace, EventHandlerAsync<IqEventArgs> Handler, bool RemoveNamespaceAsFeature)
        {
            return this.UnregisterIqHandler(this.iqGetHandlers, LocalName, Namespace, Handler, RemoveNamespaceAsFeature);
        }
 
        public bool UnregisterIqSetHandler(string LocalName, string Namespace, EventHandlerAsync<IqEventArgs> Handler, bool RemoveNamespaceAsFeature)
        {
            return this.UnregisterIqHandler(this.iqSetHandlers, LocalName, Namespace, Handler, RemoveNamespaceAsFeature);
        }
 
        private bool UnregisterIqHandler(Dictionary<string, EventHandlerAsync<IqEventArgs>> Handlers, string LocalName, string Namespace, EventHandlerAsync<IqEventArgs> Handler,
            bool RemoveNamespaceAsFeature)
        {
            string Key = LocalName + " " + Namespace;
 
            lock (this.synchObject)
            {
                if (!Handlers.TryGetValue(Key, out EventHandlerAsync<IqEventArgs> h))
                    return false;
 
                if (h != Handler)
                    return false;
 
                Handlers.Remove(Key);
 
                if (RemoveNamespaceAsFeature)
                    this.features.Remove(Namespace);
            }
 
            return true;
        }
 
        public bool UnregisterMessageHandler(string LocalName, string Namespace, EventHandlerAsync<MessageEventArgs> Handler, bool RemoveNamespaceAsFeature)
        {
            string Key = LocalName + " " + Namespace;
 
            lock (this.synchObject)
            {
                if (!this.messageHandlers.TryGetValue(Key, out EventHandlerAsync<MessageEventArgs> h))
                    return false;
 
                if (h != Handler)
                    return false;
 
                this.messageHandlers.Remove(Key);
 
                if (RemoveNamespaceAsFeature)
                    this.features.Remove(Namespace);
            }
 
            return true;
        }
 
        public bool UnregisterPresenceHandler(string LocalName, string Namespace, EventHandlerAsync<PresenceEventArgs> Handler, bool RemoveNamespaceAsFeature)
        {
            string Key = LocalName + " " + Namespace;
 
            lock (this.synchObject)
            {
                if (!this.presenceHandlers.TryGetValue(Key, out EventHandlerAsync<PresenceEventArgs> h))
                    return false;
 
                if (h != Handler)
                    return false;
 
                this.presenceHandlers.Remove(Key);
 
                if (RemoveNamespaceAsFeature)
                    this.features.Remove(Namespace);
            }
 
            return true;
        }
 
        public void UnregisterFeature(string Namespace)
        {
            lock (this.synchObject)
            {
                this.features.Remove(Namespace);
            }
        }
 
        public async Task<bool> IQ(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            Dictionary<string, EventHandlerAsync<IqEventArgs>> Handlers;
            EventHandlerAsync<IqEventArgs> h = null;
            IqResponse Response;
            string Counter;
            string Key;
 
            switch (Type)
            {
                case "get":
                    if (this.responses.TryGet(From.Address, Id, true, out Response, out bool Created))
                    {
                        if (!Created)
                        {
                            KeyValuePair<string, bool> P = await Response.GetResponse();
 
                            if (P.Value)
                                return await Sender.IqResult(Id, From, To, P.Key);
                            else
                                return await Sender.IqError(Id, From, To, P.Key);
                        }
                    }
 
                    Handlers = this.iqGetHandlers;
                    Counter = "XMPP.Component." + this.subdomain + ".Get";
                    break;
 
                case "set":
                    if (this.responses.TryGet(From.Address, Id, true, out Response, out Created))
                    {
                        if (!Created)
                        {
                            KeyValuePair<string, bool> P = await Response.GetResponse();
 
                            if (P.Value)
                                return await Sender.IqResult(Id, From, To, P.Key);
                            else
                                return await Sender.IqError(Id, From, To, P.Key);
                        }
                    }
 
                    Handlers = this.iqSetHandlers;
                    Counter = "XMPP.Component." + this.subdomain + ".Set";
                    break;
 
                case "result":
                case "error":
                    return await this.server.ProcessResponse(Type, Id, To, From, Language, true, false, Stanza, Sender);
 
                default:
                    if (Sender is null)
                        return false;
                    else
                        return !(await Sender.IqErrorBadRequest(Id, From, To, "Invalid type.", "en") is null);
            }
 
            IqEventArgs e = new IqEventArgs(Sender, Stanza.StanzaElement, Id, Type, To, From, Language, Response);
 
            lock (this.synchObject)
            {
                foreach (XmlNode N in Stanza.StanzaElement.ChildNodes)
                {
                    if (!(N is XmlElement E))
                        continue;
 
                    Key = E.LocalName + " " + E.NamespaceURI;
                    if (Handlers.TryGetValue(Key, out h))
                    {
                        Counter += "." + E.LocalName;
                        e.Query = E;
                        break;
                    }
                    else
                        h = null;
                }
            }
 
            if (h is null)
            {
                if (Sender is null)
                {
                    Response.SetResult(string.Empty, false);
                    return false;
                }
                else
                {
                    string ErrorXml = await Sender.IqError(Id, From, To, "cancel", "<feature-not-implemented xmlns='" + XmppServer.StanzaNamespace + "'/>", string.Empty, string.Empty);
                    Response.SetResult(ErrorXml, false);
                    return !(ErrorXml is null);
                }
            }
 
            try
            {
                await RuntimeCounters.IncrementCounter(Counter);
                await h(this, e);
                return true;
            }
            catch (Exception ex)
            {
                if (Sender is null)
                {
                    Response.SetResult(string.Empty, false);
                    return false;
                }
                else
                {
                    string ErrorXml = await Sender.IqError(Id, From, To, ex);
                    Response.SetResult(ErrorXml, false);
                    return !(ErrorXml is null);
                }
            }
        }
 
        public Task<bool> IQ(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            return this.IQ(Type, Id, To, From, Language, XmppServer.ToStanza("iq", Type, Id, To, From, Language, ContentXml), Sender);
        }
 
        public async Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            MessageEventArgs e = new MessageEventArgs(Sender, Stanza.StanzaElement, Id, Type, To, From, Language);
            EventHandlerAsync<MessageEventArgs> h = null;
            string Counter = "XMPP.Component." + this.subdomain + ".Message";
            string Key;
 
            lock (this.synchObject)
            {
                foreach (XmlNode N in Stanza.StanzaElement.ChildNodes)
                {
                    if (!(N is XmlElement E))
                        continue;
 
                    Key = E.LocalName + " " + E.NamespaceURI;
                    if (this.messageHandlers.TryGetValue(Key, out h))
                    {
                        Counter += "." + E.LocalName;
                        e.Content = E;
                        break;
                    }
                    else
                        h = null;
                }
            }
 
            try
            {
                if (h is null)
                    await this.MessageNoHandlerReceived(e);
                else
                {
                    await RuntimeCounters.IncrementCounter(Counter);
                    await h(this, e);
                }
            }
            catch (Exception ex)
            {
                if (!(Sender is null))
                    await (Sender?.MessageError(Id, From, To, ex) ?? Task.CompletedTask);
            }
 
            return true;
        }
 
        protected virtual Task MessageNoHandlerReceived(MessageEventArgs e)
        {
            return Task.CompletedTask;
        }
 
        public Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            return this.Message(Type, Id, To, From, Language, XmppServer.ToStanza("message", Type, Id, To, From, Language, ContentXml), Sender);
        }
 
        //public Task<bool> Presence(string Type, string Id, CaseInsensitiveString From, string Language, Stanza Stanza, ISender Sender)
        //{
        //  // TODO: Component presence
        //  return Task.FromResult(true);
        //}
 
        public async Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, Stanza Stanza, ISender Sender)
        {
            PresenceEventArgs e = new PresenceEventArgs(Sender, Type, Id, To, From, Language, Stanza, null);
            EventHandlerAsync<PresenceEventArgs> h = null;
            string Counter = "XMPP.Component." + this.subdomain + ".Presence";
            string Key;
 
            lock (this.synchObject)
            {
                foreach (XmlNode N in Stanza.StanzaElement.ChildNodes)
                {
                    if (!(N is XmlElement E))
                        continue;
 
                    Key = E.LocalName + " " + E.NamespaceURI;
                    if (this.presenceHandlers.TryGetValue(Key, out h))
                    {
                        Counter += "." + E.LocalName;
                        e.Content = E;
                        break;
                    }
                    else
                        h = null;
                }
            }
 
            try
            {
                if (h is null)
                    await this.PresenceNoHandlerReceived(e);
                else
                {
                    await RuntimeCounters.IncrementCounter(Counter);
                    await h(this, e);
                }
            }
            catch (Exception ex)
            {
                if (!(Sender is null))
                    await (Sender?.PresenceError(Id, From, To, ex) ?? Task.CompletedTask);
            }
 
            return true;
        }
 
        protected virtual Task PresenceNoHandlerReceived(PresenceEventArgs e)
        {
            return Task.CompletedTask;
        }
 
        public Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml, ISender Sender)
        {
            return this.Presence(Type, Id, To, From, Language, XmppServer.ToStanza("presence", Type, Id, To, From, Language, ContentXml), Sender);
        }
 
        protected static string InnerXmlNoJabberNamespace(XmlElement Xml)
        {
            if (Xml is null)
                return string.Empty;
 
            string s = Xml.OuterXml;
            int i = s.IndexOf('>');
            int j = s.LastIndexOf('<');
 
            if (j <= i)
                return string.Empty;
 
            return s.Substring(i + 1, j - i - 1);
        }
 
        #endregion
 
        #region Discovery XEP-0030
 
        protected virtual async Task DiscoveryQueryGet(object Sender, IqEventArgs e)
        {
            XmlElement E = e.Query;
 
            if (e.To.HasAccount && (!this.SupportsAccounts || !await this.SupportsAccount(e.To.Account)))
            {
                await e.IqErrorItemNotFound(e.To, "Item not found.", "en");
                return;
            }
 
            string Node = XML.Attribute(E, "node");
            if (!string.IsNullOrEmpty(Node) && !await this.SupportsNode(Node))
            {
                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                return;
            }
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<query xmlns='");
            Xml.Append(XmppServer.DiscoveryNamespace);
            Xml.Append("'>");
 
            await this.AppendServiceDiscoveryIdentities(Xml, e, Node);
 
            if (string.IsNullOrEmpty(e.To.Account) && string.IsNullOrEmpty(Node))
            {
                lock (this.synchObject)
                {
                    foreach (string Feature in this.features.Keys)
                    {
                        Xml.Append("<feature var='");
                        Xml.Append(XML.Encode(Feature));
                        Xml.Append("'/>");
                    }
                }
            }
 
            await this.AppendServiceDiscoveryFeatures(Xml, e, Node);
 
            Xml.Append("</query>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        protected virtual Task<bool> SupportsAccount(string Account)
        {
            return Task.FromResult(false);
        }
 
        protected virtual Task<bool> SupportsNode(string Node)
        {
            return Task.FromResult(false);
        }
 
        protected virtual async Task DiscoveryQueryItemsGet(object Sender, IqEventArgs e)
        {
            XmlElement E = e.Query;
 
            if (e.To.HasAccount && (!this.SupportsAccounts || !await this.SupportsAccount(e.To.Account)))
            {
                await e.IqErrorItemNotFound(e.To, "Item not found.", "en");
                return;
            }
 
            string Node = XML.Attribute(E, "node");
            if (!string.IsNullOrEmpty(Node) && !await this.SupportsNode(Node))
            {
                await e.IqErrorItemNotFound(e.To, "Node not found.", "en");
                return;
            }
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<query xmlns='");
            Xml.Append(XmppServer.DiscoveryItemsNamespace);
            Xml.Append("'>");
 
            await this.AppendItemInformation(Xml, e, Node);
 
            Xml.Append("</query>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        protected virtual Task AppendServiceDiscoveryIdentities(StringBuilder Xml, IqEventArgs e, string Node)
        {
            return Task.CompletedTask;
        }
 
        protected virtual Task AppendServiceDiscoveryFeatures(StringBuilder Xml, IqEventArgs e, string Node)
        {
            return Task.CompletedTask;
        }
 
        protected virtual Task AppendItemInformation(StringBuilder Xml, IqEventArgs e, string Node)
        {
            return Task.CompletedTask;
        }
 
        #endregion
 
        #region ISender
 
        public virtual Task<string> IqError(string Id, XmppAddress To, XmppAddress From, Exception ex)
        {
            return Task.FromResult(string.Empty);   // Do nothing by default.
        }
 
        public virtual Task<bool> IqError(string Id, XmppAddress To, XmppAddress From, string ErrorXml)
        {
            return Task.FromResult(true); // Do nothing by default.
        }
 
        public virtual Task<bool> IqResult(string Id, XmppAddress To, XmppAddress From, string ResultXml)
        {
            return Task.FromResult(true); // Do nothing by default.
        }
 
        public virtual Task<bool> PresenceError(string Id, XmppAddress To, XmppAddress From, Exception ex)
        {
            return Task.FromResult(true); // Do nothing by default.
        }
 
        public virtual Task<bool> PresenceError(string Id, XmppAddress To, XmppAddress From, string ErrorXml)
        {
            return Task.FromResult(true); // Do nothing by default.
        }
 
        public virtual Task<bool> Presence(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml)
        {
            return Task.FromResult(true); // Do nothing by default.
        }
 
        public virtual Task<bool> Message(string Type, string Id, XmppAddress To, XmppAddress From, string Language, string ContentXml)
        {
            return Task.FromResult(true); // Do nothing by default.
        }
 
        public virtual Task<bool> MessageError(string Id, XmppAddress To, XmppAddress From, Exception ex)
        {
            return Task.FromResult(true); // Do nothing by default.
        }
 
        #endregion
 
    }
}