StateMachine.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Persistence.Filters;
using Waher.Runtime.Collections;
using Waher.Runtime.Profiling;
using Waher.Script;
using Waher.Service.IoTBroker.EDaler;
using Waher.Service.IoTBroker.Legal;
using Waher.Service.IoTBroker.NeuroFeatures;
using Waher.Service.IoTBroker.NeuroFeatures.WebServices;
using Waher.Service.IoTBroker.StateMachines.EventHandlers;
using Waher.Service.IoTBroker.StateMachines.Exceptions;
using Waher.Service.IoTBroker.StateMachines.Model;
using Waher.Service.IoTBroker.StateMachines.Model.Actions;
using Waher.Service.IoTBroker.StateMachines.Model.Actions.Runtime;
using Waher.Service.IoTBroker.StateMachines.Model.Events;
using Waher.Service.IoTBroker.StateMachines.Model.States;
using Waher.Things;
 
namespace Waher.Service.IoTBroker.StateMachines
{
    [CollectionName("StateMachines")]
    [TypeName(TypeNameSerialization.FullName)]
    [ArchivingTime(nameof(ArchiveDays))]
    [Index("StateMachineId")]
    [Index("CreatorTokenId")]
    [Index("Expires", "StateMachineId")]
    [ObsoleteMethod(nameof(SetObsoleteProperties))]
    public class StateMachine : IContextVariables, IRequestOrigin
    {
        private Dictionary<string, Model.Actions.Action> actions;
        private Dictionary<string, Model.Events.Event> events;
        private Dictionary<string, State> states;
 
        [ObjectId]
        public string ObjectId { get; set; }
 
        public CaseInsensitiveString StateMachineId { get; set; }
 
        public CaseInsensitiveString CreatorTokenId { get; set; }
 
        public StateMachineRoot Root { get; set; }
 
        public DateTime Expires { get; set; }
 
        public string XmlDefinition { get; set; }
 
        public CaseInsensitiveString DefinitionContractId { get; set; }
 
        public CaseInsensitiveString TrustProvider { get; set; }
 
        public CaseInsensitiveString TrustProviderJid { get; set; }
 
        [DefaultValueNull]
        public Duration? ArchiveRequired { get; set; }
 
        [DefaultValueNull]
        public Duration? ArchiveOptional { get; set; }
 
        public int ArchiveDays => Token.CalcArchiveDays(this.Expires, this.ArchiveRequired, this.ArchiveOptional);
 
        public void IndexElements()
        {
            this.actions = new Dictionary<string, Model.Actions.Action>();
            this.events = new Dictionary<string, Model.Events.Event>();
            this.states = new Dictionary<string, State>();
 
            this.Root?.ForEach((Node, State) =>
            {
                Node.IndexElement(this);
                return true;
            }, null);
        }
 
        public void Index(Model.Actions.Action Action)
        {
            if (this.actions.ContainsKey(Action.Id))
                throw new StateMachineException(this, "Duplicate Action ID: " + Action.Id);
 
            this.actions[Action.Id] = Action;
        }
 
        public void Index(Model.Events.Event Event)
        {
            if (this.events.ContainsKey(Event.Id))
                throw new StateMachineException(this, "Duplicate Event ID: " + Event.Id);
 
            this.events[Event.Id] = Event;
        }
 
        public void Index(State State)
        {
            if (this.states.ContainsKey(State.Id))
                throw new StateMachineException(this, "Duplicate State ID: " + State.Id);
 
            this.states[State.Id] = State;
        }
 
        public void CheckReferences(Token Token)
        {
            this.IndexElements();
 
            this.Root?.ForEach((Node, State) =>
            {
                Node.CheckReferences(this, Token);
                return true;
            }, null);
        }
 
        public bool TryGetAction(string Id, out Model.Actions.Action Action)
        {
            if (Id is null)
            {
                Action = null;
                return false;
            }
            else
                return this.actions.TryGetValue(Id, out Action);
        }
 
        public bool TryGetEvent(string Id, out Model.Events.Event Event)
        {
            if (Id is null)
            {
                Event = null;
                return false;
            }
            else
                return this.events.TryGetValue(Id, out Event);
        }
 
