GeoSpatialComponent.cs

using Paiwise;
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Runtime.Collections;
using Waher.Runtime.Geo;
using Waher.Runtime.Threading;
using Waher.Service.IoTBroker.Legal;
using Waher.Service.IoTBroker.Legal.Identity;
 
namespace Waher.Service.IoTBroker.GeoSpatial
{
    public class GeoSpatialComponent : Component
    {
        private const int defaultSubscriptionTtl = 60;
 
        private const int maxSubscriptionTtl = 300;
 
        private const int maxSubscriptionsPerClient = 5;    // TODO: Make an account setting
 
        private const int maxPublicationsPerClient = 5;     // TODO: Make an account setting
 
        private const int maxSearchResults = 100;           // TODO: Make an account setting
 
        private readonly GeoPositionCollection<PersistedGeoSpatialObjectReference> geoPositions =
            new GeoPositionCollection<PersistedGeoSpatialObjectReference>();
        private readonly GeoBoxCollection<GeoSubscription> geoSubscriptions =
            new GeoBoxCollection<GeoSubscription>();
        private readonly Dictionary<CaseInsensitiveString, ChunkedList<GeoSubscription>> geoSubscriptionsByBareJid =
            new Dictionary<CaseInsensitiveString, ChunkedList<GeoSubscription>>();
        private readonly Dictionary<CaseInsensitiveString, int> geoPublicationsByBareJid =
            new Dictionary<CaseInsensitiveString, int>();
 
        public const string NamespaceGeoSpatialNeuroFoundationV1 = "urn:nf:iot:geo:1.0";
 
        public static readonly string[] NamespacesGeoSpatial = new string[]
        {
            NamespaceGeoSpatialNeuroFoundationV1
        };
 
        public static bool IsNamespaceGeoSpatial(string Namespace)
        {
            return Array.IndexOf(NamespacesGeoSpatial, Namespace) >= 0;
        }
 
        public GeoSpatialComponent(XmppServer Server, CaseInsensitiveString Subdomain, string Name)
            : base(Server, Subdomain, Name)
        {
            Server.ClientConnectionRemoved += this.ClientConnectionRemoved;
 
            #region Neuro-Foundation V1 handlers
 
            this.RegisterIqSetHandler("subscribe", NamespaceGeoSpatialNeuroFoundationV1, this.SubscribeHandler, true);
            this.RegisterIqSetHandler("unsubscribe", NamespaceGeoSpatialNeuroFoundationV1, this.UnsubscribeHandler, false);
            this.RegisterIqSetHandler("publish", NamespaceGeoSpatialNeuroFoundationV1, this.PublishHandler, false);
            this.RegisterIqSetHandler("delete", NamespaceGeoSpatialNeuroFoundationV1, this.DeleteHandler, false);
            this.RegisterIqGetHandler("search", NamespaceGeoSpatialNeuroFoundationV1, this.SearchHandler, false);
 
            #endregion
        }
 
        public override void Dispose()
        {
            this.Server.ClientConnectionRemoved -= this.ClientConnectionRemoved;
 
            #region Neuro-Foundation V1 handlers
 
            this.UnregisterIqSetHandler("subscribe", NamespaceGeoSpatialNeuroFoundationV1, this.SubscribeHandler, true);
            this.UnregisterIqSetHandler("unsubscribe", NamespaceGeoSpatialNeuroFoundationV1, this.UnsubscribeHandler, false);
            this.UnregisterIqSetHandler("publish", NamespaceGeoSpatialNeuroFoundationV1, this.PublishHandler, false);
            this.UnregisterIqSetHandler("delete", NamespaceGeoSpatialNeuroFoundationV1, this.DeleteHandler, false);
            this.UnregisterIqGetHandler("search", NamespaceGeoSpatialNeuroFoundationV1, this.SearchHandler, false);
 
            #endregion
        }
 
        public override bool SupportsAccounts => false;
 
