NeuroFeaturesClient.cs

using NeuroFeatures.EventArguments;
using NeuroFeatures.Events;
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;
using Waher.Networking.XMPP.Contracts;
using Waher.Networking.XMPP.Contracts.EventArguments;
using Waher.Networking.XMPP.Events;
using Waher.Script;
 
namespace NeuroFeatures
{
    public class NeuroFeaturesClient : XmppExtension
    {
        public const string NamespaceNeuroFeatures = "https://paiwise.tagroot.io/Schema/NeuroFeatures.xsd";
 
        public const string NamespaceStateMachine = "https://paiwise.tagroot.io/Schema/StateMachines.xsd";
 
        public const string DefinitionStateMachine = "StateMachine";
 
        private readonly ContractsClient contractsClient;
        private readonly string componentAddress;
 
        #region Setup
 
        public NeuroFeaturesClient(XmppClient Client, ContractsClient ContractsClient, string ComponentAddress)
            : base(Client)
        {
            this.componentAddress = ComponentAddress;
            this.contractsClient = ContractsClient;
 
            Client.RegisterMessageHandler("tokenAdded", NamespaceNeuroFeatures, this.TokenAddedHandler, true);
            Client.RegisterMessageHandler("tokenRemoved", NamespaceNeuroFeatures, this.TokenRemovedHandler, false);
 
            Client.RegisterMessageHandler("stateUpdated", NamespaceStateMachine, this.StateUpdatedHandler, true);
            Client.RegisterMessageHandler("variablesUpdated", NamespaceStateMachine, this.VariablesUpdatedHandler, false);
        }
 
        public ContractsClient ContractsClient => this.contractsClient;
 
        public override void Dispose()
        {
            this.Client.UnregisterMessageHandler("tokenAdded", NamespaceNeuroFeatures, this.TokenAddedHandler, true);
            this.Client.UnregisterMessageHandler("tokenRemoved", NamespaceNeuroFeatures, this.TokenRemovedHandler, false);
 
            this.Client.UnregisterMessageHandler("stateUpdated", NamespaceStateMachine, this.StateUpdatedHandler, true);
            this.Client.UnregisterMessageHandler("variablesUpdated", NamespaceStateMachine, this.VariablesUpdatedHandler, false);
 
            base.Dispose();
        }
 
        public string ComponentAddress => this.componentAddress;
 
        public override string[] Extensions => new string[] { };
 
        #endregion
 
        #region Tokens
 
        #region GetToken
 
        public Task GetToken(string TokenId, EventHandlerAsync<TokenResultEventArgs> Callback, object State)
        {
            string Domain = this.GetDomain(TokenId);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<token id='");
            Xml.Append(XML.Encode(TokenId));
            Xml.Append("' xmlns='");
            Xml.Append(NamespaceNeuroFeatures);
            Xml.Append("'/>");
 
            return this.client.SendIqGet(Domain, Xml.ToString(), async (Sender, e) =>
            {
                Token ResultToken = null;
 
                if (e.Ok)
                {
                    if (e.FirstElement is null || e.FirstElement.LocalName != "token" || e.FirstElement.NamespaceURI != NamespaceNeuroFeatures)
                    {
                        e.Ok = false;
                        this.client.Error("Unexpected response.");
                    }
                    else if ((ResultToken = await Token.TryParse(e.FirstElement)) is null)
                    {
                        e.Ok = false;
                        this.client.Error("Unable to parse token.");
                    }
                }
 
                TokenResultEventArgs e2 = new TokenResultEventArgs(e, ResultToken);
                await Callback.Raise(this, e2);
            }, State);
        }
 
        private string GetDomain(string TokenId)
        {
            int i = TokenId.IndexOf('@');
 
            if (i < 0)
                return this.componentAddress;
            else
                return TokenId[(i + 1)..];
        }
 
