MeteringTopology.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Networking;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Language;
using Waher.Runtime.Settings;
using Waher.Things.Metering.NodeTypes;
using Waher.Things.SensorData;
using Waher.Things.SourceEvents;
 
namespace Waher.Things.Metering
{
    public delegate Task NewMomentaryValuesHandler(IThingReference Reference, IEnumerable<Field> Values);
 
    public class MeteringTopology : IDataSource
    {
        public const string SourceID = "MeteringTopology";
 
        private static readonly Dictionary<string, MeteringNode> nodes = new Dictionary<string, MeteringNode>();
        private static Root root = null;
        private static MeteringTopology instance = null;
 
        private DateTime lastChanged;
 
        public MeteringTopology()
        {
            this.lastChanged = RuntimeSettings.Get(SourceID + ".LastChanged", DateTime.MinValue);
 
            if (instance is null)
                instance = this;
        }
 
        string IDataSource.SourceID
        {
            get { return SourceID; }
        }
 
        public IEnumerable<IDataSource> ChildSources
        {
            get { return null; }
        }
 
        public bool HasChildren
        {
            get { return false; }
        }
 
        public DateTime LastChanged
        {
            get => this.lastChanged;
            internal set
            {
                if (this.lastChanged != value)
                {
                    this.lastChanged = value;
                    Task _ = RuntimeSettings.SetAsync("MeteringTopology.LastChanged", value);
                }
            }
        }
 