        internal async Task Load()
        {
            try
            {
                await Database.Iterate(new ReferenceLoader(this), "GeoObjects");
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public async Task Publish(IGeoSpatialObject Object)
        {
            if (Object is null)
                return;
 
            if (!Object.HasGeoLocation)
            {
                await this.Delete(Object);
                return;
            }
 
            GeoPosition PrevLocation;
 
            if (this.geoPositions.TryGetObject(Object.GeoId, out PersistedGeoSpatialObjectReference Ref))
            {
                bool PrevEphemeral = Ref.EphemeralLocation;
                PrevLocation = Ref.Location;
 
                Ref.Location = await Object.GetLocation();
                Ref.EphemeralLocation = Object.EphemeralLocation;
 
                this.geoPositions.Moved(Ref);
 
                if (Ref.EphemeralLocation)
                {
                    if (!PrevEphemeral && !string.IsNullOrEmpty(Ref.ObjectId))
                    {
                        await Database.Delete(Ref);
                        Ref.ObjectId = null;
                    }
                }
                else
                {
                    if (!string.IsNullOrEmpty(Ref.ObjectId))
                        await Database.Update(Ref);
                    else
                        await Database.Insert(Ref);
                }
            }
            else
            {
                Ref = await PersistedGeoSpatialObjectReference.Create(Object);
                this.AddReference(Ref, false);
 
                if (!Ref.EphemeralLocation)
                    await Database.Insert(Ref);
 
                PrevLocation = null;
            }
 
            Dictionary<string, GeoSubscription> PrevSubscriptions = null;
            GeoSubscription[] Subscriptions;
 
            if (!(PrevLocation is null) && !PrevLocation.Equals(Ref.Location))
            {
                Subscriptions = this.geoSubscriptions.Find(PrevLocation);
                if (Subscriptions.Length > 0)
                {
                    PrevSubscriptions = new Dictionary<string, GeoSubscription>();
 
                    foreach (GeoSubscription Subscription in Subscriptions)
                        PrevSubscriptions[Subscription.BoxId] = Subscription;
                }
            }
 
            Subscriptions = this.geoSubscriptions.Find(Ref.Location);
 
            if (Subscriptions.Length > 0)
            {
                foreach (GeoSubscription Subscription in Subscriptions)
                {
                    try
                    {
                        if (PrevSubscriptions?.Remove(Subscription.BoxId) ?? false)
                            await Subscription.ObjectUpdated(Ref, this);
                        else
                            await Subscription.ObjectAdded(Ref, this);
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
                }
            }
 
            if (!(PrevSubscriptions is null))
            {
                foreach (GeoSubscription Subscription in PrevSubscriptions.Values)
                {
                    try
                    {
                        await Subscription.ObjectRemoved(Ref, this);
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
                }
            }
        }
 
        private bool AddReference(PersistedGeoSpatialObjectReference Ref, bool CheckLimit)
        {
            if (!CaseInsensitiveString.IsNullOrEmpty(Ref.Creator))
            {
                lock (this.geoPublicationsByBareJid)
                {
                    if (this.geoPublicationsByBareJid.TryGetValue(Ref.Creator, out int Count))
                    {
                        if (CheckLimit && Count >= maxPublicationsPerClient)
                            return false;
 
                        this.geoPublicationsByBareJid[Ref.Creator] = Count + 1;
                    }
                    else
                        this.geoPublicationsByBareJid[Ref.Creator] = 1;
                }
            }
 
            this.geoPositions.Add(Ref);
 
            return true;
        }
 
        private bool RemoveReference(string GeoId)
        {
            return this.RemoveReference(GeoId, out _);
        }
 
        private bool RemoveReference(PersistedGeoSpatialObjectReference Ref)
        {
            return this.RemoveReference(Ref.GeoId, out _);
        }
 
        private bool RemoveReference(string GeoId, out PersistedGeoSpatialObjectReference Ref)
        {
            if (!this.geoPositions.Remove(GeoId, out Ref))
                return false;
 
            if (Ref.Expires.HasValue)
            {
                Gateway.CancelScheduledEvent(Ref.Expires.Value);
                Ref.Expires = null;
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(Ref.Creator))
            {
                lock (this.geoPublicationsByBareJid)
                {
                    if (this.geoPublicationsByBareJid.TryGetValue(Ref.Creator, out int Count))
                    {
                        if (Count > 1)
                            this.geoPublicationsByBareJid[Ref.Creator] = Count - 1;
                        else
                            this.geoPublicationsByBareJid.Remove(Ref.Creator);
                    }
                }
            }
 
            return true;
        }
 
        internal void Loaded(PersistedGeoSpatialObjectReference Ref)
        {
            if (!this.geoPositions.Contains(Ref.GeoId))
            {
                this.AddReference(Ref, false);
 
                if (Ref.Expires.HasValue)
                    Gateway.ScheduleEvent(this.CheckItemExpired, Ref.Expires.Value, Ref.GeoId);
            }
        }
 
        public async Task Delete(IGeoSpatialObject Object)
        {
            if (Object is null)
                return;
 
            await this.Delete(Object.GeoId);
        }
 
        public async Task Delete(string GeoId)
        {
            if (this.RemoveReference(GeoId, out PersistedGeoSpatialObjectReference Ref))
            {
                if (!string.IsNullOrEmpty(Ref.ObjectId))
                    await Database.Delete(Ref);
 
                GeoSubscription[] Subscriptions = this.geoSubscriptions.Find(Ref.Location);
 
                if (Subscriptions.Length > 0)
                {
                    foreach (GeoSubscription Subscription in Subscriptions)
                    {
                        try
                        {
                            await Subscription.ObjectRemoved(Ref, this);
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex);
                        }
                    }
                }
            }
        }
 
        private async Task SubscribeHandler(object Sender, IqEventArgs e)
        {
            string Id = XML.Attribute(e.Query, "id");
            double MinLat = XML.Attribute(e.Query, "minLat", double.NaN);
            double MaxLat = XML.Attribute(e.Query, "maxLat", double.NaN);
            double MinLon = XML.Attribute(e.Query, "minLon", double.NaN);
            double MaxLon = XML.Attribute(e.Query, "maxLon", double.NaN);
            double? MinAlt = e.Query.HasAttribute("minAlt") ? XML.Attribute(e.Query, "minAlt", double.NaN) : (double?)null;
            double? MaxAlt = e.Query.HasAttribute("maxAlt") ? XML.Attribute(e.Query, "maxAlt", double.NaN) : (double?)null;
            int Ttl = XML.Attribute(e.Query, "ttl", defaultSubscriptionTtl);
 
            if (double.IsNaN(MinLat) ||
                double.IsNaN(MaxLat) ||
                double.IsNaN(MinLon) ||
                double.IsNaN(MaxLon) ||
                (MinAlt.HasValue && double.IsNaN(MinAlt.Value)) ||
                (MaxAlt.HasValue && double.IsNaN(MaxAlt.Value)))
            {
                await e.IqErrorBadRequest(e.To, "Invalid floating-point attribute values.", "en");
                return;
            }
 
            if (MinLat < -90 || MinLat > 90 || MaxLat < -90 || MaxLat > 90)
            {
                await e.IqErrorBadRequest(e.To, "Valid latitude values reside in the range [-90,90].", "en");
                return;
            }
 
            if (MinLon < -180 || MinLon > 180 || MaxLon < -180 || MaxLon > 180)
            {
                await e.IqErrorBadRequest(e.To, "Valid longitude values reside in the range [-180,180].", "en");
                return;
            }
 
            if (MinLat > MaxLat)
            {
                await e.IqErrorBadRequest(e.To, "Minimum latitude cannot be larger than the maximum latitude.", "en");
                return;
            }
 
            if (MinAlt.HasValue && MaxAlt.HasValue && MinAlt.Value > MaxAlt.Value)
            {
                await e.IqErrorBadRequest(e.To, "Minimum altitude cannot be larger than the maximum altitude.", "en");
                return;
            }
 
            if (Ttl <= 0)
            {
                await e.IqErrorBadRequest(e.To, "Invalid time to live (TTL) value.", "en");
                return;
            }
 
            if (Ttl > maxSubscriptionTtl)
                Ttl = maxSubscriptionTtl;
 
            Dictionary<string, PersistedGeoSpatialObjectReference> PrevReferences = null;
            PersistedGeoSpatialObjectReference[] References;
            GeoSubscription Subscription;
 
            if (!string.IsNullOrEmpty(Id))
            {
                if (!this.geoSubscriptions.TryGetBox(Id, out Subscription))
                {
                    await e.IqErrorItemNotFound(e.To, "Subscription ID not found.", "en");
                    return;
                }
 
                if (Subscription.From.BareJid != e.From.BareJid)
                {
                    await e.IqErrorForbidden(e.To, "Subscription not created by sender.", "en");
                    return;
                }
 
                References = this.geoPositions.Find(Subscription);
                PrevReferences = new Dictionary<string, PersistedGeoSpatialObjectReference>();
 
                foreach (PersistedGeoSpatialObjectReference Obj in References)
                    PrevReferences[Obj.GeoId] = Obj;
 
                Subscription.Min.Latitude = MinLat;
                Subscription.Min.Longitude = MinLon;
                Subscription.Min.Altitude = MinAlt;
                Subscription.Max.Latitude = MaxLat;
                Subscription.Max.Longitude = MaxLon;
                Subscription.Max.Altitude = MaxAlt;
 
                Gateway.CancelScheduledEvent(Subscription.Elapses);
                Subscription.Elapses = Gateway.ScheduleEvent(this.SubscriptionTimeout,
                    DateTime.Now.AddSeconds(Ttl), Subscription);
 
                this.geoSubscriptions.Moved(Subscription);
            }
            else
            {
                Subscription = new GeoSubscription(
                    e.From,
                    new GeoPosition(MinLat, MinLon, MinAlt),
                    new GeoPosition(MaxLat, MaxLon, MaxAlt),
                    DateTime.MinValue);
 
                lock (this.geoSubscriptionsByBareJid)
                {
                    if (!this.geoSubscriptionsByBareJid.TryGetValue(e.From.BareJid,
                        out ChunkedList<GeoSubscription> Subscriptions))
                    {
                        Subscriptions = new ChunkedList<GeoSubscription>(1);
                        this.geoSubscriptionsByBareJid[e.From.BareJid] = Subscriptions;
 
                        Subscriptions.Add(Subscription);
                    }
                    else if (Subscriptions.Count >= maxSubscriptionsPerClient)
                        Subscription = null;
                    else
                        Subscriptions.Add(Subscription);
                }
 
                if (Subscription is null)
                {
                    await e.IqErrorResourceConstraint(e.To, "Too many current subscriptions.", "en");
                    return;
                }
 
                this.geoSubscriptions.Add(Subscription);
 
                DateTime Elapses = Gateway.ScheduleEvent(this.SubscriptionTimeout,
                    DateTime.Now.AddSeconds(Ttl), Subscription);
 
                Subscription.Elapses = Elapses;
            }
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<subscribed xmlns='");
            Xml.Append(e.Query.NamespaceURI);
            Xml.Append("' ttl='");
            Xml.Append(Ttl);
 
            if (string.IsNullOrEmpty(Id))
            {
                Xml.Append("' id='");
                Xml.Append(XML.Encode(Subscription.BoxId));
            }
 
            Xml.Append("'/>");
 
            await e.IqResult(Xml.ToString(), e.To);
 
            References = this.geoPositions.Find(Subscription);
 
            foreach (PersistedGeoSpatialObjectReference Obj in References)
            {
                if (PrevReferences is null || !PrevReferences.Remove(Obj.GeoId))
                    await Subscription.ObjectAdded(Obj, this);
            }
 
            if (!(PrevReferences is null))
            {
                foreach (PersistedGeoSpatialObjectReference Obj in PrevReferences.Values)
                    await Subscription.ObjectRemoved(Obj, this);
            }
        }
 
        private Task ClientConnectionRemoved(object Sender, ClientConnectionEventArgs e)
        {
            try
            {
                XmppAddress Jid = new XmppAddress(e.JID);
                ChunkedList<GeoSubscription> Removed = null;
                ChunkedList<GeoSubscription> Kept = null;
 
                lock (this.geoSubscriptionsByBareJid)
                {
                    if (!this.geoSubscriptionsByBareJid.TryGetValue(Jid.BareJid,
                        out ChunkedList<GeoSubscription> Subscriptions))
                    {
                        return Task.CompletedTask;
                    }
 
                    foreach (GeoSubscription Subscription in Subscriptions)
                    {
                        if (Subscription.From.Address == e.JID)
                        {
                            Removed ??= new ChunkedList<GeoSubscription>();
                            Removed.Add(Subscription);
                        }
                        else
                        {
                            Kept ??= new ChunkedList<GeoSubscription>();
                            Kept.Add(Subscription);
                        }
                    }
 
                    if (Kept is null)
                        this.geoSubscriptionsByBareJid.Remove(Jid.BareJid);
                    else if (!(Removed is null))
                        this.geoSubscriptionsByBareJid[Jid.BareJid] = Kept;
                }
 
                if (!(Removed is null))
                {
                    foreach (GeoSubscription Subscription in Removed)
                    {
                        Gateway.CancelScheduledEvent(Subscription.Elapses);
                        Subscription.Elapses = DateTime.MinValue;
 
                        this.geoSubscriptions.Remove(Subscription);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
 
            return Task.CompletedTask;
        }
 
        private async Task SubscriptionTimeout(object State)
        {
            if (!(State is GeoSubscription Subscription))
                return;
 
            this.geoSubscriptions.Remove(Subscription);
 
            lock (this.geoSubscriptionsByBareJid)
            {
                if (this.geoSubscriptionsByBareJid.TryGetValue(Subscription.From.BareJid,
                    out ChunkedList<GeoSubscription> Subscriptions) &&
                    Subscriptions.Remove(Subscription) &&
                    Subscriptions.Count == 0)
                {
                    this.geoSubscriptionsByBareJid.Remove(Subscription.From.BareJid);
                }
            }
 
            await this.Message(string.Empty, string.Empty, Subscription.From,
                this.MainDomain, string.Empty, UnsubscribedXml(Subscription.BoxId), null);
        }
 
        private static string UnsubscribedXml(string Id)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<unsubscribed xmlns='");
            Xml.Append(NamespaceGeoSpatialNeuroFoundationV1);
            Xml.Append("' id='");
            Xml.Append(XML.Encode(Id));
            Xml.Append("'/>");
 
            return Xml.ToString();
        }
 
        private async Task UnsubscribeHandler(object Sender, IqEventArgs e)
        {
            string Id = XML.Attribute(e.Query, "id");
 
            if (string.IsNullOrEmpty(Id))
            {
                await e.IqErrorBadRequest(e.To, "Missing subscription ID.", "en");
                return;
            }
 
            if (!this.geoSubscriptions.TryGetBox(Id, out GeoSubscription Subscription))
            {
                await e.IqErrorItemNotFound(e.To, "Subscription ID not found.", "en");
                return;
            }
 
            if (Subscription.From.BareJid != e.From.BareJid)
            {
                await e.IqErrorForbidden(e.To, "Subscription not created by sender.", "en");
                return;
            }
 
            Gateway.CancelScheduledEvent(Subscription.Elapses);
            Subscription.Elapses = DateTime.MinValue;
 
            this.geoSubscriptions.Remove(Subscription);
 
            await e.IqResult(UnsubscribedXml(Id), e.To);
        }
 
        private async Task PublishHandler(object Sender, IqEventArgs e)
        {
            string Id = XML.Attribute(e.Query, "id");
            double Lat = XML.Attribute(e.Query, "lat", double.NaN);
            double Lon = XML.Attribute(e.Query, "lon", double.NaN);
            double? Alt = e.Query.HasAttribute("alt") ? XML.Attribute(e.Query, "alt", double.NaN) : (double?)null;
            int? Ttl = e.Query.HasAttribute("ttl") ? XML.Attribute(e.Query, "ttl", 0) : (int?)null;
            DateTime? From = e.Query.HasAttribute("from") ? XML.Attribute(e.Query, "from", DateTime.MinValue) : (DateTime?)null;
            DateTime? To = e.Query.HasAttribute("to") ? XML.Attribute(e.Query, "to", DateTime.MinValue) : (DateTime?)null;
 
            if (double.IsNaN(Lat) ||
                double.IsNaN(Lon) ||
                (Alt.HasValue && double.IsNaN(Alt.Value)))
            {
                await e.IqErrorBadRequest(e.To, "Invalid floating-point attribute values.", "en");
                return;
            }
 
            if (Lat < -90 || Lat > 90)
            {
                await e.IqErrorBadRequest(e.To, "Valid latitude values reside in the range [-90,90].", "en");
                return;
            }
 
            if (Lon < -180 || Lon > 180)
            {
                await e.IqErrorBadRequest(e.To, "Valid longitude values reside in the range [-180,180].", "en");
                return;
            }
 
            if (Ttl.HasValue && Ttl.Value <= 0)
            {
                await e.IqErrorBadRequest(e.To, "Invalid time to live (TTL) value.", "en");
                return;
            }
 
            if (From.HasValue)
            {
                if (From.Value == DateTime.MinValue)
                {
                    await e.IqErrorBadRequest(e.To, "Invalid from timestamp.", "en");
                    return;
                }
 
                if (From.Value.Kind != DateTimeKind.Utc)
                {
                    await e.IqErrorBadRequest(e.To, "From timestamp not in UTC.", "en");
                    return;
                }
            }
 
            if (To.HasValue)
            {
                if (To.Value == DateTime.MinValue)
                {
                    await e.IqErrorBadRequest(e.To, "Invalid to timestamp.", "en");
                    return;
                }
 
                if (To.Value.Kind != DateTimeKind.Utc)
                {
                    await e.IqErrorBadRequest(e.To, "To timestamp not in UTC.", "en");
                    return;
                }
            }
 
            int i = Id.IndexOf(':');
            if (i > 0)
            {
                string Scheme = Id[..i];
 
                switch (Scheme.ToLower())
                {
                    case "iotdisco":
                        await e.IqErrorForbidden(e.To, "Geo-spatial references to devices must be managed via the Thing Registry.", "en");
                        return;
 
                    case "iotid":
                        string LegalId = Id[(i + 1)..];
 
                        LegalIdentity Identity = await LegalComponent.GetLocalLegalIdentity(LegalId);
                        if (Identity is null)
                        {
                            await e.IqErrorForbidden(e.To, "Geo-spatial references to legal identities only allowed for local identities.", "en");
                            return;
                        }
 
                        PersonalInformation Info = LegalComponent.GetPersonalInformation(Identity);
 
                        if (e.From.BareJid != Info.Jid)
                        {
                            await e.IqErrorForbidden(e.To, "You are only allowed to add geo-spatial references to your own legal identities.", "en");
                            return;
                        }
                        break;
                }
            }
 
            Dictionary<string, GeoSubscription> PrevSubscriptions = null;
            PersistedGeoSpatialObjectReference Ref = null;
            bool NewRef = true;
 
            if (string.IsNullOrEmpty(Id))
                Id = Guid.NewGuid().ToString();
            else
            {
                if (this.geoPositions.TryGetObject(Id, out Ref))
                {
                    if (e.From.BareJid != Ref.Creator)
                    {
                        await e.IqErrorForbidden(e.To, "Object not created by sender.", "en");
                        return;
                    }
 
                    if (Ref.Expires.HasValue)
                    {
                        Gateway.CancelScheduledEvent(Ref.Expires.Value);
                        Ref.Expires = null;
                    }
 
                    NewRef = false;
                    PrevSubscriptions ??= new Dictionary<string, GeoSubscription>();
 
                    foreach (GeoSubscription Subscription in this.geoSubscriptions.Find(Ref.Location))
                        PrevSubscriptions[Subscription.BoxId] = Subscription;
                }
                else
                    Ref = null;
            }
 
            if (Ttl.HasValue)
            {
                if (Ref is null)
                {
                    Ref = new PersistedGeoSpatialObjectReference()
                    {
                        GeoId = Id,
                        EphemeralLocation = false,
                        Expires = Gateway.ScheduleEvent(this.CheckItemExpired, DateTime.Now.AddSeconds(Ttl.Value), Id),
                        Creator = e.From.BareJid,
                        Location = new GeoPosition(Lat, Lon, Alt),
                        ContentXml = e.Query.InnerXml,
                        Created = DateTime.UtcNow,
                        From = From,
                        To = To
                    };
                }
                else
                {
                    Ref.EphemeralLocation = false;
                    Ref.Expires = Gateway.ScheduleEvent(this.CheckItemExpired, DateTime.Now.AddSeconds(Ttl.Value), Id);
                    Ref.Location = new GeoPosition(Lat, Lon, Alt);
                    Ref.ContentXml = e.Query.InnerXml;
                    Ref.Updated = DateTime.UtcNow;
                    Ref.From = From;
                    Ref.To = To;
                }
            }
            else
            {
                if (Ref is null)
                {
                    Ref = new PersistedGeoSpatialObjectReference()
                    {
                        GeoId = Id,
                        EphemeralLocation = true,
                        Expires = null,
                        Creator = e.From.BareJid,
                        Location = new GeoPosition(Lat, Lon, Alt),
                        ContentXml = e.Query.InnerXml,
                        Created = DateTime.UtcNow,
                        From = From,
                        To = To
                    };
                }
                else
                {
                    this.RemoveReference(Ref);
 
                    Ref.EphemeralLocation = true;
                    Ref.Expires = null;
                    Ref.Location = new GeoPosition(Lat, Lon, Alt);
                    Ref.ContentXml = e.Query.InnerXml;
                    Ref.Updated = DateTime.UtcNow;
                    Ref.From = From;
                    Ref.To = To;
                }
            }
 
            if (NewRef)
            {
                if (!this.AddReference(Ref, true))
                {
                    await e.IqErrorResourceConstraint(e.To, "Publication limit reached.", "en");
                    return;
                }
            }
            else
                this.geoPositions.Moved(Ref);
 
            if (Ref.EphemeralLocation)
            {
                if (!string.IsNullOrEmpty(Ref.ObjectId))
                {
                    await Database.Delete(Ref);
                    Ref.ObjectId = null;
                }
            }
            else if (string.IsNullOrEmpty(Ref.ObjectId))
                await Database.Insert(Ref);
            else
                await Database.Update(Ref);
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<published xmlns='");
            Xml.Append(NamespaceGeoSpatialNeuroFoundationV1);
            Xml.Append("' id='");
            Xml.Append(XML.Encode(Id));
 
            if (Ttl.HasValue)
            {
                Xml.Append("' ttl='");
                Xml.Append(Ttl.Value);
            }
 
            Xml.Append("'/>");
 
            await e.IqResult(Xml.ToString(), e.To);
 
            GeoSubscription[] Subscriptions = this.geoSubscriptions.Find(Ref.Location);
 
            foreach (GeoSubscription Subscription in Subscriptions)
            {
                try
                {
                    if (PrevSubscriptions?.Remove(Subscription.BoxId) ?? false)
                        await Subscription.ObjectUpdated(Ref, this);
                    else
                        await Subscription.ObjectAdded(Ref, this);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            }
 
            if ((PrevSubscriptions?.Count ?? 0) > 0)
            {
                foreach (GeoSubscription Subscription in PrevSubscriptions.Values)
                {
                    try
                    {
                        await Subscription.ObjectRemoved(Ref, this);
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
                }
            }
        }
 
        private async Task CheckItemExpired(object State)
        {
            if (!(State is string GeoId))
                return;
 
            if (!this.geoPositions.TryGetObject(GeoId, out PersistedGeoSpatialObjectReference Ref))
                return;
 
            if (!Ref.Expires.HasValue || Ref.Expires.Value > DateTime.Now)
                return;
 
            this.RemoveReference(GeoId);
 
            if (!string.IsNullOrEmpty(Ref.ObjectId))
                await Database.Delete(Ref);
 
            foreach (GeoSubscription Subscription in this.geoSubscriptions.Find(Ref.Location))
            {
                try
                {
                    await Subscription.ObjectRemoved(Ref, this);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            }
        }
 
        private async Task DeleteHandler(object Sender, IqEventArgs e)
        {
            string Id = XML.Attribute(e.Query, "id");
 
            if (!this.geoPositions.TryGetObject(Id, out PersistedGeoSpatialObjectReference Ref))
            {
                await e.IqErrorItemNotFound(e.To, "Object not found.", "en");
                return;
            }
 
            if (e.From.BareJid != Ref.Creator)
            {
                await e.IqErrorForbidden(e.To, "Object not created by sender.", "en");
                return;
            }
 
            this.RemoveReference(Id);
 
            if (!string.IsNullOrEmpty(Ref.ObjectId))
            {
                await Database.Delete(Ref);
                Ref.ObjectId = null;
            }
            
            GeoSubscription[] Subscriptions = this.geoSubscriptions.Find(Ref.Location);
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<deleted xmlns='");
            Xml.Append(NamespaceGeoSpatialNeuroFoundationV1);
            Xml.Append("'/>");
 
            await e.IqResult(Xml.ToString(), e.To);
 
            foreach (GeoSubscription Subscription in Subscriptions)
            {
                try
                {
                    await Subscription.ObjectRemoved(Ref, this);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            }
        }
 
        private async Task SearchHandler(object Sender, IqEventArgs e)
        {
            double MinLat = XML.Attribute(e.Query, "minLat", double.NaN);
            double MaxLat = XML.Attribute(e.Query, "maxLat", double.NaN);
            double MinLon = XML.Attribute(e.Query, "minLon", double.NaN);
            double MaxLon = XML.Attribute(e.Query, "maxLon", double.NaN);
            double? MinAlt = e.Query.HasAttribute("minAlt") ? XML.Attribute(e.Query, "minAlt", double.NaN) : (double?)null;
            double? MaxAlt = e.Query.HasAttribute("maxAlt") ? XML.Attribute(e.Query, "maxAlt", double.NaN) : (double?)null;
            string Pattern = XML.Attribute(e.Query, "pattern");
            string Path = XML.Attribute(e.Query, "path");
            int Offset = XML.Attribute(e.Query, "offset", 0);
            int MaxCount = XML.Attribute(e.Query, "maxCount", maxSearchResults);
            Dictionary<string, string> Prefixes = null;
            Regex ParsedPattern;
 
            if (double.IsNaN(MinLat) ||
                double.IsNaN(MaxLat) ||
                double.IsNaN(MinLon) ||
                double.IsNaN(MaxLon) ||
                (MinAlt.HasValue && double.IsNaN(MinAlt.Value)) ||
                (MaxAlt.HasValue && double.IsNaN(MaxAlt.Value)))
            {
                await e.IqErrorBadRequest(e.To, "Invalid floating-point attribute values.", "en");
                return;
            }
 
            if (MinLat < -90 || MinLat > 90 || MaxLat < -90 || MaxLat > 90)
            {
                await e.IqErrorBadRequest(e.To, "Valid latitude values reside in the range [-90,90].", "en");
                return;
            }
 
            if (MinLon < -180 || MinLon > 180 || MaxLon < -180 || MaxLon > 180)
            {
                await e.IqErrorBadRequest(e.To, "Valid longitude values reside in the range [-180,180].", "en");
                return;
            }
 
            if (MinLat > MaxLat)
            {
                await e.IqErrorBadRequest(e.To, "Minimum latitude cannot be larger than the maximum latitude.", "en");
                return;
            }
 
            if (MinAlt.HasValue && MaxAlt.HasValue && MinAlt.Value > MaxAlt.Value)
            {
                await e.IqErrorBadRequest(e.To, "Minimum altitude cannot be larger than the maximum altitude.", "en");
                return;
            }
 
            if (MaxCount <= 0)
            {
                await e.IqErrorBadRequest(e.To, "Invalid maximum number of items to return.", "en");
                return;
            }
 
            if (Offset < 0)
            {
                await e.IqErrorBadRequest(e.To, "Invalid offset.", "en");
                return;
            }
 
            if (string.IsNullOrEmpty(Pattern))
                ParsedPattern = null;
            else
            {
                try
                {
                    ParsedPattern = new Regex(Pattern, RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.CultureInvariant);
                }
                catch (Exception ex)
                {
                    await e.IqErrorBadRequest(e.To, "Invalid regular expression pattern: " + ex.Message, "en");
                    return;
                }
            }
 
            if (string.IsNullOrEmpty(Path))
                Prefixes = null;
            else
            {
                Prefixes = new Dictionary<string, string>();
 
                foreach (XmlNode N in e.Query.ChildNodes)
                {
                    if (N is XmlElement E &&
                        E.LocalName == "namespace" &&
                        E.NamespaceURI == e.Query.NamespaceURI)
                    {
                        string Prefix = XML.Attribute(E, "prefix");
                        string Value = XML.Attribute(E, "value");
 
                        Prefixes[Prefix] = Value;
                    }
                }
            }
 
            if (MaxCount > maxSearchResults)
                MaxCount = maxSearchResults;
 
            GeoBoundingBox Box = new GeoBoundingBox(
                new GeoPosition(MinLat, MinLon, MinAlt),
                new GeoPosition(MaxLat, MaxLon, MaxAlt));
 
            Predicate<PersistedGeoSpatialObjectReference> XPathFilter;
 
            if (Prefixes is null)
                XPathFilter = null;
            else
            {
                XPathFilter = (Obj) =>
                {
                    if (string.IsNullOrEmpty(Obj.ContentXml))
                        return false;
 
                    try
                    {
                        XmlDocument Doc = XML.ParseXml(Obj.ContentXml);
 
                        XmlNamespaceManager NamespaceManager = new XmlNamespaceManager(Doc.NameTable);
 
                        foreach (KeyValuePair<string, string> P in Prefixes)
                        {
                            if (!NamespaceManager.HasNamespace(P.Key))
                                NamespaceManager.AddNamespace(P.Key, P.Value);
                        }
 
                        return !(Doc.DocumentElement.SelectSingleNode(Path, NamespaceManager) is null);
                    }
                    catch (Exception)
                    {
                        return false;
                    }
                };
            }
 
            // Using semaphore to restrict searches to one at a time, per Bare JID.
            using Semaphore Semaphore = await Semaphores.BeginWrite("search:" + e.From.BareJid);
 
            PersistedGeoSpatialObjectReference[] Result = this.geoPositions.Find(Box,
                Offset, MaxCount, ParsedPattern, XPathFilter);
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<references xmlns='");
            Xml.Append(e.Query.NamespaceURI);
            Xml.Append("' maxCount='");
            Xml.Append(MaxCount);
            Xml.Append('>');
 
            foreach (PersistedGeoSpatialObjectReference Ref in Result)
                Ref.Serialize(Xml);
 
            Xml.Append("</references>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
    }
}