        public async Task<Token> GetTokenAsync(string TokenId)
        {
            TaskCompletionSource<Token> Result = new TaskCompletionSource<Token>();
 
            await this.GetToken(TokenId, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e.Token);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get token."));
 
                return Task.CompletedTask;
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region Get Token References
 
        public Task GetTokenReferences(EventHandlerAsync<IdReferencesEventArgs> Callback, object State)
        {
            return this.GetTokenReferences(this.componentAddress, 0, int.MaxValue, Callback, State);
        }
 
        public Task GetTokenReferences(string Address, EventHandlerAsync<IdReferencesEventArgs> Callback, object State)
        {
            return this.GetTokenReferences(Address, 0, int.MaxValue, Callback, State);
        }
 
        public Task GetTokenReferences(int Offset, int MaxCount, EventHandlerAsync<IdReferencesEventArgs> Callback, object State)
        {
            return this.GetTokenReferences(this.componentAddress, Offset, MaxCount, Callback, State);
        }
 
        public Task GetTokenReferences(string Address, int Offset, int MaxCount, EventHandlerAsync<IdReferencesEventArgs> Callback, object State)
        {
            if (Offset < 0)
                throw new ArgumentException("Offsets cannot be negative.", nameof(Offset));
 
            if (MaxCount <= 0)
                throw new ArgumentException("Must be postitive.", nameof(MaxCount));
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<tokens references='true' xmlns='");
            Xml.Append(NamespaceNeuroFeatures);
 
            if (Offset > 0)
            {
                Xml.Append("' offset='");
                Xml.Append(Offset.ToString());
            }
 
            if (MaxCount < int.MaxValue)
            {
                Xml.Append("' maxCount='");
                Xml.Append(MaxCount.ToString());
            }
 
            Xml.Append("'/>");
 
            return this.client.SendIqGet(Address, Xml.ToString(), this.TokenReferencesResponse, new object[] { Callback, State });
        }
 
        private async Task TokenReferencesResponse(object Sender, IqResultEventArgs e)
        {
            object[] P = (object[])e.State;
            EventHandlerAsync<IdReferencesEventArgs> Callback = (EventHandlerAsync<IdReferencesEventArgs>)P[0];
            XmlElement E = e.FirstElement;
            List<string> IDs = new List<string>();
 
            if (e.Ok && !(E is null))
            {
                foreach (XmlNode N in E.ChildNodes)
                {
                    if (N is XmlElement E2 && E2.LocalName == "ref" && E2.NamespaceURI == NamespaceNeuroFeatures)
                    {
                        string Id = XML.Attribute(E2, "id");
                        IDs.Add(Id);
                    }
                }
            }
            else
                e.Ok = false;
 
            e.State = P[1];
            await Callback.Raise(this, new IdReferencesEventArgs(e, IDs.ToArray()));
        }
 
        public Task<string[]> GetTokenReferencesAsync()
        {
            return this.GetTokenReferencesAsync(this.componentAddress, 0, int.MaxValue);
        }
 
        public Task<string[]> GetTokenReferencesAsync(string Address)
        {
            return this.GetTokenReferencesAsync(Address, 0, int.MaxValue);
        }
 
        public Task<string[]> GetTokenReferencesAsync(int Offset, int MaxCount)
        {
            return this.GetTokenReferencesAsync(this.componentAddress, Offset, MaxCount);
        }
 
        public async Task<string[]> GetTokenReferencesAsync(string Address, int Offset, int MaxCount)
        {
            TaskCompletionSource<string[]> Result = new TaskCompletionSource<string[]>();
 
            await this.GetTokenReferences(Address, Offset, MaxCount, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e.References);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get token references."));
 
                return Task.CompletedTask;
 
            }, null);
 
            return await Result.Task;
        }
 
 
 
        #endregion
 
        #region Get Tokens
        public Task GetTokens(EventHandlerAsync<TokensEventArgs> Callback, object State)
        {
            return this.GetTokens(this.componentAddress, 0, int.MaxValue, Callback, State);
        }
 
        public Task GetTokens(string Address, EventHandlerAsync<TokensEventArgs> Callback, object State)
        {
            return this.GetTokens(Address, 0, int.MaxValue, Callback, State);
        }
 
        public Task GetTokens(int Offset, int MaxCount, EventHandlerAsync<TokensEventArgs> Callback, object State)
        {
            return this.GetTokens(this.componentAddress, Offset, MaxCount, Callback, State);
        }
 
        public Task GetTokens(string Address, int Offset, int MaxCount, EventHandlerAsync<TokensEventArgs> Callback, object State)
        {
            if (Offset < 0)
                throw new ArgumentException("Offsets cannot be negative.", nameof(Offset));
 
            if (MaxCount <= 0)
                throw new ArgumentException("Must be postitive.", nameof(MaxCount));
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<tokens references='false' xmlns='");
            Xml.Append(NamespaceNeuroFeatures);
 
            if (Offset > 0)
            {
                Xml.Append("' offset='");
                Xml.Append(Offset.ToString());
            }
 
            if (MaxCount < int.MaxValue)
            {
                Xml.Append("' maxCount='");
                Xml.Append(MaxCount.ToString());
            }
 
            Xml.Append("'/>");
 
            return this.client.SendIqGet(Address, Xml.ToString(), this.TokensResponse, new object[] { Callback, State });
        }
 
        private async Task TokensResponse(object Sender, IqResultEventArgs e)
        {
            object[] P = (object[])e.State;
            EventHandlerAsync<TokensEventArgs> Callback = (EventHandlerAsync<TokensEventArgs>)P[0];
            XmlElement E = e.FirstElement;
            List<Token> Tokens = new List<Token>();
            List<string> References = new List<string>();
 
            if (e.Ok && !(E is null))
            {
                foreach (XmlNode N in E.ChildNodes)
                {
                    if (N is XmlElement E2 && E2.NamespaceURI == NamespaceNeuroFeatures)
                    {
                        switch (E2.LocalName)
                        {
                            case "token":
                                Token ParsedToken = await Token.TryParse(E2);
                                if (!(ParsedToken is null))
                                    Tokens.Add(ParsedToken);
                                break;
 
                            case "ref":
                                string TokenId = XML.Attribute(E2, "id");
                                References.Add(TokenId);
                                break;
                        }
                    }
                }
            }
            else
                e.Ok = false;
 
            e.State = P[1];
            await Callback.Raise(this, new TokensEventArgs(e, Tokens.ToArray(), References.ToArray()));
        }
 