        public bool TryGetState(string Id, out State State)
        {
            if (Id is null)
            {
                State = null;
                return false;
            }
            else
                return this.states.TryGetValue(Id, out State);
        }
 
        public async Task<(CurrentState, EvaluationArguments)> CreateCurrentState(Token Token, 
            LegalComponent Legal, EDalerComponent EDaler, Profiler Profiler)
        {
            List<CurrentStateVariable> VariableValues = new List<CurrentStateVariable>();
            CurrentState CurrentState = await StateMachineProcessor.GetOrCreateCurrentState(this, false);
            Variables Variables = CurrentState.GetVariables(this);
            EvaluationArguments Arguments = new EvaluationArguments(Variables, this, Token, CurrentState, Legal, EDaler, Profiler);
            List<StateMachineSample> Samples = null;
 
            if (!(this.Root.ChildNodes is null))
            {
                foreach (IStateMachineNode Node in this.Root.ChildNodes)
                {
                    if (Node is Model.Variable Variable)
                    {
                        try
                        {
                            object Value = await Variable.Evaluate(Arguments);
 
                            Variables[Variable.Id] = Value;
                            VariableValues.Add(new CurrentStateVariable(Variable.Id, Value));
 
                            Samples ??= new List<StateMachineSample>();
                            Samples.Add(new StateMachineSample()
                            {
                                Variable = Variable.Id,
                                Timestamp = DateTime.UtcNow,
                                Value = Value,
                                StateMachineId = this.StateMachineId,
                                Expires = this.Expires,
                                ArchiveOptional = this.ArchiveOptional,
                                ArchiveRequired = this.ArchiveRequired
                            });
                        }
                        catch (Exception ex)
                        {
                            Log.Critical("Unable to evaluate inital value for variable " +
                                Variable.Id + " for state-machine. Error reported: " + ex.Message, this.ObjectId);
 
                            await Database.Insert(new StateMachineSample()
                            {
                                Variable = StateMachineSample.ExceptionVariable,
                                Timestamp = DateTime.UtcNow,
                                Value = ex.Message,
                                StateMachineId = Arguments.Machine.StateMachineId,
                                Expires = Arguments.Machine.Expires,
                                ArchiveOptional = Arguments.Machine.ArchiveOptional,
                                ArchiveRequired = Arguments.Machine.ArchiveRequired
                            });
                        }
                    }
                }
            }
 
            CurrentState.VariableValues = VariableValues.ToArray();
 
            await Database.Update(CurrentState);
 
            if (!(Samples is null))
                await Database.Insert(Samples.ToArray());
 
            return (CurrentState, Arguments);
        }
 
        public async Task Start(EvaluationArguments Arguments)
        { 
            await GoToState(this.Root.StartState, Arguments);
        }
 
