StateMachineProcessor.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Markdown;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Cache;
using Waher.Runtime.Collections;
using Waher.Runtime.HashStore;
using Waher.Runtime.Inventory;
using Waher.Runtime.Profiling;
using Waher.Runtime.Threading;
using Waher.Script;
using Waher.Script.Exceptions;
using Waher.Security;
using Waher.Security.SHA3;
using Waher.Security.Users;
using Waher.Service.IoTBroker.EDaler;
using Waher.Service.IoTBroker.EDaler.Uris;
using Waher.Service.IoTBroker.Legal;
using Waher.Service.IoTBroker.Legal.Contracts;
using Waher.Service.IoTBroker.Legal.MFA;
using Waher.Service.IoTBroker.NeuroFeatures;
using Waher.Service.IoTBroker.NeuroFeatures.Events;
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.Reports;
using Waher.Service.IoTBroker.StateMachines.Model.States;
 
namespace Waher.Service.IoTBroker.StateMachines
{
    public static class StateMachineProcessor
    {
        public const string StateMachineNamespace = "https://paiwise.tagroot.io/Schema/StateMachines.xsd";
 
        public const string StateMachineDefinition = "StateMachine";
 
        private static readonly Cache<CaseInsensitiveString, CacheRecord> stateMachines = new Cache<CaseInsensitiveString, CacheRecord>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromHours(1));
        private static Dictionary<string, IStateMachineNode> stateMachineNodes = null;
        private static LegalComponent legal;
        private static EDalerComponent eDaler;
 
        internal class CacheRecord
        {
            public StateMachine Machine;
            public CurrentState CurrentState;
            public LegalComponent Legal;
            public EDalerComponent EDaler;
            public Profiler Profiler;
        }
 
        public static Task<StateMachine> Parse(Token Token)
        {
            return Parse(Token.Definition, Token.DefinitionParsed, Token);
        }
 
        public static async Task<StateMachine> Parse(string Xml, Token Token)
        {
            XmlDocument Doc = XML.ParseXml(Xml, true);
 
            StateMachine Result = await Parse(Xml, Doc, Token);
 
            Result.XmlDefinition = Xml;
 
            return Result;
        }
 
        public static Task<StateMachine> Parse(string NormalizedXml, XmlDocument Xml, Token Token)
        {
            return Parse(NormalizedXml, Xml.DocumentElement, Token);
        }
 
        public static async Task<StateMachine> Parse(string NormalizedXml, XmlElement Xml, Token Token)
        {
            if (Xml is null || Xml.LocalName != "StateMachine" || Xml.NamespaceURI != StateMachineNamespace)
                return null;
 
            StateMachine Result = new StateMachine()
            {
                Root = (StateMachineRoot)await Create(Xml),
                XmlDefinition = NormalizedXml,
                DefinitionContractId = Token.CreationContract,
                TrustProvider = Token.TrustProvider,
                TrustProviderJid = Token.TrustProviderJid,
                CreatorTokenId = Token.TokenId
            };
 
            Result.CheckReferences(Token);
 
            return Result;
        }
 
        internal static bool IsStateMachineCreationContract(Contract Contract,
            out string LocalName, out string Namespace)
        {
            return NeuroFeaturesProcessor.IsNeuroFeaturesCreationContract(Contract,
                out LocalName, out Namespace) &&
                LocalName == StateMachineDefinition &&
                Namespace == StateMachineNamespace;
        }
 