        public Task<TokensEventArgs> GetTokensAsync()
        {
            return this.GetTokensAsync(this.componentAddress, 0, int.MaxValue);
        }
 
        public Task<TokensEventArgs> GetTokensAsync(string Address)
        {
            return this.GetTokensAsync(Address, 0, int.MaxValue);
        }
 
        public Task<TokensEventArgs> GetTokensAsync(int Offset, int MaxCount)
        {
            return this.GetTokensAsync(this.componentAddress, Offset, MaxCount);
        }
 
        public async Task<TokensEventArgs> GetTokensAsync(string Address, int Offset, int MaxCount)
        {
            TaskCompletionSource<TokensEventArgs> Result = new TaskCompletionSource<TokensEventArgs>();
 
            await this.GetTokens(Address, Offset, MaxCount, (Sender, e) =>
            {
                Result.TrySetResult(e);
                return Task.CompletedTask;
 
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region Get Contract Token References
 
        public Task GetContractTokenReferences(string ContractId, EventHandlerAsync<IdReferencesEventArgs> Callback, object State)
        {
            return this.GetContractTokenReferences(this.contractsClient.GetTrustProvider(ContractId),
                ContractId, 0, int.MaxValue, Callback, State);
        }
 
        public Task GetContractTokenReferences(string Address, string ContractId, EventHandlerAsync<IdReferencesEventArgs> Callback, object State)
        {
            return this.GetContractTokenReferences(Address, ContractId, 0, int.MaxValue, Callback, State);
        }
 
        public Task GetContractTokenReferences(string ContractId, int Offset, int MaxCount, EventHandlerAsync<IdReferencesEventArgs> Callback, object State)
        {
            return this.GetContractTokenReferences(this.contractsClient.GetTrustProvider(ContractId),
                ContractId, Offset, MaxCount, Callback, State);
        }
 
        public Task GetContractTokenReferences(string Address, string ContractId, int Offset, int MaxCount, EventHandlerAsync<IdReferencesEventArgs> Callback, object State)
        {
            if (Offset < 0)
                throw new ArgumentException("Offsets cannot be negative.", nameof(Offset));
 
            if (MaxCount <= 0)
                throw new ArgumentException("Must be postitive.", nameof(MaxCount));
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<contractTokens contractId='");
            Xml.Append(XML.Encode(ContractId));
            Xml.Append("' references='true' xmlns='");
            Xml.Append(NamespaceNeuroFeatures);
 
            if (Offset > 0)
            {
                Xml.Append("' offset='");
                Xml.Append(Offset.ToString());
            }
 
            if (MaxCount < int.MaxValue)
            {
                Xml.Append("' maxCount='");
                Xml.Append(MaxCount.ToString());
            }
 
            Xml.Append("'/>");
 
            return this.client.SendIqGet(Address, Xml.ToString(), this.TokenReferencesResponse, new object[] { Callback, State });
        }
 
        public Task<string[]> GetContractTokenReferencesAsync(string ContractId)
        {
            return this.GetContractTokenReferencesAsync(this.contractsClient.GetTrustProvider(ContractId),
                ContractId, 0, int.MaxValue);
        }
 
        public Task<string[]> GetContractTokenReferencesAsync(string Address, string ContractId)
        {
            return this.GetContractTokenReferencesAsync(Address, ContractId, 0, int.MaxValue);
        }
 
        public Task<string[]> GetContractTokenReferencesAsync(string ContractId, int Offset, int MaxCount)
        {
            return this.GetContractTokenReferencesAsync(this.contractsClient.GetTrustProvider(ContractId),
                ContractId, Offset, MaxCount);
        }
 
        public async Task<string[]> GetContractTokenReferencesAsync(string Address, string ContractId, int Offset, int MaxCount)
        {
            TaskCompletionSource<string[]> Result = new TaskCompletionSource<string[]>();
 
            await this.GetContractTokenReferences(Address, ContractId, Offset, MaxCount, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e.References);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get token references."));
 
                return Task.CompletedTask;
 
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region Get Contract Tokens
 
        public Task GetContractTokens(string ContractId, EventHandlerAsync<TokensEventArgs> Callback, object State)
        {
            return this.GetContractTokens(this.contractsClient.GetTrustProvider(ContractId),
                ContractId, 0, int.MaxValue, Callback, State);
        }
 
        public Task GetContractTokens(string Address, string ContractId, EventHandlerAsync<TokensEventArgs> Callback, object State)
        {
            return this.GetContractTokens(Address, ContractId, 0, int.MaxValue, Callback, State);
        }
 
        public Task GetContractTokens(string ContractId, int Offset, int MaxCount, EventHandlerAsync<TokensEventArgs> Callback, object State)
        {
            return this.GetContractTokens(this.contractsClient.GetTrustProvider(ContractId),
                ContractId, Offset, MaxCount, Callback, State);
        }
 
        public Task GetContractTokens(string Address, string ContractId, int Offset, int MaxCount, EventHandlerAsync<TokensEventArgs> Callback, object State)
        {
            if (Offset < 0)
                throw new ArgumentException("Offsets cannot be negative.", nameof(Offset));
 
            if (MaxCount <= 0)
                throw new ArgumentException("Must be postitive.", nameof(MaxCount));
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<contractTokens contractId='");
            Xml.Append(XML.Encode(ContractId));
            Xml.Append("' references='false' xmlns='");
            Xml.Append(NamespaceNeuroFeatures);
 
            if (Offset > 0)
            {
                Xml.Append("' offset='");
                Xml.Append(Offset.ToString());
            }
 
            if (MaxCount < int.MaxValue)
            {
                Xml.Append("' maxCount='");
                Xml.Append(MaxCount.ToString());
            }
 
            Xml.Append("'/>");
 
            return this.client.SendIqGet(Address, Xml.ToString(), this.TokensResponse, new object[] { Callback, State });
        }
 
        public Task<TokensEventArgs> GetContractTokensAsync(string ContractId)
        {
            return this.GetContractTokensAsync(this.contractsClient.GetTrustProvider(ContractId),
                ContractId, 0, int.MaxValue);
        }
 
        public Task<TokensEventArgs> GetContractTokensAsync(string Address, string ContractId)
        {
            return this.GetContractTokensAsync(Address, ContractId, 0, int.MaxValue);
        }
 
        public Task<TokensEventArgs> GetContractTokensAsync(string ContractId, int Offset, int MaxCount)
        {
            return this.GetContractTokensAsync(this.contractsClient.GetTrustProvider(ContractId),
                ContractId, Offset, MaxCount);
        }
 
        public async Task<TokensEventArgs> GetContractTokensAsync(string Address, string ContractId, int Offset, int MaxCount)
        {
            TaskCompletionSource<TokensEventArgs> Result = new TaskCompletionSource<TokensEventArgs>();
 
            await this.GetContractTokens(Address, ContractId, Offset, MaxCount, (Sender, e) =>
            {
                Result.TrySetResult(e);
                return Task.CompletedTask;
 
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region TokenAdded
 
        private async Task TokenAddedHandler(object Sender, MessageEventArgs e)
        {
            Token TokenAdded;
 
            foreach (XmlNode N in e.Content.ChildNodes)
            {
                if (N is XmlElement E &&
                    E.LocalName == "token" &&
                    E.NamespaceURI == NamespaceNeuroFeatures &&
                    !((TokenAdded = await Token.TryParse(E)) is null))
                {
                    await this.TokenAdded.Raise(this, new TokenEventArgs(e, TokenAdded));
                }
            }
        }
 
        public event EventHandlerAsync<TokenEventArgs> TokenAdded;
 
        #endregion
 
        #region TokenRemoved
 
        private async Task TokenRemovedHandler(object Sender, MessageEventArgs e)
        {
            Token TokenRemoved;
 
            foreach (XmlNode N in e.Content.ChildNodes)
            {
                if (N is XmlElement E &&
                    E.LocalName == "token" &&
                    E.NamespaceURI == NamespaceNeuroFeatures &&
                    !((TokenRemoved = await Token.TryParse(E)) is null))
                {
                    await this.TokenRemoved.Raise(this, new TokenEventArgs(e, TokenRemoved));
                }
            }
        }
 
        public event EventHandlerAsync<TokenEventArgs> TokenRemoved;
 
        #endregion
 
        #region Get Total
 
        public Task GetTotals(EventHandlerAsync<TokenTotalsEventArgs> Callback, object State)
        {
            return this.GetTotals(this.componentAddress, Callback, State);
        }
 
        public Task GetTotals(string Address, EventHandlerAsync<TokenTotalsEventArgs> Callback, object State)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<totals xmlns='");
            Xml.Append(NamespaceNeuroFeatures);
            Xml.Append("'/>");
 
            return this.client.SendIqGet(Address, Xml.ToString(), this.TotalsResponse, new object[] { Callback, State });
        }
 
        private async Task TotalsResponse(object Sender, IqResultEventArgs e)
        {
            object[] P = (object[])e.State;
            EventHandlerAsync<TokenTotalsEventArgs> Callback = (EventHandlerAsync<TokenTotalsEventArgs>)P[0];
            XmlElement E = e.FirstElement;
            List<TokenTotal> Totals = new List<TokenTotal>();
 
            if (e.Ok && !(E is null) && E.LocalName == "totals" && E.NamespaceURI == NamespaceNeuroFeatures)
            {
                foreach (XmlNode N in E.ChildNodes)
                {
                    if (N is XmlElement E2 && E2.NamespaceURI == NamespaceNeuroFeatures && E2.LocalName == "total")
                    {
                        Totals.Add(new TokenTotal()
                        {
                            NrTokens = XML.Attribute(E2, "nr", 0),
                            Total = XML.Attribute(E2, "total", 0.0m),
                            Currency = XML.Attribute(E2, "currency")
                        });
                    }
                }
            }
            else
                e.Ok = false;
 
            e.State = P[1];
            await Callback.Raise(this, new TokenTotalsEventArgs(e, Totals.ToArray()));
        }
 
        public Task<TokenTotalsEventArgs> GetTotalsAsync()
        {
            return this.GetTotalsAsync(this.componentAddress);
        }
 
        public async Task<TokenTotalsEventArgs> GetTotalsAsync(string Address)
        {
            TaskCompletionSource<TokenTotalsEventArgs> Result = new TaskCompletionSource<TokenTotalsEventArgs>();
 
            await this.GetTotals(Address, (Sender, e) =>
            {
                Result.TrySetResult(e);
                return Task.CompletedTask;
 
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region AddTextNote
 
        public Task AddTextNote(string TokenId, string Note, EventHandlerAsync<IqResultEventArgs> Callback, object State)
        {
            return this.AddTextNote(TokenId, Note, false, Callback, State);
        }
 
        public Task AddTextNote(string TokenId, string Note, bool Personal, EventHandlerAsync<IqResultEventArgs> Callback, object State)
        {
            string Domain = this.GetDomain(TokenId);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<noteText xmlns='");
            Xml.Append(NamespaceNeuroFeatures);
            Xml.Append("' id='");
            Xml.Append(XML.Encode(TokenId));
            Xml.Append("' personal='");
            Xml.Append(CommonTypes.Encode(Personal));
            Xml.Append("'>");
            Xml.Append(XML.Encode(Note));
            Xml.Append("</noteText>");
 
            return this.client.SendIqSet(Domain, Xml.ToString(), Callback, State);
        }
 
        public Task AddTextNoteAsync(string TokenId, string Note)
        {
            return this.AddTextNoteAsync(TokenId, Note, false);
        }
 
        public async Task AddTextNoteAsync(string TokenId, string Note, bool Personal)
        {
            TaskCompletionSource<bool> Result = new TaskCompletionSource<bool>();
 
            await this.AddTextNote(TokenId, Note, Personal, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(true);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to add text note."));
 
                return Task.CompletedTask;
            }, null);
 
            await Result.Task;
        }
 
        #endregion
 
        #region AddXmlNote
 
        public Task AddXmlNote(string TokenId, string Note, EventHandlerAsync<IqResultEventArgs> Callback, object State)
        {
            return this.AddXmlNote(TokenId, Note, false, Callback, State);
        }
 
        public Task AddXmlNote(string TokenId, string Note, bool Personal, EventHandlerAsync<IqResultEventArgs> Callback, object State)
        {
            if (!XML.IsValidXml(Note))
                throw new ArgumentException("Note is not valid XML.", nameof(Note));
 
            string Domain = this.GetDomain(TokenId);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<noteXml xmlns='");
            Xml.Append(NamespaceNeuroFeatures);
            Xml.Append("' id='");
            Xml.Append(XML.Encode(TokenId));
            Xml.Append("' personal='");
            Xml.Append(CommonTypes.Encode(Personal));
            Xml.Append("'>");
            Xml.Append(Note);
            Xml.Append("</noteXml>");
 
            return this.client.SendIqSet(Domain, Xml.ToString(), Callback, State);
        }
 
        public Task AddXmlNoteAsync(string TokenId, string Note)
        {
            return this.AddXmlNoteAsync(TokenId, Note, false);
        }
 
        public async Task AddXmlNoteAsync(string TokenId, string Note, bool Personal)
        {
            TaskCompletionSource<bool> Result = new TaskCompletionSource<bool>();
 
            await this.AddXmlNote(TokenId, Note, Personal, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(true);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to add xml note."));
 
                return Task.CompletedTask;
            }, null);
 
            await Result.Task;
        }
 
        #endregion
 
        #region GetEvents
 
        public Task GetEvents(string TokenId, EventHandlerAsync<EventsEventArgs> Callback, object State)
        {
            return this.GetEvents(TokenId, 0, int.MaxValue, Callback, State);
        }
 
        public Task GetEvents(string TokenId, int Offset, int MaxCount, EventHandlerAsync<EventsEventArgs> Callback, object State)
        {
            if (Offset < 0)
                throw new ArgumentException("Offsets cannot be negative.", nameof(Offset));
 
            if (MaxCount <= 0)
                throw new ArgumentException("Must be postitive.", nameof(MaxCount));
 
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<events xmlns='");
            Xml.Append(NamespaceNeuroFeatures);
            Xml.Append("' id='");
            Xml.Append(XML.Encode(TokenId));
 
            if (Offset > 0)
            {
                Xml.Append("' offset='");
                Xml.Append(Offset.ToString());
            }
 
            if (MaxCount < int.MaxValue)
            {
                Xml.Append("' maxCount='");
                Xml.Append(MaxCount.ToString());
            }
 
            Xml.Append("'/>");
 
            return this.client.SendIqGet(this.GetDomain(TokenId), Xml.ToString(), async (Sender, e) =>
            {
                XmlElement E = e.FirstElement;
                List<TokenEvent> Events = new List<TokenEvent>();
 
                if (e.Ok && !(E is null))
                {
                    foreach (XmlNode N in E.ChildNodes)
                    {
                        if (N is XmlElement E2 && E2.NamespaceURI == NamespaceNeuroFeatures)
                        {
                            if (TokenEvent.TryParse(E2, out TokenEvent Event))
                                Events.Add(Event);
                        }
                    }
                }
                else
                    e.Ok = false;
 
                e.State = State;
                await Callback.Raise(this, new EventsEventArgs(e, Events.ToArray()));
 
            }, null);
        }
 
        public Task<TokenEvent[]> GetEventsAsync(string TokenId)
        {
            return this.GetEventsAsync(TokenId, 0, int.MaxValue);
        }
 
        public async Task<TokenEvent[]> GetEventsAsync(string TokenId, int Offset, int MaxCount)
        {
            TaskCompletionSource<TokenEvent[]> Result = new TaskCompletionSource<TokenEvent[]>();
 
            await this.GetEvents(TokenId, Offset, MaxCount, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e.Events);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get token events."));
 
                return Task.CompletedTask;
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region GetCreationAttributes
 
        public Task GetCreationAttributes(EventHandlerAsync<CreationAttributesEventArgs> Callback, object State)
        {
            return this.client.SendIqGet(this.componentAddress, "<creationAttributes xmlns='" + NamespaceNeuroFeatures + "'/>", (Sender, e) =>
            {
                return Callback.Raise(this, new CreationAttributesEventArgs(e));
            }, State);
        }
 
        public async Task<CreationAttributesEventArgs> GetCreationAttributesAsync()
        {
            TaskCompletionSource<CreationAttributesEventArgs> Result = new TaskCompletionSource<CreationAttributesEventArgs>();
 
            await this.GetCreationAttributes((Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get creation attributes."));
 
                return Task.CompletedTask;
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region GenerateDescription
 
        public Task GenerateDescription(string TokenId, ReportFormat Format,
            EventHandlerAsync<ReportEventArgs> Callback, object State)
        {
            string Domain = this.GetDomain(TokenId);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<description xmlns='");
            Xml.Append(NamespaceNeuroFeatures);
            Xml.Append("' id='");
            Xml.Append(XML.Encode(TokenId));
            Xml.Append("' format='");
            Xml.Append(Format.ToString());
            Xml.Append("'/>");
 
            return this.client.SendIqGet(Domain, Xml.ToString(), (Sender, e) => this.ReportResponse(e, Callback), State);
        }
 
        private async Task ReportResponse(IqResultEventArgs e, EventHandlerAsync<ReportEventArgs> Callback)
        {
            try
            {
                string ReportText = null;
 
                if (e.Ok && e.FirstElement.LocalName == "report" &&
                    (e.FirstElement.NamespaceURI == NamespaceStateMachine ||
                    e.FirstElement.NamespaceURI == NamespaceNeuroFeatures))
                {
                    ReportText = e.FirstElement.InnerText;
                }
                else
                    e.Ok = false;
 
                await Callback.Raise(this, new ReportEventArgs(ReportText, e));
            }
            catch (Exception ex)
            {
                this.client.Exception(ex);
                Log.Exception(ex);
            }
        }
 
        public async Task<ReportEventArgs> GenerateDescriptionAsync(string TokenId, ReportFormat Format)
        {
            TaskCompletionSource<ReportEventArgs> Result = new TaskCompletionSource<ReportEventArgs>();
 
            await this.GenerateDescription(TokenId, Format, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get the description of the token."));
 
                return Task.CompletedTask;
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #endregion
 
        #region State-Machines
 
        #region GetCurrentState
 
        public Task GetCurrentState(string TokenId, EventHandlerAsync<CurrentStateEventArgs> Callback, object State)
        {
            string Domain = this.GetDomain(TokenId);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<currentState xmlns='");
            Xml.Append(NamespaceStateMachine);
            Xml.Append("' tokenId='");
            Xml.Append(XML.Encode(TokenId));
            Xml.Append("'/>");
 
            return this.client.SendIqGet(Domain, Xml.ToString(), async (Sender, e) =>
            {
                try
                {
                    string CurrentState = null;
                    bool Ended = false;
                    bool Running = false;
                    DateTime Expires = DateTime.MinValue;
                    Variables Variables = null;
 
                    if (e.Ok && e.FirstElement.LocalName == "currentState" && e.FirstElement.NamespaceURI == NamespaceStateMachine)
                    {
                        CurrentState = XML.Attribute(e.FirstElement, "state");
                        Ended = XML.Attribute(e.FirstElement, "ended", false);
                        Running = XML.Attribute(e.FirstElement, "running", false);
                        Expires = XML.Attribute(e.FirstElement, "expires", DateTime.MaxValue);
                        Variables = await ParseVariables(e.FirstElement);
                    }
                    else
                        e.Ok = false;
 
                    await Callback.Raise(this, new CurrentStateEventArgs(CurrentState, Ended, Running,
                        Expires, Variables, e));
                }
                catch (Exception ex)
                {
                    this.client.Exception(ex);
                    Log.Exception(ex);
                }
            }, State);
        }
 
        private async static Task<Variables> ParseVariables(XmlElement VariablesDefinition)
        {
            Variables Variables = new Variables();
 
            foreach (XmlNode N in VariablesDefinition.ChildNodes)
            {
                if (N is XmlElement E &&
                    E.LocalName == "variable" &&
                    E.NamespaceURI == NamespaceStateMachine)
                {
                    string Name = XML.Attribute(E, "name");
                    object Value = await ParseVariable(E, Variables);
 
                    Variables[Name] = Value;
                }
            }
 
            return Variables;
        }
 
        private async static Task<object> ParseVariable(XmlElement VariableDefinition, Variables Variables)
        {
            object Value = null;
 
            foreach (XmlNode N2 in VariableDefinition.ChildNodes)
            {
                if (!(N2 is XmlElement E2))
                    continue;
 
                switch (E2.LocalName)
                {
                    case "null":
                        Value = null;
                        break;
 
                    case "dbl":
                        if (CommonTypes.TryParse(E2.InnerText, out double dbl))
                            Value = dbl;
                        break;
 
                    case "fl":
                        if (CommonTypes.TryParse(E2.InnerText, out float fl))
                            Value = fl;
                        break;
 
                    case "dec":
                        if (CommonTypes.TryParse(E2.InnerText, out decimal dec))
                            Value = dec;
                        break;
 
                    case "i8":
                        if (sbyte.TryParse(E2.InnerText, out sbyte i8))
                            Value = i8;
                        break;
 
                    case "i16":
                        if (short.TryParse(E2.InnerText, out short i16))
                            Value = i16;
                        break;
 
                    case "i32":
                        if (int.TryParse(E2.InnerText, out int i32))
                            Value = i32;
                        break;
 
                    case "i64":
                        if (long.TryParse(E2.InnerText, out long i64))
                            Value = i64;
                        break;
 
                    case "ui8":
                        if (byte.TryParse(E2.InnerText, out byte ui8))
                            Value = ui8;
                        break;
 
                    case "ui16":
                        if (ushort.TryParse(E2.InnerText, out ushort ui16))
                            Value = ui16;
                        break;
 
                    case "ui32":
                        if (uint.TryParse(E2.InnerText, out uint ui32))
                            Value = ui32;
                        break;
 
                    case "ui64":
                        if (ulong.TryParse(E2.InnerText, out ulong ui64))
                            Value = ui64;
                        break;
 
                    case "b":
                        if (CommonTypes.TryParse(E2.InnerText, out bool b))
                            Value = b;
                        break;
 
                    case "dt":
                        if (XML.TryParse(E2.InnerText, out DateTime TP))
                            Value = TP;
                        break;
 
                    case "dto":
                        if (XML.TryParse(E2.InnerText, out DateTimeOffset TPO))
                            Value = TPO;
                        break;
 
                    case "ts":
                        if (TimeSpan.TryParse(E2.InnerText, out TimeSpan TS))
                            Value = TS;
                        break;
 
                    case "d":
                        if (Duration.TryParse(E2.InnerText, out Duration D))
                            Value = D;
                        break;
 
                    case "s":
                        Value = E2.InnerText;
                        break;
 
                    case "exp":
                        try
                        {
                            Expression Exp = new Expression(E2.InnerText);
                            Value = await Exp.EvaluateAsync(Variables);
                        }
                        catch (Exception)
                        {
                            Value = E2.InnerText;
                        }
                        break;
                }
            }
 
            return Value;
        }
 
        public async Task<CurrentStateEventArgs> GetCurrentStateAsync(string TokenId)
        {
            TaskCompletionSource<CurrentStateEventArgs> Result = new TaskCompletionSource<CurrentStateEventArgs>();
 
            await this.GetCurrentState(TokenId, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get current state of state-machine."));
 
                return Task.CompletedTask;
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region GenerateProfilingReport
 
        public Task GenerateProfilingReport(string TokenId, ReportFormat Format,
            EventHandlerAsync<ReportEventArgs> Callback, object State)
        {
            string Domain = this.GetDomain(TokenId);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<profilingReport xmlns='");
            Xml.Append(NamespaceStateMachine);
            Xml.Append("' tokenId='");
            Xml.Append(XML.Encode(TokenId));
            Xml.Append("' format='");
            Xml.Append(Format.ToString());
            Xml.Append("'/>");
 
            return this.client.SendIqGet(Domain, Xml.ToString(), (Sender, e) => this.ReportResponse(e, Callback), State);
        }
 
        public async Task<ReportEventArgs> GenerateProfilingReportAsync(string TokenId, ReportFormat Format)
        {
            TaskCompletionSource<ReportEventArgs> Result = new TaskCompletionSource<ReportEventArgs>();
 
            await this.GenerateProfilingReport(TokenId, Format, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get the profiling report of the state-machine."));
 
                return Task.CompletedTask;
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region GeneratePresentReport
 
        public Task GeneratePresentReport(string TokenId, ReportFormat Format,
            EventHandlerAsync<ReportEventArgs> Callback, object State)
        {
            string Domain = this.GetDomain(TokenId);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<presentReport xmlns='");
            Xml.Append(NamespaceStateMachine);
            Xml.Append("' tokenId='");
            Xml.Append(XML.Encode(TokenId));
            Xml.Append("' format='");
            Xml.Append(Format.ToString());
            Xml.Append("'/>");
 
            return this.client.SendIqGet(Domain, Xml.ToString(), (Sender, e) => this.ReportResponse(e, Callback), State);
        }
 
        public async Task<ReportEventArgs> GeneratePresentReportAsync(string TokenId, ReportFormat Format)
        {
            TaskCompletionSource<ReportEventArgs> Result = new TaskCompletionSource<ReportEventArgs>();
 
            await this.GeneratePresentReport(TokenId, Format, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get the profiling report of the state-machine."));
 
                return Task.CompletedTask;
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region GenerateHistoryReport
 
        public Task GenerateHistoryReport(string TokenId, ReportFormat Format,
            EventHandlerAsync<ReportEventArgs> Callback, object State)
        {
            string Domain = this.GetDomain(TokenId);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<historyReport xmlns='");
            Xml.Append(NamespaceStateMachine);
            Xml.Append("' tokenId='");
            Xml.Append(XML.Encode(TokenId));
            Xml.Append("' format='");
            Xml.Append(Format.ToString());
            Xml.Append("'/>");
 
            return this.client.SendIqGet(Domain, Xml.ToString(), (Sender, e) => this.ReportResponse(e, Callback), State);
        }
 
        public async Task<ReportEventArgs> GenerateHistoryReportAsync(string TokenId, ReportFormat Format)
        {
            TaskCompletionSource<ReportEventArgs> Result = new TaskCompletionSource<ReportEventArgs>();
 
            await this.GenerateHistoryReport(TokenId, Format, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get the profiling report of the state-machine."));
 
                return Task.CompletedTask;
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region GenerateStateDiagram
 
        public Task GenerateStateDiagram(string TokenId, ReportFormat Format,
            EventHandlerAsync<ReportEventArgs> Callback, object State)
        {
            string Domain = this.GetDomain(TokenId);
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<stateDiagram xmlns='");
            Xml.Append(NamespaceStateMachine);
            Xml.Append("' tokenId='");
            Xml.Append(XML.Encode(TokenId));
            Xml.Append("' format='");
            Xml.Append(Format.ToString());
            Xml.Append("'/>");
 
            return this.client.SendIqGet(Domain, Xml.ToString(), (Sender, e) => this.ReportResponse(e, Callback), State);
        }
 
        public async Task<ReportEventArgs> GenerateStateDiagramAsync(string TokenId, ReportFormat Format)
        {
            TaskCompletionSource<ReportEventArgs> Result = new TaskCompletionSource<ReportEventArgs>();
 
            await this.GenerateStateDiagram(TokenId, Format, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get the state diagram of the state-machine."));
 
                return Task.CompletedTask;
            }, null);
 
            return await Result.Task;
        }
 
        #endregion
 
        #region StateUpdated
 
        private Task StateUpdatedHandler(object Sender, MessageEventArgs e)
        {
            string TokenId = XML.Attribute(e.Content, "tokenId");
            string MachineId = XML.Attribute(e.Content, "machineId");
            string NewState = XML.Attribute(e.Content, "state");
 
            return this.StateUpdated.Raise(this, new NewStateEventArgs(TokenId, MachineId, NewState, e));
        }
 
        public event EventHandlerAsync<NewStateEventArgs> StateUpdated;
 
        #endregion
 
        #region VariablesUpdated
 
        private async Task VariablesUpdatedHandler(object Sender, MessageEventArgs e)
        {
            string TokenId = XML.Attribute(e.Content, "tokenId");
            string MachineId = XML.Attribute(e.Content, "machineId");
            Variables Variables = await ParseVariables(e.Content);
 
            await this.VariablesUpdated.Raise(this, new VariablesUpdatedEventArgs(TokenId, MachineId, Variables, e));
        }
 
        public event EventHandlerAsync<VariablesUpdatedEventArgs> VariablesUpdated;
 
        #endregion
 
        #endregion
    }
}