        public static async Task GoToState(string StateId, EvaluationArguments Arguments)
        {
            DateTime Start = DateTime.Now;
 
            try
            {
                do
                {
                    bool NewState = StateId != Arguments.CurrentState.State;
 
                    if (!string.IsNullOrEmpty(Arguments.CurrentState.State) &&
                        Arguments.Machine.TryGetState(Arguments.CurrentState.State, out State State))
                    {
                        if (NewState)
                            await UnregisterEventHandlers(State.OnEvent, Arguments);
 
                        await ExecuteLog(State.OnLeave, Arguments, false);
                    }
 
                    State = null;
 
                    if (!string.IsNullOrEmpty(StateId) && !Arguments.Machine.TryGetState(StateId, out State))
                        throw new StateMachineException(Arguments.Machine, "State not found:" + StateId);
 
                    if (NewState)
                    {
                        Arguments.SetState(StateId);
 
                        await Database.Insert(new StateMachineSample()
                        {
                            Variable = StateMachineSample.CurrentStateVariable,
                            Timestamp = DateTime.UtcNow,
                            Value = StateId,
                            StateMachineId = Arguments.Machine.StateMachineId,
                            Expires = Arguments.Machine.Expires,
                            ArchiveOptional = Arguments.Machine.ArchiveOptional,
                            ArchiveRequired = Arguments.Machine.ArchiveRequired
                        });
 
                        if (string.IsNullOrEmpty(StateId))
                            await ScheduledAction.DeleteScheduledActions(Arguments.Machine.StateMachineId);
                    }
 
                    StateId = null;
 
                    if (!(State is null))
                    {
                        ChunkedList<EventHandlerReference> EventsTriggered = null;
 
                        try
                        {
                            await ExecuteLog(State.OnEnter, Arguments, false);
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex, Arguments.Token?.TokenId ?? Arguments.Machine.StateMachineId);
 
                            await Database.Insert(new StateMachineSample()
                            {
                                Variable = StateMachineSample.ExceptionVariable,
                                Timestamp = DateTime.UtcNow,
                                Value = ex.Message,
                                StateMachineId = Arguments.Machine.StateMachineId,
                                Expires = Arguments.Machine.Expires,
                                ArchiveOptional = Arguments.Machine.ArchiveOptional,
                                ArchiveRequired = Arguments.Machine.ArchiveRequired
                            });
                        }
 
                        if (NewState)
                            EventsTriggered = await RegisterEventHandlers(State.OnEvent, Arguments);
 
                        if (!(EventsTriggered is null))
                        {
                            foreach (EventHandlerReference Ref in EventsTriggered)
                            {
                                OnEvent EventTriggered = Ref.Event;
                                if (!(EventTriggered is null))
                                {
                                    try
                                    {
                                        await Ref.Prepare(Arguments);
 
                                        bool SuppressSamples = await EventTriggered.GetSuppressSample(Arguments);
                                        await EventTriggered.ExecuteLog(Arguments, SuppressSamples);
                                        StateId = await EventTriggered.GetNewState(Arguments);
                                    }
                                    catch (Exception ex)
                                    {
                                        StateId = await EventTriggered.GetFailureState(Arguments);
 
                                        if (string.IsNullOrEmpty(StateId))
                                        {
                                            Log.Error(ex, Arguments.Machine.ObjectId);
 
                                            await Database.Insert(new StateMachineSample()
                                            {
                                                Variable = StateMachineSample.ExceptionVariable,
                                                Timestamp = DateTime.UtcNow,
                                                Value = ex.Message,
                                                StateMachineId = Arguments.Machine.StateMachineId,
                                                Expires = Arguments.Machine.Expires,
                                                ArchiveOptional = Arguments.Machine.ArchiveOptional,
                                                ArchiveRequired = Arguments.Machine.ArchiveRequired
                                            });
                                        }
                                    }
 
                                    if (!string.IsNullOrEmpty(StateId))
                                        break;
                                }
                            }
 
                            double ElapsedTimeSeconds = DateTime.Now.Subtract(Start).TotalMinutes;
 
                            if (ElapsedTimeSeconds > 60)
                            {
                                Log.Error("State change exceeds maximum allotted time.", Arguments.Machine.ObjectId,
                                    new KeyValuePair<string, object>("StateMachineId", Arguments.Machine.StateMachineId),
                                    new KeyValuePair<string, object>("ElapsedTimeSeconds", ElapsedTimeSeconds));
 
                                return;
                            }
                        }
                    }
                }
                while (!string.IsNullOrEmpty(StateId));
            }
            finally
            {
                await EvaluationComplete(Arguments);
            }
        }
 