        public Task<string> GetNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(MeteringTopology), 13, "Metering Topology");
        }
 
        public async Task<INode> GetNodeAsync(IThingReference NodeRef)
        {
            return await GetNode(NodeRef);
        }
 
        public static Task<MeteringNode> GetNode(string NodeId)
        {
            return GetNode(new ThingReference(NodeId, SourceID));
        }
 
        public static async Task<MeteringNode> GetNode(IThingReference NodeRef)
        {
            if (NodeRef is null || NodeRef.SourceId != SourceID || !string.IsNullOrEmpty(NodeRef.Partition))
                return null;
 
            lock (nodes)
            {
                if (nodes.TryGetValue(NodeRef.NodeId, out MeteringNode Node))
                    return Node;
            }
 
            foreach (MeteringNode Node2 in await Database.Find<MeteringNode>(new FilterFieldEqualTo("NodeId", NodeRef.NodeId)))
            {
                lock (nodes)
                {
                    if (nodes.TryGetValue(NodeRef.NodeId, out MeteringNode Node))
                        return Node;
                    else
                    {
                        nodes[NodeRef.NodeId] = Node2;
                        return Node2;
                    }
                }
            }
 
            return null;
        }
 
        internal static MeteringNode RegisterNode(MeteringNode Node)
        {
            if (Node.SourceId == SourceID && string.IsNullOrEmpty(Node.Partition))
            {
                lock (nodes)
                {
                    if (nodes.TryGetValue(Node.NodeId, out MeteringNode Node2))
                        return Node2;
                    else
                    {
                        nodes[Node.NodeId] = Node;
                        return Node;
                    }
                }
            }
            else
                return Node;
        }
 
        internal static MeteringNode RegisterNewNodeId(MeteringNode Node, string OldId)
        {
            if (Node.SourceId != SourceID || !string.IsNullOrEmpty(Node.Partition))
                return Node;
 
            lock (nodes)
            {
                if (!nodes.TryGetValue(OldId, out MeteringNode Node2) || Node2 != Node)
                    return Node;
 
                if (nodes.TryGetValue(Node.NodeId, out Node2))
                    return Node2;
 
                nodes.Remove(OldId);
                nodes[Node.NodeId] = Node;
 
                return Node;
            }
        }
 
        internal static void UnregisterNode(MeteringNode Node)
        {
            if (Node.SourceId == SourceID && string.IsNullOrEmpty(Node.Partition))
            {
                lock (nodes)
                {
                    if (nodes.TryGetValue(Node.NodeId, out MeteringNode Node2) && Node == Node2)
                        nodes.Remove(Node.NodeId);
                }
            }
        }
 
        public Task<bool> CanViewAsync(RequestOrigin Caller)
        {
            return Task.FromResult(true);     // TODO: Check user privileges
        }
 
        public IEnumerable<INode> RootNodes
        {
            get
            {
                if (root is null)
                    LoadRoot().Wait();
 
                return new INode[] { root };
            }
        }
 
        public static Root Root
        {
            get
            {
                if (root is null)
                    LoadRoot().Wait();
 
                return root;
            }
        }
 
        private static async Task LoadRoot()
        {
            Root Result = null;
 
            foreach (MeteringNode Node in await Database.Find<MeteringNode>(new FilterFieldEqualTo("ParentId", Guid.Empty)))
            {
                if (Node is Root Root)
                {
                    if (Result is null)
                        Result = Root;
                    else
                        await Database.Delete(Node);
                }
            }
 
            if (Result is null)
            {
                Result = new Root()
                {
                    NodeId = await (await Translator.GetDefaultLanguageAsync()).GetStringAsync(typeof(MeteringTopology), 14, "Root")
                };
 
                await Database.Insert(Result);
 
                Language Language = await Translator.GetDefaultLanguageAsync();
                await NewEvent(new NodeAdded()
                {
                    Parameters = await Result.GetDisplayableParameterAraryAsync(Language, RequestOrigin.Empty),
                    NodeType = Result.GetType().FullName,
                    Sniffable = Result is ICommunicationLayer,
                    DisplayName = await Result.GetTypeNameAsync(Language),
                    HasChildren = Result.HasChildren,
                    ChildrenOrdered = Result.ChildrenOrdered,
                    IsReadable = Result.IsReadable,
                    IsControllable = Result.IsControllable,
                    HasCommands = Result.HasCommands,
                    ParentId = string.Empty,
                    ParentPartition = string.Empty,
                    Updated = Result.Updated,
                    State = Result.State,
                    NodeId = Result.NodeId,
                    Partition = Result.Partition,
                    LogId = NodeAdded.EmptyIfSame(Result.LogId, Result.NodeId),
                    LocalId = NodeAdded.EmptyIfSame(Result.LocalId, Result.NodeId),
                    SourceId = Result.SourceId,
                    Timestamp = DateTime.Now
                });
            }
 
            lock (nodes)
            {
                nodes[Result.NodeId] = Result;
            }
 
            root = Result;
        }
 
        public static async Task<int> DeleteOldEvents(TimeSpan MaxAge)
        {
            if (MaxAge <= TimeSpan.Zero)
                throw new ArgumentException("Age must be positive.", nameof(MaxAge));
 
            DateTime Limit = DateTime.Now.Subtract(MaxAge);
            int NrEvents = 0;
            bool Deleted;
 
            do
            {
                Deleted = false;
 
                foreach (SourceEvent Event in await Database.FindDelete<SourceEvent>(0, 100, new FilterAnd(
                    new FilterFieldEqualTo("SourceId", SourceID), new FilterFieldLesserOrEqualTo("Timestamp", Limit))))
                {
                    NrEvents++;
                    Deleted = true;
                }
            }
            while (Deleted);
 
            if (NrEvents > 0)
            {
                KeyValuePair<string, object>[] Tags = new KeyValuePair<string, object>[]
                {
                    new KeyValuePair<string, object>("Limit", Limit),
                    new KeyValuePair<string, object>("NrEvents", NrEvents)
                };
 
                if (NrEvents == 1)
                    Log.Informational("Deleting 1 metering topology event from the database.", SourceID, Tags);
                else
                    Log.Informational("Deleting " + NrEvents.ToString() + " metering topology events from the database.", SourceID, Tags);
            }
 
            return NrEvents;
        }
 
        public event EventHandlerAsync<SourceEvent> OnEvent = null;
 
        internal static async Task NewEvent(SourceEvent Event)
        {
            await Database.InsertLazy(Event);
            await instance?.OnEvent?.Raise(instance, Event);
        }
 
        public static Task NewMomentaryValues(IThingReference Reference, IEnumerable<Field> Values)
        {
            NewMomentaryValuesHandler h = OnNewMomentaryValues;
            if (h is null)
                return Task.CompletedTask;
            else
                return h(Reference, Values);
        }
 
        public static event NewMomentaryValuesHandler OnNewMomentaryValues = null;
 
        public static async Task<int> DeleteOrphans()
        {
            int Result = 0;
 
            foreach (MeteringNode Node in await Database.Find<MeteringNode>())
            {
                if (Node.ParentId == Guid.Empty)
                    continue;
 
                MeteringNode ParentNode = await Database.TryLoadObject<MeteringNode>(Node.ParentId);
                if (ParentNode is null)
                {
                    await Database.Delete(Node);
                    Result++;
 
                    lock (nodes)
                    {
                        nodes.Remove(Node.NodeId);
                    }
                }
            }
 
            return Result;
        }
 
    }
}