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 timepoint = DateTime.MaxValue;
        private Duration recurrence = Duration.Zero;
 
        public TimedEventNode()
            : base()
        {
        }
 
        public abstract Task<EventTimepoint> GetEventTimepoint(EvaluationArguments Arguments);
 
        public class EventTimepoint
        {
            public EventTimepoint()
            {
                this.Current = DateTime.Now;
                this.Next = DateTime.MaxValue;
                this.Duration = Duration.Zero;
            }
 
            public EventTimepoint(DateTime Next)
            {
                this.Current = DateTime.Now;
                this.Next = Next.ToLocalTime();
                this.Duration = Duration.Zero;
            }
 
            public EventTimepoint(Duration Duration)
            {
                this.Current = DateTime.Now;
                this.Next = this.Current + Duration;
                this.Duration = Duration;
            }
 
            public EventTimepoint(DateTime Next, Duration Duration)
            {
                this.Current = DateTime.Now;
                this.Next = Next.ToLocalTime();
                this.Duration = Duration;
            }
 
            public EventTimepoint(DateTime Current, DateTime Next, Duration Duration)
            {
                this.Current = Current;
                this.Next = Next.ToLocalTime();
                this.Duration = Duration;
            }
 
            public DateTime Current { get; }
 
            public DateTime Next { get; }
 
            public Duration Duration { get; }
        }
 
        public override async Task<bool> Register(int EventIndex, EvaluationArguments Arguments, OnEvent Event)
        {
            EventTimepoint TP = await this.GetEventTimepoint(Arguments);
 
            this.timepoint = TP.Next;
            this.recurrence = Event.HasNewState ? Duration.Zero : TP.Duration;
 
            if (this.timepoint <= DateTime.Now)
                return true;
 
            if (this.timepoint == DateTime.MaxValue)
                return false;
 
            TimepointEventHandler Handler = new TimepointEventHandler(Arguments, EventIndex, this.timepoint, this.recurrence);
            await Database.Insert(Handler);
 
            this.timepoint = pendingEvents.Add(this.timepoint, this.EventElapsed, Handler);
 
            this.AddIntervalToProfiler(TP, Arguments.Profiler);
 
            return false;
        }
 
        public async Task ReregisterOnStart(TimepointEventHandler Handler)
        {
            EventTimepoint TP = new EventTimepoint(Handler.Timepoint, Handler.Recurrence);
 
            this.timepoint = Handler.Timepoint.ToLocalTime();
            this.recurrence = Handler.Recurrence;
 
            if (this.timepoint <= DateTime.Now)
                await this.EventElapsed(Handler);
            else if (this.timepoint < DateTime.MaxValue)
                this.timepoint = pendingEvents.Add(this.timepoint, this.EventElapsed, Handler);
        }
 
        private void AddIntervalToProfiler(EventTimepoint TP, Profiler Profiler)
        {
            if (Profiler is null)
                return;
 
            string Label;
 
            if (TP.Duration > Duration.Zero)
                Label = TP.Duration.ToString();
            else
            {
                TimeSpan TS = TP.Next - TP.Current;
                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";
                            }
                        }
                    }
                }
            }
 
            Profiler.Interval(TP.Current, TP.Next, Label);
        }
 
        public void Register(TimepointEventHandler Handler)
        {
            this.recurrence = Handler.Recurrence;
            this.timepoint = pendingEvents.Add(Handler.Timepoint, this.EventElapsed, Handler);
        }
 
        public override Task Unregister(int EventIndex, EvaluationArguments Arguments)
        {
            if (this.timepoint != DateTime.MaxValue)
            {
                pendingEvents.Remove(this.timepoint);
                this.timepoint = 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.CacheRecord Record = null;
            Duration Recurrence = Handler.Recurrence;
            bool Recurring = Recurrence > Duration.Zero;
            DateTime From = Handler.Timepoint;
 
            try
            {
                Record = await StateMachineProcessor.EventRaised(Handler, null, null);
 
                if (Recurring && !(Record is null))
                {
                    do
                    {
                        Handler.Timepoint += Recurrence;
                    }
                    while (Handler.Timepoint <= DateTime.Now);
 
                    this.recurrence = Recurrence;
                    this.timepoint = pendingEvents.Add(Handler.Timepoint, this.EventElapsed, Handler);
 
                    this.AddIntervalToProfiler(new EventTimepoint(From, Handler.Timepoint, Recurrence), Record.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.Profiler is null))
                {
                    int NoteNr = Record.Profiler.AddNote(ex);
                    Record.Profiler?.Exception(ex, "Note" + NoteNr);
                }
            }
        }
 
        internal static void ClearPendingEvents()
        {
            pendingEvents.Clear();
        }
    }
}