        public static async Task EvaluationComplete(EvaluationArguments Arguments)
        {
            bool StateUpdated = Arguments.StateUpdated;
            bool VariablesUpdated = Arguments.VariablesUpdated;
            bool AuthorizationsUpdated = Arguments.AuthorizationsUpdated;
 
            if (StateUpdated || VariablesUpdated || AuthorizationsUpdated)
            {
                await Database.Update(Arguments.CurrentState);
 
                Arguments.AuthorizationsUpdated = false;
 
                if (StateUpdated)
                {
                    Arguments.StateUpdated = false;
 
                    if (!(Arguments.Token is null))
                    {
                        StringBuilder Xml = new StringBuilder();
                        string OwnerJid = Arguments.Token.OwnerJid;
 
                        Xml.Append("<stateUpdated xmlns='");
                        Xml.Append(StateMachineProcessor.StateMachineNamespace);
                        Xml.Append("' tokenId='");
                        Xml.Append(XML.Encode(Arguments.Token.TokenId));
                        Xml.Append("' machineId='");
                        Xml.Append(XML.Encode(Arguments.Machine.StateMachineId));
                        Xml.Append("' state='");
                        Xml.Append(XML.Encode(Arguments.CurrentState.State));
                        Xml.Append("'/>");
 
                        _ = Task.Run(async () =>
                        {
                            try
                            {
                                await Arguments.EDaler.Server.SendMessage(string.Empty, string.Empty, Arguments.EDaler.MainDomain,
                                    new XmppAddress(OwnerJid), string.Empty, Xml.ToString());
                            }
                            catch (Exception ex)
                            {
                                Log.Exception(ex);
                            }
                        });
                    }
                }
 
                if (VariablesUpdated)
                {
                    if (Arguments.Token is null)
                        Arguments.ClearUpdatedVariables();
                    else
                    {
                        KeyValuePair<string, object>[] Variables = Arguments.PopUpdatedVariables();
                        StringBuilder Xml = new StringBuilder();
                        string OwnerJid = Arguments.Token.OwnerJid;
 
                        Xml.Append("<variablesUpdated xmlns='");
                        Xml.Append(StateMachineProcessor.StateMachineNamespace);
                        Xml.Append("' tokenId='");
                        Xml.Append(XML.Encode(Arguments.Token.TokenId));
                        Xml.Append("' machineId='");
                        Xml.Append(XML.Encode(Arguments.Machine.StateMachineId));
                        Xml.Append("'>");
 
                        foreach (KeyValuePair<string, object> P in Variables)
                            StateMachineProcessor.AppendVariable(Xml, P.Key, P.Value);
 
                        Xml.Append("</variablesUpdated>");
 
                        _ = Task.Run(async () =>
                        {
                            try
                            {
                                await Arguments.EDaler.Server.SendMessage(string.Empty, string.Empty, Arguments.EDaler.MainDomain,
                                    new XmppAddress(OwnerJid), string.Empty, Xml.ToString());
                            }
                            catch (Exception ex)
                            {
                                Log.Exception(ex);
                            }
                        });
                    }
                }
 
                if (Arguments.Token?.IsPublic ?? false)
                {
                    string[] TabIDs = ClientEvents.GetTabIDsForLocation("/NF/" + Arguments.Token.TokenId);
 
                    if ((TabIDs?.Length ?? 0) > 0)
                        await PublicTokenView.UpdatePresent(TabIDs, Arguments.Token);
                }
            }
        }
 
        public static async Task CheckConditionalEvents(EvaluationArguments Arguments)
        {
            if (!Arguments.Machine.TryGetState(Arguments.CurrentState.State, out State State))
                return;
 
            if (!(State.OnEvent is null))
            {
                foreach (OnEvent Event in State.OnEvent)
                {
                    EventHandlerReference Ref = await Event.StateUpdated(Arguments);
 
                    if (Ref?.Triggered ?? false)
                    {
                        string StateId;
 
                        try
                        {
                            await Ref.Prepare(Arguments);
 
                            bool SuppressSamples = await Event.GetSuppressSample(Arguments);
                            await Event.ExecuteLog(Arguments, SuppressSamples);
                            StateId = await Event.GetNewState(Arguments);
                        }
                        catch (Exception ex)
                        {
                            StateId = await Event.GetFailureState(Arguments);
 
                            if (string.IsNullOrEmpty(StateId))
                            {
                                Log.Error(ex, Arguments.Machine.ObjectId);
 
                                await Database.Insert(new StateMachineSample()
                                {
                                    Variable = StateMachineSample.ExceptionVariable,
                                    Timestamp = DateTime.UtcNow,
                                    Value = ex.Message,
                                    StateMachineId = Arguments.Machine.StateMachineId,
                                    Expires = Arguments.Machine.Expires,
                                    ArchiveOptional = Arguments.Machine.ArchiveOptional,
                                    ArchiveRequired = Arguments.Machine.ArchiveRequired
                                });
                            }
                        }
 
                        if (!string.IsNullOrEmpty(StateId))
                        {
                            await GoToState(StateId, Arguments);
                            break;
                        }
                    }
                }
            }
        }
 
        public static async Task ExecuteLog(ActionReference[] ActionReferences, EvaluationArguments Arguments, bool SuppressSamples)
        {
            if (ActionReferences is null)
                return;
 
            foreach (ActionReference Action in ActionReferences)
                await Action.ExecuteLog(Arguments, SuppressSamples);
        }
 
