TimedEventNode.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Events;
using Waher.Persistence;
using Waher.Runtime.Profiling;
using Waher.Runtime.Timing;
using Waher.Service.IoTBroker.StateMachines.EventHandlers;
using Waher.Service.IoTBroker.StateMachines.Model.States;
 
namespace Waher.Service.IoTBroker.StateMachines.Model.Events
{
    public abstract class TimedEventNode : EventNode
    {
        private static readonly Scheduler pendingEvents = new Scheduler();
 
        private DateTime timepointUtc = DateTime.MaxValue;
        private Duration recurrence = Duration.Zero;
 
        public TimedEventNode()
            : base()
        {
        }
 
        public abstract Task<EventTimepointUtc> GetEventTimepointUtc(EvaluationArguments Arguments);
 
        public class EventTimepointUtc
        {
            public EventTimepointUtc()
            {
                this.CurrentUtc = DateTime.UtcNow;
                this.NextUtc = DateTime.MaxValue;
                this.Duration = Duration.Zero;
            }
 
            public EventTimepointUtc(DateTime Next)
            {
                this.CurrentUtc = DateTime.UtcNow;
                this.NextUtc = Next.Kind == DateTimeKind.Utc ? Next : Next.ToUniversalTime();
                this.Duration = Duration.Zero;
            }
 
            public EventTimepointUtc(Duration Duration)
            {
                this.CurrentUtc = DateTime.UtcNow;
                this.NextUtc = this.CurrentUtc + Duration;
                this.Duration = Duration;
            }
 
            public EventTimepointUtc(DateTime Next, Duration Duration)
            {
                this.CurrentUtc = DateTime.UtcNow;
                this.NextUtc = Next.Kind == DateTimeKind.Utc ? Next : Next.ToUniversalTime();
                this.Duration = Duration;
            }
 
            public EventTimepointUtc(DateTime Current, DateTime Next, Duration Duration)
            {
                this.CurrentUtc = Current.Kind == DateTimeKind.Utc ? Current : Current.ToUniversalTime();
                this.NextUtc = Next.Kind == DateTimeKind.Utc ? Next : Next.ToUniversalTime();
                this.Duration = Duration;
            }
 
            public DateTime CurrentUtc { get; }
 
            public DateTime NextUtc { get; }
 
            public Duration Duration { get; }
        }
 
        public override async Task<EventHandlerReference> Register(int EventIndex,
            EvaluationArguments Arguments, OnEvent Event)
        {
            EventTimepointUtc TP = await this.GetEventTimepointUtc(Arguments);
 
            this.timepointUtc = TP.NextUtc;
            this.recurrence = Event.HasNewState ? Duration.Zero : TP.Duration;
 
            if (this.timepointUtc == DateTime.MaxValue)
                return null;
 
            if (this.timepointUtc <= DateTime.UtcNow)
                return new EventHandlerReference(null, true);
 
            TimepointEventHandler Handler = new TimepointEventHandler(Arguments, EventIndex, this.timepointUtc, this.recurrence);
            await Database.Insert(Handler);
 
            this.timepointUtc = pendingEvents.Add(this.timepointUtc, this.EventElapsed, Handler);
 
            bool SuppressSamples;
 
            try
            {
                SuppressSamples = await Event.GetSuppressSample(Arguments);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                SuppressSamples = false;
            }
 
            if (!SuppressSamples)
                this.AddIntervalToProfiler(TP, Arguments.Profiler);
 
            return null;
        }
 
        public async Task ReregisterOnStart(TimepointEventHandler Handler)
        {
            EventTimepointUtc TP = new EventTimepointUtc(Handler.Timepoint, Handler.Recurrence);
 
            this.timepointUtc = Handler.Timepoint;
            this.recurrence = Handler.Recurrence;
 
            if (this.timepointUtc <= DateTime.UtcNow)
                await this.EventElapsed(Handler);
            else if (this.timepointUtc < DateTime.MaxValue)
                this.timepointUtc = pendingEvents.Add(this.timepointUtc, this.EventElapsed, Handler);
        }
 
        private void AddIntervalToProfiler(EventTimepointUtc TP, Profiler Profiler)
        {
            if (Profiler is null)
                return;
 
            string Label;
 
            if (TP.Duration > Duration.Zero)
                Label = TP.Duration.ToString();
            else
            {
                TimeSpan TS = TP.NextUtc - TP.CurrentUtc;
                double d = TS.TotalDays;
                if (d > 1)
                    Label = d.ToString("F2") + " days";
                else
                {
                    d = TS.TotalHours;
                    if (d > 1)
                        Label = d.ToString("F2") + " h";
                    else
                    {
                        d = TS.TotalMinutes;
                        if (d > 1)
                            Label = d.ToString("F2") + " min";
                        else
                        {
                            d = TS.TotalSeconds;
                            if (d > 1)
                                Label = d.ToString("F2") + " s";
                            else
                            {
                                d = TS.TotalMilliseconds;
                                Label = d.ToString("F2") + " ms";
                            }
                        }
                    }
                }
            }
 
            if (TP.NextUtc != DateTime.MaxValue)
                Profiler.Interval(TP.CurrentUtc, TP.NextUtc, Label);
        }
 
        public void Register(TimepointEventHandler Handler)
        {
            this.recurrence = Handler.Recurrence;
            this.timepointUtc = pendingEvents.Add(Handler.Timepoint, this.EventElapsed, Handler);
        }
 
        public override Task Unregister(int EventIndex, EvaluationArguments Arguments)
        {
            if (this.timepointUtc != DateTime.MaxValue)
            {
                pendingEvents.Remove(this.timepointUtc);
                this.timepointUtc = DateTime.MaxValue;
                this.recurrence = Duration.Zero;
            }
 
            return Task.CompletedTask;  // Do nothing by default.
        }
 
        private Task EventElapsed(object State)
        {
            return this.EventElapsed((TimepointEventHandler)State);
        }
 
        public async Task EventElapsed(TimepointEventHandler Handler)
        {
            StateMachineProcessor.EventRecord Record = null;
            Duration Recurrence = Handler.Recurrence;
            bool Recurring = Recurrence > Duration.Zero;
            DateTime From = Handler.Timepoint;
 
            try
            {
                Record = await StateMachineProcessor.ProcessEvent(Handler, null, null);
 
                if (Recurring && !(Record is null))
                {
                    DateTime UtcNow = DateTime.UtcNow;
 
                    do
                    {
                        Handler.Timepoint += Recurrence;
                    }
                    while (Handler.Timepoint <= UtcNow);
 
                    this.recurrence = Recurrence;
                    this.timepointUtc = pendingEvents.Add(Handler.Timepoint, this.EventElapsed, Handler);
 
                    if (!Record.SuppressSamples)
                        this.AddIntervalToProfiler(new EventTimepointUtc(From, Handler.Timepoint, Recurrence), Record.CacheRecord.Profiler);
 
                    await Database.Update(Handler);
                }
                else
                    await Database.Delete(Handler);
            }
            catch (KeyNotFoundException)
            {
                // Already deleted, since state changed.
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
 
                if (!(Record.CacheRecord.Profiler is null) && !Record.SuppressSamples)
                {
                    int NoteNr = Record.CacheRecord.Profiler.AddNote(ex);
                    Record.CacheRecord.Profiler?.Exception(ex, "Note" + NoteNr);
                }
            }
        }
 
        internal static void ClearPendingEvents()
        {
            pendingEvents.Clear();
        }
    }
}