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.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Persistence.Filters;
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.StateMachines.EventHandlers;
using Waher.Service.IoTBroker.StateMachines.Model;
using Waher.Service.IoTBroker.StateMachines.Model.Actions;
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("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 Exception("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 Exception("Duplicate Event ID: " + Event.Id);
 
            this.events[Event.Id] = Event;
        }
 
        public void Index(State State)
        {
            if (this.states.ContainsKey(State.Id))
                throw new Exception("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);
            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));
 
                            if (Samples is null)
                                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);
                        }
                    }
                }
            }
 
            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);
                    }
 
                    State = null;
 
                    if (!string.IsNullOrEmpty(StateId) && !Arguments.Machine.TryGetState(StateId, out State))
                        throw new Exception("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
                        });
                    }
 
                    StateId = null;
 
                    if (!(State is null))
                    {
                        IEnumerable<OnEvent> EventsTriggered = null;
 
                        try
                        {
                            await ExecuteLog(State.OnEnter, Arguments);
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex, Arguments.Token?.TokenId ?? Arguments.Machine.StateMachineId);
                        }
 
                        if (NewState)
                            EventsTriggered = await RegisterEventHandlers(State.OnEvent, Arguments);
 
                        if (!(EventsTriggered is null))
                        {
                            foreach (OnEvent EventTriggered in EventsTriggered)
                            {
                                try
                                {
                                    await EventTriggered.ExecuteLog(Arguments);
                                    StateId = await EventTriggered.GetNewState(Arguments);
                                }
                                catch (Exception ex)
                                {
                                    StateId = await EventTriggered.GetFailureState(Arguments);
 
                                    if (string.IsNullOrEmpty(StateId))
                                        Log.Error(ex, Arguments.Machine.ObjectId);
                                }
 
                                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("'/>");
 
                        await Arguments.EDaler.Server.SendMessage(string.Empty, string.Empty, Arguments.EDaler.MainDomain,
                            new XmppAddress(OwnerJid), string.Empty, Xml.ToString());
 
                        if (VariablesUpdated)
                            Xml.Clear();
                    }
                }
 
                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>");
 
                        await Arguments.EDaler.Server.SendMessage(string.Empty, string.Empty, Arguments.EDaler.MainDomain,
                            new XmppAddress(OwnerJid), string.Empty, Xml.ToString());
                    }
                }
            }
        }
 
        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)
                {
                    if (await Event.StateUpdated(Arguments))
                    {
                        string StateId;
 
                        try
                        {
                            await Event.ExecuteLog(Arguments);
                            StateId = await Event.GetNewState(Arguments);
                        }
                        catch (Exception ex)
                        {
                            StateId = await Event.GetFailureState(Arguments);
 
                            if (string.IsNullOrEmpty(StateId))
                                Log.Error(ex, Arguments.Machine.ObjectId);
                        }
 
                        if (!string.IsNullOrEmpty(StateId))
                        {
                            await GoToState(StateId, Arguments);
                            break;
                        }
                    }
                }
            }
        }
 
        public static async Task ExecuteLog(ActionReference[] ActionReferences, EvaluationArguments Arguments)
        {
            if (ActionReferences is null)
                return;
 
            foreach (ActionReference Action in ActionReferences)
                await Action.ExecuteLog(Arguments);
        }
 
        public static async Task<IEnumerable<OnEvent>> RegisterEventHandlers(OnEvent[] Events, EvaluationArguments Arguments)
        {
            if (Events is null)
                return null;
 
            int i = 0;
            LinkedList<OnEvent> Result = null;
 
            foreach (OnEvent Event in Events)
            {
                if (await Event.Register(i++, Arguments))
                {
                    if (Result is null)
                        Result = new LinkedList<OnEvent>();
 
                    Result.AddLast(Event);
                }
            }
 
            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);
        }
 
        public void ReparseDefinition()
        {
            XmlDocument Doc = new XmlDocument();
            Doc.LoadXml(this.XmlDefinition);
 
            this.Root = (StateMachineRoot)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;
                }
            }
        }
    }
}