        internal static async Task<IStateMachineNode> Create(XmlElement Xml)
        {
            IStateMachineNode Node;
 
            if (stateMachineNodes is null)
            {
                Dictionary<string, IStateMachineNode> ByFqn = new Dictionary<string, IStateMachineNode>();
 
                foreach (Type T in Types.GetTypesImplementingInterface(typeof(IStateMachineNode)))
                {
                    if (T.IsAbstract || T.IsInterface || T.IsGenericTypeDefinition)
                        continue;
 
                    try
                    {
                        Node = (IStateMachineNode)Types.Instantiate(T);
                        ByFqn[Node.Namespace + "#" + Node.LocalName] = Node;
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
                }
 
                stateMachineNodes = ByFqn;
            }
 
            string Fqn = Xml.NamespaceURI + "#" + Xml.LocalName;
            if (!stateMachineNodes.TryGetValue(Fqn, out Node))
                throw new Exception("A State-Machine node named " + Fqn + " not known.");
 
            Node = Node.Create();
            await Node.Parse(Xml);
 
            return Node;
        }
 
        internal static async Task EventGenerated(Token Token, TokenEvent Event)
        {
            if (Token.DefinitionNamespace != StateMachineNamespace)
                return;
 
            CacheRecord CacheRecord = await GetStateMachine(Token, false);
            if (CacheRecord is null)
                return;
 
            await EventGenerated(Token, Event, CacheRecord);
        }
 
        private static async Task EventGenerated(Token Token, TokenEvent Event, CacheRecord CacheRecord)
        {
            StateMachine Machine = CacheRecord.Machine;
 
            try
            {
                if (Event is Transferred Transferred)
                    await TokenTransferred(Token, Transferred, Machine);
                else if (Event is NoteText NoteText)
                    await NoteAdded(Token, NoteText, Machine);
                else if (Event is NoteXml NoteXml)
                    await NoteAdded(Token, NoteXml, Machine);
                else if (Event is ExternalNoteText ExternalNoteText)
                    await NoteAdded(Token, ExternalNoteText, Machine);
                else if (Event is ExternalNoteXml ExternalNoteXml)
                    await NoteAdded(Token, ExternalNoteXml, Machine);
                else if (Event is Destroyed)
                    await TokenDestroyed(Token, Machine);
            }
            catch (Exception ex)
            {
                if (!(CacheRecord.Profiler is null))
                {
                    int NoteNr = CacheRecord.Profiler.AddNote(ex);
                    CacheRecord.Profiler?.Exception(ex, "Note" + NoteNr);
                }
 
                Log.Exception(ex, Token.TokenId.Value);
                stateMachines.Remove(Machine.StateMachineId);    // Might be in an incorrect state. By removing it from the cache, a new version of the state machine is loaded next time.
            }
        }
 
        internal static async Task EventGenerated(string StateMachineId, TokenEvent Event)
        {
            CacheRecord CacheRecord = await GetStateMachine(StateMachineId, false);
            if (CacheRecord is null)
                return;
 
            Token Token = await NeuroFeaturesProcessor.GetToken(StateMachineId, true);
 
            await EventGenerated(Token, Event, CacheRecord);
        }
 
        internal static Task<CacheRecord> GetStateMachine(Token Token, bool Locked)
        {
            return GetStateMachine(Token.MachineId, Locked);
        }
 
        internal static async Task<CurrentState> GetOrCreateCurrentState(StateMachine Machine, bool Locked)
        {
            Semaphore Semaphore;
 
            if (Locked)
                Semaphore = null;
            else
                Semaphore = await Semaphores.BeginWrite("machine:" + Machine.StateMachineId.Value);
 
            try
            {
                CurrentState CurrentState = await Database.FindFirstIgnoreRest<CurrentState>(new FilterFieldEqualTo("StateMachineId", Machine.StateMachineId));
 
                if (CurrentState is null)
                {
                    CurrentState = new CurrentState()
                    {
                        StateMachineId = Machine.StateMachineId,
                        VariableValues = Array.Empty<CurrentStateVariable>(),
                        State = string.Empty,
                        Expires = Machine.Expires,
                        ArchiveRequired = Machine.ArchiveRequired,
                        ArchiveOptional = Machine.ArchiveOptional
                    };
 
                    await Database.Insert(CurrentState);
                }
        
                return CurrentState;
            }
            finally
            {
                if (!(Semaphore is null))
                    await Semaphore.DisposeAsync();
            }
        }
 
        internal static async Task<CacheRecord> GetStateMachine(string MachineId, bool Locked)
        {
            if (string.IsNullOrEmpty(MachineId))
                return null;
 
            if (stateMachines.TryGetValue(MachineId, out CacheRecord Result))
                return Result;
 
            StateMachine Machine = await Database.FindFirstIgnoreRest<StateMachine>(new FilterFieldEqualTo("StateMachineId", MachineId));
            if (Machine is null)
                return null;
 
            Machine.IndexElements();
 
            CurrentState CurrentState = await GetOrCreateCurrentState(Machine, Locked);
 
            Result = new CacheRecord()
            {
                Machine = Machine,
                CurrentState = CurrentState,
                EDaler = eDaler,
                Legal = legal,
                Profiler = new Profiler(MachineId, ProfilerThreadType.StateMachine)
            };
 
            stateMachines[MachineId] = Result;
            Result.Profiler.NewState(CurrentState.State);
            Result.Profiler.Start();
            Result.Profiler.Event("Reloaded");
 
            return Result;
        }
 
        internal static async Task<string> GetCurrentState(string MachineId)
        {
            CacheRecord State = await GetStateMachine(MachineId, false);
            return State?.CurrentState?.State;
        }
 
        internal static async Task ModuleStarted(LegalComponent Legal, EDalerComponent EDaler)
        {
            legal = Legal;
            eDaler = EDaler;
 
            Ledger.EntryAdded += Ledger_EntryAdded;
            Ledger.EntryUpdated += Ledger_EntryUpdated;
            Ledger.EntryDeleted += Ledger_EntryDeleted;
 
            LinkedList<TimepointEventHandler> ToDelete = null;
 
            try
            {
                foreach (TimepointEventHandler Handler in await Database.Find<TimepointEventHandler>(
                    new FilterFieldEqualTo("EventType", nameof(TimepointEventHandler))))
                {
                    if (await ReregisterOnStart(Handler))
                    {
                        ToDelete ??= new LinkedList<TimepointEventHandler>();
                        ToDelete.AddLast(Handler);
                    }
                }
            }
            finally
            {
                if (!(ToDelete is null))
                    await Database.Delete(ToDelete);
 
                await ScheduledAction.ScheduleNext();
            }
        }
 
        private static async Task<bool> ReregisterOnStart(TimepointEventHandler Handler)
        {
            try
            {
                CacheRecord CacheRecord = await GetStateMachine(Handler.StateMachineId, false);
                if (CacheRecord is null)
                    return true;
 
                StateMachine Machine = CacheRecord.Machine;
                CurrentState CurrentState = CacheRecord.CurrentState;
                if (Handler.State != CurrentState.State)
                    return true;
 
                if (!Machine.TryGetState(Handler.State, out State State))
                    return true;
 
                if (State.OnEvent is null || State.OnEvent.Length <= Handler.EventIndex)
                    return true;
 
                OnEvent Event = State.OnEvent[Handler.EventIndex];
                if (!(Event.Event is TimedEventNode TimedEventNode))
                    return true;
 
                await TimedEventNode.ReregisterOnStart(Handler);
                return false;
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                return true;
            }
        }
 
        internal static Task ModuleStopped()
        {
            legal = null;
            eDaler = null;
 
            Ledger.EntryAdded -= Ledger_EntryAdded;
            Ledger.EntryUpdated -= Ledger_EntryUpdated;
            Ledger.EntryDeleted -= Ledger_EntryDeleted;
 
            TimedEventNode.ClearPendingEvents();
 
            return Task.CompletedTask;
        }
 
        internal static async Task Start(StateMachine Machine, Token Token, LegalComponent Legal, EDalerComponent EDaler)
        {
            try
            {
                Profiler Profiler = new Profiler(Machine.StateMachineId, ProfilerThreadType.StateMachine);
                Profiler.Start();
 
                (CurrentState CurrentState, EvaluationArguments Arguments) = await Machine.CreateCurrentState(Token, Legal, EDaler, Profiler);
 
                stateMachines[Machine.StateMachineId] = new CacheRecord()
                {
                    CurrentState = CurrentState,
                    Machine = Machine,
                    EDaler = EDaler,
                    Legal = Legal,
                    Profiler = Profiler
                };
 
                await Machine.Start(Arguments);
            }
            catch (Exception ex)
            {
                Log.Exception(ex, Machine.ObjectId,
                    new KeyValuePair<string, object>("StateMachineId", Machine.StateMachineId.Value));
            }
        }
 
        internal static void EventRaised(EventHandlers.EventHandler Handler, Token Token,
            params KeyValuePair<string, object>[] ToSet)
        {
            Task.Run(async () =>
            {
                try
                {
                    await ProcessEvent(Handler, Token, ToSet);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            });
        }
 
        internal static async Task<EventRecord> ProcessEvent(EventHandlers.EventHandler Handler,
            Token Token, params KeyValuePair<string, object>[] ToSet)
        {
            using Semaphore Semaphore = await Semaphores.BeginWrite("machine:" + Handler.StateMachineId);
            return await EventRaisedLocked(Handler, Token, ToSet);
        }
 
        internal class EventRecord
        {
            public CacheRecord CacheRecord;
            public bool SuppressSamples;
        }
 
        internal static async Task<EventRecord> EventRaisedLocked(EventHandlers.EventHandler Handler,
            Token Token, params KeyValuePair<string, object>[] ToSet)
        {
            EventRecord Result = new EventRecord()
            {
                SuppressSamples = false,
                CacheRecord = await GetStateMachine(Handler.StateMachineId, true)
            };
 
            if (Result.CacheRecord is null)
                return null;
 
            try
            {
                StateMachine Machine = Result.CacheRecord.Machine;
                CurrentState CurrentState = Result.CacheRecord.CurrentState;
                if (Handler.State != CurrentState.State)
                    return null;
 
                if (!Machine.TryGetState(Handler.State, out State State))
                    return null;
 
                if (State.OnEvent is null || State.OnEvent.Length <= Handler.EventIndex)
                    return null;
 
                Variables Variables = CurrentState.GetVariables(Machine);
 
                if (!(ToSet is null))
                {
                    foreach (KeyValuePair<string, object> P in ToSet)
                        Variables[P.Key] = P.Value;
                }
 
                if (Token is null && !CaseInsensitiveString.IsNullOrEmpty(Machine.CreatorTokenId))
                    Token = await NeuroFeaturesProcessor.GetToken(Machine.CreatorTokenId, false);
 
                EvaluationArguments Arguments = new EvaluationArguments(Variables, Machine,
                    Token, CurrentState, Result.CacheRecord.Legal ?? legal,
                    Result.CacheRecord.EDaler ?? eDaler, Result.CacheRecord.Profiler);
 
                try
                {
                    OnEvent Event = State.OnEvent[Handler.EventIndex];
                    string StateId;
 
                    if (await Event.Applies(Arguments))
                    {
                        try
                        {
                            Result.SuppressSamples = await Event.GetSuppressSample(Arguments);
                            await Event.ExecuteLog(Arguments, Result.SuppressSamples);
                            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 StateMachine.CheckConditionalEvents(Arguments);
                        else
                            await StateMachine.GoToState(StateId, Arguments);
                    }
                }
                finally
                {
                    await StateMachine.EvaluationComplete(Arguments);
                }
            }
            catch (Exception ex)
            {
                if (!(Result.CacheRecord.Profiler is null))
                {
                    int NoteNr = Result.CacheRecord.Profiler.AddNote(ex);
                    Result.CacheRecord.Profiler?.Exception(ex, "Note" + NoteNr);
                }
 
                Log.Exception(ex, Handler.StateMachineId);
            }
 
            return Result;
        }
 
        internal static async Task NoteAdded(Token Token, NoteText Event, StateMachine Machine)
        {
            using Semaphore Semaphore = await Semaphores.BeginWrite("machine:" + Machine.StateMachineId.Value);
 
            CachedEventHandler[] Handlers = await CachedEventHandler.GetEventHandlers(
                nameof(TokenNoteEventHandler) + "|" + nameof(OnTextNote) + "|" +
                Machine.StateMachineId + "||");
 
            if ((Handlers?.Length ?? 0) == 0)
                return;
 
            foreach (CachedEventHandler Handler in Handlers)
            {
                if (Handler is TokenNoteEventHandler TokenNoteEventHandler)
                {
                    KeyValuePair<string, object>[] Variables = GetVariablesToSet(
                        TokenNoteEventHandler, Event.Note, Event.Personal, null);
 
                    await EventRaisedLocked(Handler, Token, Variables);
                }
            }
        }
 
        internal static async Task NoteAdded(Token Token, NoteXml Event, StateMachine Machine)
        {
            using Semaphore Semaphore = await Semaphores.BeginWrite("machine:" + Machine.StateMachineId.Value);
 
            CachedEventHandler[] Handlers = await CachedEventHandler.GetEventHandlers(
                nameof(TokenNoteEventHandler) + "|" + nameof(OnXmlNote) + "|" +
                Machine.StateMachineId + "|" + Event.LocalName + "|" + Event.Namespace);
 
            if ((Handlers?.Length ?? 0) == 0)
                return;
 
            XmlDocument Doc = null;
 
            foreach (CachedEventHandler Handler in Handlers)
            {
                if (Handler is TokenNoteEventHandler TokenNoteEventHandler)
                {
                    Doc ??= XML.ParseXml(Event.Note);
 
                    await EventRaisedLocked(Handler, Token, GetVariablesToSet(TokenNoteEventHandler, Doc, Event.Personal, null));
                }
            }
        }
 
        internal static async Task NoteAdded(Token Token, ExternalNoteText Event, StateMachine Machine)
        {
            using Semaphore Semaphore = await Semaphores.BeginWrite("machine:" + Machine.StateMachineId.Value);
 
            CachedEventHandler[] Handlers = await CachedEventHandler.GetEventHandlers(
                nameof(TokenNoteEventHandler) + "|" + nameof(OnExternalTextNote) + "|" +
                Machine.StateMachineId + "||");
 
            if ((Handlers?.Length ?? 0) == 0)
                return;
 
 
            foreach (CachedEventHandler Handler in Handlers)
            {
                if (Handler is TokenNoteEventHandler TokenNoteEventHandler)
                {
                    if (!await IsAuthorized(Event.Source, TokenNoteEventHandler.Privilege))
                        continue;
 
                    await EventRaisedLocked(Handler, Token, GetVariablesToSet(TokenNoteEventHandler, Event.Note, Event.Personal, Event.Source));
                }
            }
        }
 
        internal static async Task NoteAdded(Token Token, ExternalNoteXml Event, StateMachine Machine)
        {
            using Semaphore Semaphore = await Semaphores.BeginWrite("machine:" + Machine.StateMachineId.Value);
 
            CachedEventHandler[] Handlers = await CachedEventHandler.GetEventHandlers(
                nameof(TokenNoteEventHandler) + "|" + nameof(OnExternalXmlNote) + "|" +
                Machine.StateMachineId + "|" + Event.LocalName + "|" + Event.Namespace);
 
            if ((Handlers?.Length ?? 0) == 0)
                return;
 
            XmlDocument Doc = null;
 
            foreach (CachedEventHandler Handler in Handlers)
            {
                if (Handler is TokenNoteEventHandler TokenNoteEventHandler)
                {
                    if (!await IsAuthorized(Event.Source, TokenNoteEventHandler.Privilege))
                        continue;
 
                    Doc ??= XML.ParseXml(Event.Note);
 
                    await EventRaisedLocked(Handler, Token, GetVariablesToSet(TokenNoteEventHandler, Doc, Event.Personal, Event.Source));
                }
            }
        }
 
        private static async Task<bool> IsAuthorized(string Source, string Privilege)
        {
            bool CheckPrivilege = !string.IsNullOrEmpty(Privilege);
 
            if (!CheckPrivilege && Source.IndexOf('@') > 0)
                return true;
 
            IUser User = await Users.GetUser(Source, false);
            if (User is null)
                return false;
 
            return User.HasPrivilege(Privilege);
        }
 
        internal static KeyValuePair<string, object>[] GetVariablesToSet(TokenNoteEventHandler Handler, object Note, bool Personal, string Source)
        {
            List<KeyValuePair<string, object>> Result = new List<KeyValuePair<string, object>>();
 
            if (!string.IsNullOrEmpty(Handler.SourceVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.SourceVariable, Source));
 
            if (!string.IsNullOrEmpty(Handler.PersonalVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.PersonalVariable, Personal));
 
            if (!string.IsNullOrEmpty(Handler.NoteVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.NoteVariable, Note));
 
            return Result.ToArray();
        }
 
        internal static async Task TokenTransferred(Token Token, Transferred Event, StateMachine Machine)
        {
            using Semaphore Semaphore = await Semaphores.BeginWrite("machine:" + Machine.StateMachineId.Value);
 
            CachedEventHandler[] Handlers = await CachedEventHandler.GetEventHandlers(
                nameof(TokenTransferredEventHandler) + "|" + nameof(OnTransferred) + "|" +
                Machine.StateMachineId);
 
            if ((Handlers?.Length ?? 0) == 0)
                return;
 
            foreach (CachedEventHandler Handler in Handlers)
            {
                if (Handler is TokenTransferredEventHandler TokenTransferredEventHandler)
                    await EventRaisedLocked(Handler, Token, GetVariablesToSet(TokenTransferredEventHandler, Event));
            }
        }
 
        internal static KeyValuePair<string, object>[] GetVariablesToSet(
            TokenTransferredEventHandler Handler, Transferred Event)
        {
            List<KeyValuePair<string, object>> Result = new List<KeyValuePair<string, object>>();
 
            if (!string.IsNullOrEmpty(Handler.SellerVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.SellerVariable, Event.Seller));
 
            if (!string.IsNullOrEmpty(Handler.BuyerVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.BuyerVariable, Event.Owner));
 
            if (!string.IsNullOrEmpty(Handler.ContractVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.ContractVariable, Event.OwnershipContract));
 
            if (!string.IsNullOrEmpty(Handler.ValueVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.ValueVariable, Event.Value));
 
            if (!string.IsNullOrEmpty(Handler.AmountVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.AmountVariable, Event.Value - Event.Commission));
 
            if (!string.IsNullOrEmpty(Handler.CurrencyVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.CurrencyVariable, Event.Currency));
 
            return Result.ToArray();
        }
 
        internal static async Task EDalerSent(XmppAddress Owner, EDalerUri Uri)
        {
            CachedEventHandler[] Handlers = await CachedEventHandler.GetEventHandlers(
                nameof(OwnerEventHandler) + "|" + nameof(OnPaymentSent) + "|" + Owner.BareJid.LowerCase);
 
            if ((Handlers?.Length ?? 0) == 0)
                return;
 
            foreach (CachedEventHandler Handler in Handlers)
            {
                if (Handler is PaymentEventHandler PaymentHandler)
                    EventRaised(Handler, null, GetVariablesToSet(PaymentHandler, Uri, Uri.To.BareJid));
            }
        }
 
        internal static async Task EDalerReceived(XmppAddress Owner, EDalerUri Uri, string Sender)
        {
            CachedEventHandler[] Handlers = await CachedEventHandler.GetEventHandlers(
                nameof(OwnerEventHandler) + "|" + nameof(OnPaymentReceived) + "|" + Owner.BareJid.LowerCase);
 
            if ((Handlers?.Length ?? 0) == 0)
                return;
 
            XmppAddress SenderAddress = new XmppAddress(Sender);
            Sender = SenderAddress.BareJid;
 
            foreach (CachedEventHandler Handler in Handlers)
            {
                if (Handler is PaymentEventHandler PaymentHandler)
                    EventRaised(Handler, null, GetVariablesToSet(PaymentHandler, Uri, Sender));
            }
        }
 
        internal static KeyValuePair<string, object>[] GetVariablesToSet(PaymentEventHandler Handler, EDalerUri Uri, string RemoteAddress)
        {
            List<KeyValuePair<string, object>> Result = new List<KeyValuePair<string, object>>();
 
            if (!string.IsNullOrEmpty(Handler.RemoteVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.RemoteVariable, RemoteAddress));
 
            if (!string.IsNullOrEmpty(Handler.AmountVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.AmountVariable, (double)Uri.Amount));
 
            if (!string.IsNullOrEmpty(Handler.AmountExtraVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.AmountExtraVariable, (double)(Uri.AmountExtra ?? 0M)));
 
            if (!string.IsNullOrEmpty(Handler.AmountTotalVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.AmountTotalVariable, (double)Uri.TotalAmount));
 
            if (!string.IsNullOrEmpty(Handler.CurrencyVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.CurrencyVariable, Uri.Currency));
 
            if (!string.IsNullOrEmpty(Handler.ReferenceVariable))
            {
                if (Uri.EncryptionPublicKey is null && !(Uri.EncryptedMessage is null))
                    Result.Add(new KeyValuePair<string, object>(Handler.ReferenceVariable, Encoding.UTF8.GetString(Uri.EncryptedMessage)));
                else
                    Result.Add(new KeyValuePair<string, object>(Handler.ReferenceVariable, null));
            }
 
            if (!string.IsNullOrEmpty(Handler.ConditionVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.ConditionVariable, Uri.ContractCondition?.Value));
 
            return Result.ToArray();
        }
 
        internal static async Task ContractSignature(Contract Contract, string Role,
            CaseInsensitiveString LegalId)
        {
            StringBuilder sb = new StringBuilder();
 
            sb.Append(Contract.ContractId.LowerCase);
            sb.Append(' ');
            sb.Append(Role);
            sb.Append(' ');
            sb.Append(LegalId.LowerCase);
 
            SHA3_256 H = new SHA3_256();
            byte[] Hash = H.ComputeVariable(Encoding.UTF8.GetBytes(sb.ToString()));
 
            if (!await PersistedHashes.AddHash("ContractSignature", Contract.Expires, Hash))
                return;
 
            sb.Clear();
 
            sb.Append(nameof(ContractEventHandler));
            sb.Append('|');
            sb.Append(nameof(OnContractSignature));
            sb.Append('|');
            sb.Append(Contract.ForMachinesLocalName);
            sb.Append('|');
            sb.Append(Contract.ForMachinesNamespace);
 
            CachedEventHandler[] Handlers = await CachedEventHandler.GetEventHandlers(sb.ToString());
 
            if ((Handlers?.Length ?? 0) > 0)
            {
                foreach (CachedEventHandler Handler in Handlers)
                {
                    if (Handler is ContractEventHandler ContractEventHandler)
                    {
                        EventRaised(Handler, null, await GetVariablesToSet(ContractEventHandler,
                            Contract, LegalId, Role));
                    }
                }
            }
 
            if (LegalComponent.HasSecondaryName(Contract, out string LocalName, 
                out string Namespace, out SecondaryNameType NameType))
            {
                sb.Clear();
 
                sb.Append(nameof(ContractEventHandler));
                sb.Append('|');
                sb.Append(nameof(OnContractSignature));
                sb.Append('|');
                sb.Append(LocalName);
                sb.Append('|');
                sb.Append(Namespace);
                sb.Append('|');
                sb.Append(NameType.ToString());
 
                Handlers = await CachedEventHandler.GetEventHandlers(sb.ToString());
 
                if ((Handlers?.Length ?? 0) > 0)
                {
                    foreach (CachedEventHandler Handler in Handlers)
                    {
                        if (Handler is ContractEventHandler ContractEventHandler)
                        {
                            EventRaised(Handler, null, await GetVariablesToSet(ContractEventHandler,
                                Contract, LegalId, Role));
                        }
                    }
                }
            }
        }
 
        internal static async Task ContractSigned(Contract Contract)
        {
            SHA3_256 H = new SHA3_256();
            byte[] Hash = H.ComputeVariable(Encoding.UTF8.GetBytes(Contract.ContractId.LowerCase));
 
            if (!await PersistedHashes.AddHash("ContractSigned", Contract.Expires, Hash))
                return;
 
            StringBuilder sb = new StringBuilder();
 
            sb.Append(nameof(ContractEventHandler));
            sb.Append('|');
            sb.Append(nameof(OnContractSigned));
            sb.Append('|');
            sb.Append(Contract.ForMachinesLocalName);
            sb.Append('|');
            sb.Append(Contract.ForMachinesNamespace);
 
            CachedEventHandler[] Handlers = await CachedEventHandler.GetEventHandlers(sb.ToString());
 
            if ((Handlers?.Length ?? 0) > 0)
            {
                foreach (CachedEventHandler Handler in Handlers)
                {
                    if (Handler is ContractEventHandler ContractEventHandler)
                    {
                        EventRaised(Handler, null, await GetVariablesToSet(ContractEventHandler,
                            Contract, null, null));
                    }
                }
            }
 
            if (LegalComponent.HasSecondaryName(Contract, out string LocalName,
                out string Namespace, out SecondaryNameType NameType))
            {
                sb.Clear();
 
                sb.Append(nameof(ContractEventHandler));
                sb.Append('|');
                sb.Append(nameof(OnContractSigned));
                sb.Append('|');
                sb.Append(LocalName);
                sb.Append('|');
                sb.Append(Namespace);
                sb.Append('|');
                sb.Append(NameType.ToString());
 
                Handlers = await CachedEventHandler.GetEventHandlers(sb.ToString());
 
                if ((Handlers?.Length ?? 0) > 0)
                {
                    foreach (CachedEventHandler Handler in Handlers)
                    {
                        if (Handler is ContractEventHandler ContractEventHandler)
                        {
                            EventRaised(Handler, null, await GetVariablesToSet(ContractEventHandler,
                                Contract, null, null));
                        }
                    }
                }
            }
        }
 
        internal static async Task ContractTemplateApproved(Contract Contract)
        {
            StringBuilder sb = new StringBuilder();
 
            sb.Append(nameof(ContractEventHandler));
            sb.Append('|');
            sb.Append(nameof(OnContractTemplateApproved));
            sb.Append('|');
            sb.Append(Contract.ForMachinesLocalName);
            sb.Append('|');
            sb.Append(Contract.ForMachinesNamespace);
 
            CachedEventHandler[] Handlers = await CachedEventHandler.GetEventHandlers(sb.ToString());
 
            if ((Handlers?.Length ?? 0) > 0)
            {
                foreach (CachedEventHandler Handler in Handlers)
                {
                    if (Handler is ContractEventHandler ContractEventHandler)
                    {
                        EventRaised(Handler, null, await GetVariablesToSet(ContractEventHandler,
                            Contract, null, null));
                    }
                }
            }
 
            if (LegalComponent.HasSecondaryName(Contract, out string LocalName,
                out string Namespace, out SecondaryNameType NameType))
            {
                sb.Clear();
 
                sb.Append(nameof(ContractEventHandler));
                sb.Append('|');
                sb.Append(nameof(OnContractTemplateApproved));
                sb.Append('|');
                sb.Append(LocalName);
                sb.Append('|');
                sb.Append(Namespace);
                sb.Append('|');
                sb.Append(NameType.ToString());
 
                Handlers = await CachedEventHandler.GetEventHandlers(sb.ToString());
 
                if ((Handlers?.Length ?? 0) > 0)
                {
                    foreach (CachedEventHandler Handler in Handlers)
                    {
                        if (Handler is ContractEventHandler ContractEventHandler)
                        {
                            EventRaised(Handler, null, await GetVariablesToSet(ContractEventHandler,
                                Contract, null, null));
                        }
                    }
                }
            }
        }
 
        internal static async Task<KeyValuePair<string, object>[]> GetVariablesToSet(ContractEventHandler Handler,
            Contract Contract, CaseInsensitiveString LegalId, string Role)
        {
            List<KeyValuePair<string, object>> Result = new List<KeyValuePair<string, object>>();
 
            if (!string.IsNullOrEmpty(Handler.ContractIdVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.ContractIdVariable, Contract.ContractId.Value));
 
            if (!string.IsNullOrEmpty(Handler.ContractXmlVariable))
            {
                StringBuilder sb = new StringBuilder();
                await Contract.Serialize(sb, true, true, true, true, true, true, true, null, legal);
 
                XmlDocument Doc = XML.ParseXml(sb.ToString(), true);
 
                Result.Add(new KeyValuePair<string, object>(Handler.ContractXmlVariable, Doc));
            }
 
            if (!string.IsNullOrEmpty(Handler.ParametersVariable))
            {
                Dictionary<string, object> Parameters = new Dictionary<string, object>()
                {
                    { "Duration", Contract.Duration }
                };
 
                if (Contract.FirstSignatureAt.HasValue)
                {
                    Parameters["Now"] = Contract.FirstSignatureAt.Value.ToLocalTime();
                    Parameters["NowUtc"] = Contract.FirstSignatureAt.Value.ToUniversalTime();
                }
 
                foreach (Parameter P in Contract.Parameters)
                    Parameters[P.Name] = P.ObjectValue;
 
                Result.Add(new KeyValuePair<string, object>(Handler.ParametersVariable, Parameters));
            }
 
            if (!string.IsNullOrEmpty(Handler.RolesVariable) && !(Contract.ClientSignatures is null))
            {
                Dictionary<string, ChunkedList<string>> Roles = new Dictionary<string, ChunkedList<string>>();
 
                foreach (ClientSignature Signature in Contract.ClientSignatures)
                {
                    if (!Roles.TryGetValue(Signature.Role, out ChunkedList<string> List))
                    {
                        List = new ChunkedList<string>();
                        Roles[Signature.Role] = List;
                    }
 
                    List.Add(Signature.LegalId.LowerCase);
                }
 
                Dictionary<string, object> Roles2 = new Dictionary<string, object>();
 
                foreach (KeyValuePair<string, ChunkedList<string>> P in Roles)
                    Roles2[P.Key] = P.Value.ToArray();
 
                Result.Add(new KeyValuePair<string, object>(Handler.RolesVariable, Roles2));
            }
 
            if (!string.IsNullOrEmpty(Handler.MachineReadableVariable))
            {
                Result.Add(new KeyValuePair<string, object>(Handler.MachineReadableVariable, 
                    Contract.ForMachinesParsed));
            }
 
            if (!string.IsNullOrEmpty(Handler.LegalIdVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.LegalIdVariable, LegalId?.Value));
 
            if (!string.IsNullOrEmpty(Handler.RoleVariable))
                Result.Add(new KeyValuePair<string, object>(Handler.RoleVariable, Role));
 
            return Result.ToArray();
        }
 
        internal static async Task TokenDestroyed(Token Token, StateMachine Machine)
        {
            using Semaphore Semaphore = await Semaphores.BeginWrite("machine:" + Machine.StateMachineId.Value);
            
            CacheRecord Record = await GetStateMachine(Machine.StateMachineId.Value, true);
            if (Record is null)
                return;
 
            Variables Variables = Record.CurrentState.GetVariables(Machine);
            EvaluationArguments Arguments = new EvaluationArguments(Variables,
                Machine, Token, Record.CurrentState, Record.Legal, Record.EDaler,
                Record.Profiler);
 
            CachedEventHandler[] Handlers = await CachedEventHandler.GetEventHandlers(
                nameof(TokenEventHandler) + "|" + nameof(OnDestroyed) + "|" +
                Machine.StateMachineId);
 
            if ((Handlers?.Length ?? 0) > 0)
            {
                foreach (CachedEventHandler Handler in Handlers)
                {
                    if (Handler is TokenEventHandler TokenEventHandler)
                        await EventRaisedLocked(Handler, Token);
                }
            }
 
            Token Token2 = await Database.FindFirstIgnoreRest<Token>(
                new FilterFieldEqualTo("MachineId", Machine.StateMachineId));
 
            if (Token2 is null)
                await StateMachine.GoToState(string.Empty, Arguments);
        }
 
        internal static async Task<int> KillMachine(Token Token, IUser User,
            CaseInsensitiveString LegalId, string RemoteEndPoint,
            EventHandlerAsync<QuickLoginResponseEventArgs> Callback, object State)
        {
            if (!Token.HasStateMachine)
                return 0;
 
            CacheRecord Record = await GetStateMachine(Token.MachineId, false);
            if (Record is null)
                return 1;
 
            string TokenId = Token.TokenId;
            StringBuilder sb = new StringBuilder();
            DateTime TP = DateTime.UtcNow;
 
            sb.Append("To kill a state-machine. By signing this request, you ");
            sb.Append("confirm you have reviewed the token (");
            sb.Append(TokenId);
            sb.Append(") and understand the consequences of killing the state-machine. ");
            sb.Append("You also agree to store your approval and digital signature in ");
            sb.Append("the event log, and take full responsibility of the killing of the ");
            sb.Append("state-machine. This petition was sent ");
            sb.Append(TP.ToShortDateString());
            sb.Append(" at ");
            sb.Append(TP.ToLongTimeString());
            sb.Append(" UTC.");
 
            string Purpose = sb.ToString();
            byte[] Content = Hashes.ComputeSHA256Hash(Encoding.UTF8.GetBytes(Purpose));
 
            await QuickLogin.StartQuickLogin(LegalId, Purpose, Content, null, null, RemoteEndPoint,
                async (Sender, e) =>
                {
                    if (e.Response)
                    {
                        Variables Variables = Record.CurrentState.GetVariables(Record.Machine);
                        EvaluationArguments Arguments = new EvaluationArguments(Variables,
                            Record.Machine, Token, Record.CurrentState, Record.Legal, Record.EDaler,
                            Record.Profiler);
 
                        using Semaphore Semaphore = await Semaphores.BeginWrite("machine:" + Token.MachineId.Value);
 
                        await StateMachine.GoToState(string.Empty, Arguments);
 
                        StringBuilder sb = new StringBuilder();
                        e.RequestedIdentity.Serialize(sb, true, true, true, true, true, true, true);
 
                        NoteText Comment = new NoteText()
                        {
                            ArchiveOptional = Token.ArchiveOptional,
                            ArchiveRequired = Token.ArchiveRequired,
                            Expires = Token.Expires,
                            TokenId = TokenId,
                            Timestamp = DateTime.UtcNow,
                            Personal = false,
                            Note = "State-machine killed by " + LegalId
                        };
 
                        await Database.Insert(Comment);
 
                        Killed Event = new Killed()
                        {
                            ArchiveOptional = Token.ArchiveOptional,
                            ArchiveRequired = Token.ArchiveRequired,
                            Expires = Token.Expires,
                            Owner = Token.Owner,
                            OwnershipContract = Token.OwnershipContract,
                            TokenId = TokenId,
                            Value = 0,
                            Currency = string.Empty,
                            Timestamp = DateTime.UtcNow,
                            Personal = false,
                            LegalId = LegalId,
                            User = User.UserName,
                            ClientEndPoint = e.ClientEndpoint,
                            PetitionId = e.PetitionId,
                            Purpose = Purpose,
                            Content = e.SignatureContent,
                            Signature = e.Signature,
                            ClientIdentityXml = sb.ToString()
                        };
 
                        await Database.Insert(Event);
                    }
 
                    QuickLoginResponseEventArgs e2 = new QuickLoginResponseEventArgs(e,
                        e.SignatureContent, State);
 
                    await Callback.Raise(Sender, e2);
                }, null);
 
            return 2;
        }
 
        private static void Ledger_EntryAdded(object Sender, ObjectEventArgs e)
        {
            // TODO
        }
 
        private static void Ledger_EntryUpdated(object Sender, ObjectEventArgs e)
        {
            // TODO
        }
 
        private static void Ledger_EntryDeleted(object Sender, ObjectEventArgs e)
        {
            // TODO
        }
 
        internal static async Task<(int, int, int, int)> DeleteExpiredMachines()
        {
            int NrMachines = 0;
            int NrEventHandlers = 0;
            int NrCurrentStates = 0;
            int NrSamples = 0;
 
            IEnumerable<StateMachine> Deleted = await Database.FindDelete<StateMachine>(
                new FilterFieldLesserThan("Expires", DateTime.Today.AddDays(-1)));
 
            foreach (StateMachine Machine in Deleted)
            {
                NrMachines++;
 
                if (stateMachines.TryGetValue(Machine.StateMachineId, out CacheRecord Record))
                {
                    stateMachines.Remove(Machine.StateMachineId);
 
                    if (!string.IsNullOrEmpty(Record.CurrentState?.State) &&
                        Machine.TryGetState(Record.CurrentState.State, out State State) &&
                        !(State.OnEvent is null))
                    {
                        try
                        {
                            Variables Variables = Record.CurrentState.GetVariables(Machine);
                            EvaluationArguments Arguments = new EvaluationArguments(Variables,
                                Machine, null, Record.CurrentState, Record.Legal, Record.EDaler,
                                Record.Profiler);
 
                            await StateMachine.UnregisterEventHandlers(State.OnEvent, Arguments);
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex);
                        }
                    }
                }
 
                IEnumerable<EventHandlers.EventHandler> EventHandlers = await Database.FindDelete<EventHandlers.EventHandler>(
                    new FilterFieldEqualTo("StateMachineId", Machine.StateMachineId));
 
                foreach (EventHandlers.EventHandler EventHandler in EventHandlers)
                {
                    NrEventHandlers++;
 
                    if (EventHandler is CachedEventHandler CachedEventHandler)
                        await CachedEventHandler.RemoveFromCache();
                }
 
                NrCurrentStates = await Database.Delete<CurrentState>(
                    new FilterFieldEqualTo("StateMachineId", Machine.StateMachineId));
 
                NrSamples = await Database.Delete<StateMachineSample>(
                    new FilterFieldEqualTo("StateMachineId", Machine.StateMachineId.Value));
            }
 
            return (NrMachines, NrEventHandlers, NrCurrentStates, NrSamples);
        }
 
        #region XMPP Interface
 
        internal static void RegisterHandlers(EDalerComponent EDaler)
        {
            eDaler = EDaler;
 
            EDaler.RegisterIqGetHandler("currentState", StateMachineNamespace, GetCurrentStateHandler, true);
            EDaler.RegisterIqGetHandler("profilingReport", StateMachineNamespace, GetProfilingReport, false);
            EDaler.RegisterIqGetHandler("presentReport", StateMachineNamespace, GetPresentReport, false);
            EDaler.RegisterIqGetHandler("historyReport", StateMachineNamespace, GetHistoryReport, false);
            EDaler.RegisterIqGetHandler("stateDiagram", StateMachineNamespace, GetStateDiagram, false);
        }
 
        internal static void UnregisterHandlers(EDalerComponent EDaler)
        {
            eDaler = null;
 
            EDaler.UnregisterIqGetHandler("currentState", StateMachineNamespace, GetCurrentStateHandler, true);
            EDaler.UnregisterIqGetHandler("profilingReport", StateMachineNamespace, GetProfilingReport, false);
            EDaler.UnregisterIqGetHandler("presentReport", StateMachineNamespace, GetPresentReport, false);
            EDaler.UnregisterIqGetHandler("historyReport", StateMachineNamespace, GetHistoryReport, false);
            EDaler.UnregisterIqGetHandler("stateDiagram", StateMachineNamespace, GetStateDiagram, false);
        }
 
        #region GetCurrentStateHandler
 
        private static async Task GetCurrentStateHandler(object Sender, IqEventArgs e)
        {
            string TokenId = XML.Attribute(e.Query, "tokenId");
            if (string.IsNullOrEmpty(TokenId))
            {
                await e.IqErrorBadRequest(e.To, "Missing Token ID.", "en");
                return;
            }
 
            CurrentState CurrentState = await GetCurrentState(TokenId, e);
            if (CurrentState is null)
                return;
 
            StringBuilder Xml = new StringBuilder();
            await Export(CurrentState, Xml);
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        internal static async Task Export(CurrentState CurrentState, StringBuilder Xml)
        {
            using Semaphore Semaphore = await Semaphores.BeginRead("machine:" + CurrentState.StateMachineId.Value);
 
            Xml.Append("<currentState xmlns='");
            Xml.Append(StateMachineNamespace);
            Xml.Append("' state='");
            Xml.Append(XML.Encode(CurrentState.State));
            Xml.Append("' ended='");
            Xml.Append(CommonTypes.Encode(CurrentState.HasEnded));
            Xml.Append("' running='");
            Xml.Append(CommonTypes.Encode(CurrentState.IsRunning));
            Xml.Append("' expires='");
            Xml.Append(XML.Encode(CurrentState.Expires));
            Xml.Append("'>");
 
            if (!(CurrentState.VariableValues is null))
            {
                foreach (CurrentStateVariable Variable in CurrentState.VariableValues)
                    AppendVariable(Xml, Variable.Name, Variable.Value);
            }
 
            Xml.Append("</currentState>");
        }
 
        internal static void AppendVariable(StringBuilder Xml, string Name, object Value)
        {
            Xml.Append("<variable name='");
            Xml.Append(XML.Encode(Name));
            Xml.Append("'>");
 
            if (Value is null)
                Xml.Append("<null/>");
            else if (Value is double dbl)
            {
                Xml.Append("<dbl>");
                Xml.Append(CommonTypes.Encode(dbl));
                Xml.Append("</dbl>");
            }
            else if (Value is float fl)
            {
                Xml.Append("<fl>");
                Xml.Append(CommonTypes.Encode(fl));
                Xml.Append("</fl>");
            }
            else if (Value is decimal dec)
            {
                Xml.Append("<dec>");
                Xml.Append(CommonTypes.Encode(dec));
                Xml.Append("</dec>");
            }
            else if (Value is int i32)
            {
                Xml.Append("<i32>");
                Xml.Append(i32.ToString());
                Xml.Append("</i32>");
            }
            else if (Value is long i64)
            {
                Xml.Append("<i64>");
                Xml.Append(i64.ToString());
                Xml.Append("</i64>");
            }
            else if (Value is short i16)
            {
                Xml.Append("<i16>");
                Xml.Append(i16.ToString());
                Xml.Append("</i16>");
            }
            else if (Value is sbyte i8)
            {
                Xml.Append("<i8>");
                Xml.Append(i8.ToString());
                Xml.Append("</i8>");
            }
            else if (Value is uint ui32)
            {
                Xml.Append("<ui32>");
                Xml.Append(ui32.ToString());
                Xml.Append("</ui32>");
            }
            else if (Value is ulong ui64)
            {
                Xml.Append("<ui64>");
                Xml.Append(ui64.ToString());
                Xml.Append("</ui64>");
            }
            else if (Value is ushort ui16)
            {
                Xml.Append("<ui16>");
                Xml.Append(ui16.ToString());
                Xml.Append("</ui16>");
            }
            else if (Value is byte ui8)
            {
                Xml.Append("<ui8>");
                Xml.Append(ui8.ToString());
                Xml.Append("</ui8>");
            }
            else if (Value is bool b)
            {
                Xml.Append("<b>");
                Xml.Append(CommonTypes.Encode(b));
                Xml.Append("</b>");
            }
            else if (Value is DateTime TP)
            {
                Xml.Append("<dt>");
                Xml.Append(XML.Encode(TP));
                Xml.Append("</dt>");
            }
            else if (Value is DateTimeOffset TPO)
            {
                Xml.Append("<dto>");
                Xml.Append(XML.Encode(TPO));
                Xml.Append("</dto>");
            }
            else if (Value is TimeSpan TS)
            {
                Xml.Append("<ts>");
                Xml.Append(XML.Encode(TS.ToString()));
                Xml.Append("</ts>");
            }
            else if (Value is Duration D)
            {
                Xml.Append("<d>");
                Xml.Append(XML.Encode(D.ToString()));
                Xml.Append("</d>");
            }
            else if (Value is string s)
            {
                Xml.Append("<s>");
                Xml.Append(XML.Encode(s));
                Xml.Append("</s>");
            }
            else
            {
                Xml.Append("<exp>");
                Xml.Append(XML.Encode(Expression.ToExpressionString(Value)));
                Xml.Append("</exp>");
            }
 
            Xml.Append("</variable>");
        }
 
        private static async Task<CacheRecord> GetCacheRecord(string TokenId, IqEventArgs e)
        {
            XmppAddress Addr = new XmppAddress(TokenId);
            if (!Addr.IsBareJID || !Guid.TryParse(Addr.Account, out _))
            {
                e?.IqErrorBadRequest(e.To, "Invalid Token ID.", "en");
                return null;
            }
 
            if (!eDaler.IsComponentDomain(Addr.Domain, true))
            {
                e?.IqErrorBadRequest(e.To, "Token not hosted by this neuron.", "en");
                return null;
            }
 
            Token Token = await NeuroFeaturesProcessor.GetToken(TokenId, true);
            if (Token is null)
            {
                e?.IqErrorItemNotFound(e.To, "Token not found.", "en");
                return null;
            }
 
            if (!(e is null) && !await NeuroFeaturesProcessor.IsAuthorizedAccess(Token, e))
                return null;
 
            CacheRecord Record = await GetStateMachine(Token.MachineId, false);
            if (Record is null)
            {
                e?.IqErrorItemNotFound(e.To, "State-Machine not found.", "en");
                return null;
            }
 
            return Record;
        }
 
        private static async Task<CurrentState> GetCurrentState(string TokenId, IqEventArgs e)
        {
            CacheRecord Record = await GetCacheRecord(TokenId, e);
            if (Record is null)
                return null;
 
            return Record.CurrentState;
        }
 
        #endregion
 
        #region GetProfilingReport
 
        internal static async Task<string> GetProfilingReportAsync(string TokenId, ReportFormat Format)
        {
            CacheRecord Record = await GetCacheRecord(TokenId, null);
            if (Record?.Profiler is null)
                return string.Empty;
 
            return await GetProfilingReport(Record.Machine.StateMachineId.Value,
                Record.Profiler, Format);
        }
 
        private static async Task GetProfilingReport(object Sender, IqEventArgs e)
        {
            string TokenId = XML.Attribute(e.Query, "tokenId");
            if (string.IsNullOrEmpty(TokenId))
            {
                await e.IqErrorBadRequest(e.To, "Missing Token ID.", "en");
                return;
            }
 
            CacheRecord Record = await GetCacheRecord(TokenId, e);
            if (Record is null)
                return;
 
            if (Record?.Profiler is null)
            {
                await e.IqErrorServiceUnavailable(e.To, "Profiler not activated on the state-machine.", "en");
                return;
            }
 
            ReportFormat ReportFormat = XML.Attribute(e.Query, "format", ReportFormat.Markdown);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<report xmlns='");
            Xml.Append(StateMachineNamespace);
            Xml.Append("'>");
 
            Xml.Append(XML.Encode(await GetProfilingReport(
                Record.Machine.StateMachineId.Value, Record.Profiler, ReportFormat)));
 
            Xml.Append("</report>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private static async Task<string> GetProfilingReport(string StateMachineId, Profiler Profiler,
            ReportFormat Format)
        {
            using Semaphore Semaphore = await Semaphores.BeginRead("machine:" + StateMachineId);
            StringBuilder Markdown = new StringBuilder();
 
            Markdown.AppendLine("Timing Diagram");
            Markdown.AppendLine("==================");
            Markdown.AppendLine();
            Markdown.AppendLine("```uml");
            Profiler.ExportPlantUml(Markdown, TimeUnit.DynamicPerProfiling);
            Markdown.AppendLine("```");
 
            int i, c = Profiler.NoteCount;
 
            for (i = 1; i <= c; i++)
            {
                if (Profiler.TryGetNote(i, out object Note))
                {
                    Markdown.AppendLine();
                    Markdown.Append("Note ");
                    Markdown.AppendLine(i.ToString());
                    Markdown.AppendLine("-----------------");
                    Markdown.AppendLine();
 
                    if (Note is string s)
                    {
                        if (s.StartsWith("@startjson") && s.EndsWith("@endjson"))
                        {
                            Markdown.AppendLine("```uml");
                            Markdown.AppendLine(s);
                            Markdown.AppendLine("```");
                        }
                        else
                            Markdown.AppendLine(MarkdownDocument.Encode(s));
                    }
                    else if (Note is ScriptRuntimeException ScriptError)
                    {
                        Markdown.AppendLine(MarkdownDocument.Encode(ScriptError.Message));
                        Markdown.AppendLine();
                        Markdown.AppendLine("```");
                        Markdown.AppendLine(ScriptError.Node?.SubExpression ?? ScriptError.StackTrace);
                        Markdown.AppendLine("```");
                    }
                    else if (Note is StateMachineErrorException MachineError)
                    {
                        Markdown.AppendLine(MarkdownDocument.Encode(MachineError.Message));
                    }
                    else if (Note is Exception ex)
                    {
                        Markdown.AppendLine(MarkdownDocument.Encode(ex.Message));
                        Markdown.AppendLine();
                        Markdown.AppendLine("```");
                        Markdown.AppendLine(ex.StackTrace);
                        Markdown.AppendLine("```");
                    }
                    else
                    {
                        Markdown.AppendLine("```uml");
                        Markdown.AppendLine("@startjson");
                        Markdown.AppendLine(JSON.Encode(Note, true));
                        Markdown.AppendLine("@endjson");
                        Markdown.AppendLine("```");
                    }
                }
            }
 
            return await NeuroFeaturesProcessor.FormatReport(Markdown.ToString(), Format, HttpServer.CreateSessionVariables());
        }
 
        #endregion
 
        #region GetPresentReport
 
        internal static async Task<string> GetPresentReportAsync(Token Token, ReportFormat Format)
        {
            CacheRecord Record = await GetStateMachine(Token, false);
            if (Record is null)
                return string.Empty;
 
            return await GetPresentReport(Record, Format);
        }
 
        private static async Task GetPresentReport(object Sender, IqEventArgs e)
        {
            string TokenId = XML.Attribute(e.Query, "tokenId");
            if (string.IsNullOrEmpty(TokenId))
            {
                await e.IqErrorBadRequest(e.To, "Missing Token ID.", "en");
                return;
            }
 
            CacheRecord Record = await GetCacheRecord(TokenId, e);
            if (Record is null)
                return;
 
            ReportFormat ReportFormat = XML.Attribute(e.Query, "format", ReportFormat.Markdown);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<report xmlns='");
            Xml.Append(StateMachineNamespace);
            Xml.Append("'>");
            Xml.Append(XML.Encode(await GetPresentReport(Record, ReportFormat)));
            Xml.Append("</report>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private static async Task<string> GetPresentReport(CacheRecord Record, ReportFormat Format)
        {
            using Semaphore Semaphore = await Semaphores.BeginRead("machine:" + Record.Machine.StateMachineId.Value);
            string Markdown = null;
 
            foreach (IStateMachineNode Node in Record.Machine.Root.ChildNodes)
            {
                if (Node is ReportPresent Report)
                {
                    Markdown = Report.Markdown;
                    break;
                }
            }
 
            if (string.IsNullOrEmpty(Markdown))
                return string.Empty;
 
            Variables Variables = Record.CurrentState.GetVariables(Record.Machine);
 
            return await NeuroFeaturesProcessor.FormatReport(Markdown, Format, Variables);
        }
 
        #endregion
 
        #region GetHistoryReport
 
        internal static async Task<string> GetHistoryReportAsync(Token Token, ReportFormat Format)
        {
            CacheRecord Record = await GetStateMachine(Token, false);
            if (Record is null)
                return string.Empty;
 
            return await GetHistoryReport(Record, Format);
        }
 
        private static async Task GetHistoryReport(object Sender, IqEventArgs e)
        {
            string TokenId = XML.Attribute(e.Query, "tokenId");
            if (string.IsNullOrEmpty(TokenId))
            {
                await e.IqErrorBadRequest(e.To, "Missing Token ID.", "en");
                return;
            }
 
            CacheRecord Record = await GetCacheRecord(TokenId, e);
            if (Record is null)
                return;
 
            ReportFormat ReportFormat = XML.Attribute(e.Query, "format", ReportFormat.Markdown);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<report xmlns='");
            Xml.Append(StateMachineNamespace);
            Xml.Append("'>");
            Xml.Append(XML.Encode(await GetHistoryReport(Record, ReportFormat)));
            Xml.Append("</report>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private static async Task<string> GetHistoryReport(CacheRecord Record, ReportFormat Format)
        {
            using Semaphore Semaphore = await Semaphores.BeginRead("machine:" + Record.Machine.StateMachineId.Value);
            string Markdown = null;
 
            foreach (IStateMachineNode Node in Record.Machine.Root.ChildNodes)
            {
                if (Node is ReportHistory Report)
                {
                    Markdown = Report.Markdown;
                    break;
                }
            }
 
            if (string.IsNullOrEmpty(Markdown))
                return string.Empty;
 
            Variables Variables = await GetHistoryVariables(Record);
 
            return await NeuroFeaturesProcessor.FormatReport(Markdown, Format, Variables);
        }
 
 
        public static async Task<Variables> GetHistoryVariables(string MachineId)
        {
            CacheRecord Record = await GetStateMachine(MachineId, false);
            return await GetHistoryVariables(Record);
        }
 
        private static async Task<Variables> GetHistoryVariables(CacheRecord Record)
        {
            Dictionary<string, SortedDictionary<DateTime, StateMachineSample>> ByVariableAndTime = new Dictionary<string, SortedDictionary<DateTime, StateMachineSample>>();
            SortedDictionary<DateTime, StateMachineSample> ByTime = null;
            IEnumerable<StateMachineSample> Samples = await Database.Find<StateMachineSample>(
                new FilterFieldEqualTo("StateMachineId", Record.Machine.StateMachineId.Value),
                "Variable", "Timestamp");
            string LastVariable = null;
            Variables Variables = Record.CurrentState.GetVariables(Record.Machine);
            DateTime Now = DateTime.UtcNow;
 
            foreach (StateMachineSample Sample in Samples)
            {
                if (ByTime is null || Sample.Variable != LastVariable)
                {
                    LastVariable = Sample.Variable;
 
                    if (!ByVariableAndTime.TryGetValue(LastVariable, out ByTime))
                    {
                        ByTime = new SortedDictionary<DateTime, StateMachineSample>(timestampDescending);
                        ByVariableAndTime[LastVariable] = ByTime;
                    }
                }
 
                ByTime[Sample.Timestamp] = Sample;
            }
 
            foreach (KeyValuePair<string, SortedDictionary<DateTime, StateMachineSample>> P in ByVariableAndTime)
            {
                if (Variables.TryGetVariable(P.Key, out Script.Variable v))
                {
                    P.Value[Now] = new StateMachineSample()
                    {
                        StateMachineId = Record.Machine.StateMachineId,
                        Variable = P.Key,
                        Value = v.ValueObject,
                        Timestamp = Now,
                        Expires = Record.Machine.Expires,
                        ArchiveOptional = Record.Machine.ArchiveOptional,
                        ArchiveRequired = Record.Machine.ArchiveRequired
                    };
                }
 
                StateMachineSample[] History = new StateMachineSample[P.Value.Count];
                P.Value.Values.CopyTo(History, 0);
                Variables[P.Key] = History;
            }
 
            return Variables;
        }
 
        private class TimestampDescending : IComparer<DateTime>
        {
            public int Compare(DateTime x, DateTime y)
            {
                return y.CompareTo(x);
            }
        }
 
        private static readonly TimestampDescending timestampDescending = new TimestampDescending();
 
        #endregion
 
        #region GetStateDiagram
 
        internal static async Task<string> GetStateDiagramAsync(Token Token, ReportFormat Format)
        {
            CacheRecord Record = await GetStateMachine(Token, false);
            if (Record is null)
                return string.Empty;
 
            return await GetStateDiagram(Record, Format);
        }
 
        private static async Task GetStateDiagram(object Sender, IqEventArgs e)
        {
            string TokenId = XML.Attribute(e.Query, "tokenId");
            if (string.IsNullOrEmpty(TokenId))
            {
                await e.IqErrorBadRequest(e.To, "Missing Token ID.", "en");
                return;
            }
 
            CacheRecord Record = await GetCacheRecord(TokenId, e);
            if (Record is null)
                return;
 
            ReportFormat ReportFormat = XML.Attribute(e.Query, "format", ReportFormat.Markdown);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<report xmlns='");
            Xml.Append(StateMachineNamespace);
            Xml.Append("'>");
            Xml.Append(XML.Encode(await GetStateDiagram(Record, ReportFormat)));
            Xml.Append("</report>");
 
            await e.IqResult(Xml.ToString(), e.To);
        }
 
        private static async Task<string> GetStateDiagram(CacheRecord Record, ReportFormat Format)
        {
            using Semaphore Semaphore = await Semaphores.BeginRead("machine:" + Record.Machine.StateMachineId.Value);
            StringBuilder Markdown = new StringBuilder();
            StateMachine Machine = Record.Machine;
            Dictionary<string, string> States = new Dictionary<string, string>();
            LinkedList<State> StateNodes = new LinkedList<State>();
            string s;
            int AIndex = 0;
 
            Markdown.AppendLine("```uml");
            Markdown.AppendLine("@startuml");
            Markdown.AppendLine();
            Markdown.AppendLine("skinparam state {");
            Markdown.AppendLine("\tFontSize 12");
            Markdown.AppendLine("\tFontStyle Italic");
            Markdown.AppendLine("\tAttributeFontSize 18");
            Markdown.AppendLine("\tBackgroundColor<<Action>> LightSalmon");
            Markdown.AppendLine("\tBackgroundColor<<Calc>> LightBlue");
            Markdown.AppendLine("\tBackgroundColor<<Current>> LightGreen");
            Markdown.AppendLine("\tFontStyle<<Current>> Bold, Italic");
            Markdown.AppendLine("\tAttributeFontStyle<<Current>> Bold");
            Markdown.AppendLine("\tBorderColor<<Current>> Black");
            Markdown.AppendLine("}");
            Markdown.AppendLine();
            Markdown.AppendLine("skinparam note {");
            Markdown.AppendLine("\tBackgroundColor<<Warning>> Salmon");
            Markdown.AppendLine("}");
            Markdown.AppendLine();
 
            Markdown.AppendLine("state \"Initialize\" as Init");
            Markdown.AppendLine("[*] --> Init");
 
            Markdown.Append("Init --> ");
            Markdown.AppendLine(GetStateLabel(States, Machine.Root.StartState));
 
            foreach (IStateMachineNode Node in Machine.Root.ChildNodes)
            {
                if (Node is Model.Variable Variable)
                {
                    Markdown.Append("Init : ");
                    Markdown.Append(Variable.Id);
 
                    if (Record.CurrentState.TryGetVariable(Variable.Id, out CurrentStateVariable StateVariable) &&
                        !string.IsNullOrEmpty(StateVariable.InitExpression))
                    {
                        Markdown.Append(":=");
                        Markdown.Append(EncodeLabel(StateVariable.InitExpression));
                    }
 
                    Markdown.AppendLine();
                }
                else if (Node is State State)
                {
                    StateNodes.AddLast(State);
 
                    Markdown.AppendLine();
                    Markdown.Append("state \"State\" as ");
                    Markdown.Append(GetStateLabel(States, State.Id));
 
                    if (State.Id == Record.CurrentState.State)
                        Markdown.Append(" <<Current>>");
 
                    Markdown.Append(" : ");
                    Markdown.AppendLine(EncodeLabel(State.Id));
                }
            }
 
            foreach (State State in StateNodes)
            {
                s = GetStateLabel(States, State.Id);
 
                if (State.OnEvent is null)
                {
                    Markdown.Append("note right of ");
                    Markdown.Append(s);
                    Markdown.AppendLine(" <<Warning>> : No events defined.");
                    continue;
                }
 
                foreach (OnEvent Event in State.OnEvent)
                    GenerateEventStateDiagram(Event, Markdown, State, ref AIndex, s, States, Machine);
 
                Markdown.AppendLine();
            }
 
            Markdown.AppendLine("@enduml");
            Markdown.AppendLine("```");
 
            return await NeuroFeaturesProcessor.FormatReport(Markdown.ToString(), Format, HttpServer.CreateSessionVariables());
        }
 
        private static void GenerateEventStateDiagram(OnEvent Event, StringBuilder Markdown,
            State State, ref int AIndex, string s, Dictionary<string, string> States,
            StateMachine Machine)
        {
            string s2;
            string s3 = Event.Event.Label;
 
            if (!(State.OnLeave is null))
            {
                foreach (OnLeave OnLeave in State.OnLeave)
                {
                    AIndex++;
                    s2 = "A" + AIndex.ToString();
 
                    Markdown.Append("state \"OnLeave Action\" as ");
                    Markdown.Append(s2);
                    Markdown.Append(" <<Action>> : ");
                    Markdown.AppendLine(EncodeLabel(OnLeave.ActionReferenceDefinition));
 
                    Markdown.Append(s);
                    Markdown.Append(" --> ");
                    Markdown.Append(s2);
 
                    if (!string.IsNullOrEmpty(s3))
                    {
                        Markdown.Append(" : ");
                        Markdown.Append(EncodeLabel(s3));
                        s3 = string.Empty;
                    }
 
                    Markdown.AppendLine();
                    s = s2;
                }
            }
 
            if (Event.HasActionReference)
            {
                AIndex++;
                s2 = "A" + AIndex.ToString();
 
                Markdown.Append("state \"Event Action\" as ");
                Markdown.Append(s2);
                Markdown.Append(" <<Action>> : ");
                Markdown.AppendLine(EncodeLabel(Event.ActionReferenceDefinition));
 
                Markdown.Append(s);
                Markdown.Append(" --> ");
                Markdown.Append(s2);
 
                if (!string.IsNullOrEmpty(s3))
                {
                    Markdown.Append(" : ");
                    Markdown.Append(EncodeLabel(s3));
                    s3 = string.Empty;
                }
 
                Markdown.AppendLine();
                s = s2;
 
                if (Event.HasFailureState)
                    s3 = "OK";
            }
            else if (Event.HasFailureState)
            {
                if (string.IsNullOrEmpty(s3))
                    s3 = "OK";
                else
                    s3 += " and OK";
            }
 
            ActionReference[] Actions;
            bool Termination;
 
            if (Event.HasNewState && Machine.TryGetState(Event.NewStateDefinition, out State NewState))
            {
                Actions = NewState.OnEnter;
                Termination = NewState.IsDone(Machine);
            }
            else
            {
                Actions = null;
                Termination = false;
            }
 
            GenerateOnEnterBranch(Event, Markdown, State, ref AIndex, s, States,
                Actions, s3, Event.NewStateDefinition, Termination);
 
            if (Event.HasFailureState)
            {
                if (Machine.TryGetState(Event.FailureStateDefinition, out State FailureState))
                {
                    Actions = FailureState.OnEnter;
                    Termination = FailureState.IsDone(Machine);
                }
                else
                {
                    Actions = null;
                    Termination = false;
                }
 
                GenerateOnEnterBranch(Event, Markdown, State, ref AIndex, s, States,
                    Actions, "Error", Event.FailureStateDefinition, Termination);
            }
        }
 
        private static void GenerateOnEnterBranch(OnEvent Event, StringBuilder Markdown,
            State State, ref int AIndex, string s, Dictionary<string, string> States,
            ActionReference[] Actions, string s3, string NewState, bool Termination)
        {
            string s2;
 
            if (!(Actions is null) && !Termination)
            {
                foreach (ActionReference Action in Actions)
                {
                    AIndex++;
                    s2 = "A" + AIndex.ToString();
 
                    Markdown.Append("state \"OnEnter Action\" as ");
                    Markdown.Append(s2);
                    Markdown.Append(" <<Action>> : ");
                    Markdown.AppendLine(EncodeLabel(Action.ActionReferenceDefinition));
 
                    Markdown.Append(s);
                    Markdown.Append(" --> ");
                    Markdown.Append(s2);
 
                    if (!string.IsNullOrEmpty(s3))
                    {
                        Markdown.Append(" : ");
                        Markdown.Append(EncodeLabel(s3));
                        s3 = string.Empty;
                    }
 
                    Markdown.AppendLine();
                    s = s2;
                }
            }
 
            if (Termination)
                s2 = "[*]";
            else
            {
                if (string.IsNullOrEmpty(NewState))
                    NewState = State.Id;
 
                bool VarState = !States.ContainsKey(NewState);
 
                s2 = GetStateLabel(States, NewState);
 
                if (VarState)
                {
                    Markdown.Append("state \"Calc\" as ");
                    Markdown.Append(s2);
                    Markdown.Append(" <<Calc>> : ");
                    Markdown.AppendLine(EncodeLabel(Event.NewStateDefinition));
 
                    Markdown.Append("note right of ");
                    Markdown.Append(s2);
                    Markdown.AppendLine(" <<Warning>> : Variable state, through script.");
                }
            }
 
            Markdown.Append(s);
            Markdown.Append(" --> ");
            Markdown.Append(s2);
 
            if (!string.IsNullOrEmpty(s3))
            {
                Markdown.Append(" : ");
                Markdown.Append(EncodeLabel(s3));
            }
 
            Markdown.AppendLine();
        }
 
 
        private static string GetStateLabel(Dictionary<string, string> States, string StateId)
        {
            if (!States.TryGetValue(StateId, out string Id))
            {
                int Index = States.Count + 1;
                States[StateId] = Id = "S" + Index.ToString();
            }
 
            return Id;
        }
 
        private static string EncodeLabel(string s)
        {
            return s.
                Replace("\\", "\\\\").
                Replace("\"", "'").
                Replace("\a", "\\a").
                Replace("\b", "\\b").
                Replace("\f", "\\f").
                Replace("\n", "\\n").
                Replace("\r", "\\r").
                Replace("\t", "\\t").
                Replace("\v", "\\v");
        }
 
        #endregion
 
        #endregion
 
    }
}