        public static async Task<ChunkedList<EventHandlerReference>> RegisterEventHandlers(OnEvent[] Events, EvaluationArguments Arguments)
        {
            if (Events is null)
                return null;
 
            int i = 0;
            ChunkedList<EventHandlerReference> Result = null;
 
            foreach (OnEvent Event in Events)
            {
                try
                {
                    EventHandlerReference Ref = await Event.Register(i++, Arguments);
                    if (Ref?.Triggered ?? false)
                    {
                        Ref.Event = Event;
 
                        Result ??= new ChunkedList<EventHandlerReference>();
                        Result.Add(Ref);
                    }
                }
                catch (Exception ex)
                {
                    ex = Log.UnnestException(ex);
 
                    string MachineId = Event.StateMachine.StateMachineId;
                    string CurrentState = await StateMachineProcessor.GetCurrentState(MachineId);
 
                    Log.Error("Unable to register event handlers for state machine.",
                        new KeyValuePair<string, object>("State Machine ID", MachineId),
                        new KeyValuePair<string, object>("State", CurrentState),
                        new KeyValuePair<string, object>("Messge", ex.Message),
                        new KeyValuePair<string, object>("Event", Event.Event.Label),
                        new KeyValuePair<string, object>("Local Name", Event.Event.LocalName),
                        new KeyValuePair<string, object>("Namespace", Event.Event.Namespace));
 
                    await Database.Insert(new StateMachineSample()
                    {
                        Variable = StateMachineSample.ExceptionVariable,
                        Timestamp = DateTime.UtcNow,
                        Value = ex.Message,
                        StateMachineId = Arguments.Machine.StateMachineId,
                        Expires = Arguments.Machine.Expires,
                        ArchiveOptional = Arguments.Machine.ArchiveOptional,
                        ArchiveRequired = Arguments.Machine.ArchiveRequired
                    });
                }
            }
 
            return Result;
        }
 
        public static async Task UnregisterEventHandlers(OnEvent[] Events, EvaluationArguments Arguments)
        {
            IEnumerable<EventHandlers.EventHandler> Handlers = await Database.FindDelete<EventHandlers.EventHandler>(new FilterAnd(
                new FilterFieldEqualTo("StateMachineId", Arguments.CurrentState.StateMachineId),
                new FilterFieldEqualTo("State", Arguments.CurrentState.State)));
 
            foreach (EventHandlers.EventHandler Handler in Handlers)
            {
                if (Handler is CachedEventHandler CachedEventHandler)
                    await CachedEventHandler.RemoveFromCache();
            }
 
            if (Events is null)
                return;
 
            int i = 0;
 
            foreach (OnEvent Event in Events)
                await Event.Unregister(i, Arguments);
        }
 
        public bool TryGetVariable(string Name, out Script.Variable Variable)
        {
            switch (Name)
            {
                case "this":
                    Variable = new Script.Variable("this", this);
                    return true;
 
                default:
                    Variable = null;
                    return false;
            }
        }
 
        public bool ContainsVariable(string Name)
        {
            return Name == "this";
        }
 
        public Waher.Script.Variable Add(string Name, object Value)
        {
            throw new NotSupportedException("Variable collection is read-only.");
        }
 
        public async Task<RequestOrigin> GetOrigin()
        {
            Token Token = await NeuroFeaturesProcessor.GetToken(this.CreatorTokenId, true);
            string OwnerJid = Token?.OwnerJid.Value ?? string.Empty;
 
            return new RequestOrigin(OwnerJid, null, null, null, this);
        }
 
        public bool HasPrivilege(string Privilege)
        {
            return false;
        }
 
        public async Task ReparseDefinition()
        {
            XmlDocument Doc = XML.ParseXml(this.XmlDefinition);
 
            this.Root = (StateMachineRoot)await StateMachineProcessor.Create(Doc.DocumentElement);
 
            this.IndexElements();
        }
 
        public void SetObsoleteProperties(Dictionary<string, object> Properties)
        {
            foreach (KeyValuePair<string, object> Property in Properties)
            {
                switch (Property.Key)
                {
                    case "XmlDefinnition":
                        if (Property.Value is string s)
                            this.XmlDefinition = s;
                        break;
                }
            }
        }
    }
}