ControlActuator.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using System.Xml;
using SkiaSharp;
using TAG.Simulator.ObjectModel;
using TAG.Simulator.ObjectModel.Activities;
using TAG.Simulator.ObjectModel.Values;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.Control;
using Waher.Script;
using Waher.Things;
 
namespace TAG.Simulator.XMPP.IoT.Activities
{
    public class ControlActuator : XmppIoTActivityNode, IValueRecipient
    {
        private ThingReference[] nodes;
        private IValue value = null;
        private StringAttribute to;
        private StringAttribute parameter;
        private StringAttribute controller;
 
        public ControlActuator(ISimulationNode Parent, Model Model)
            : base(Parent, Model)
        {
        }
 
        public IValue Value => this.value;
 
        public override string LocalName => nameof(ControlActuator);
 
        public override ISimulationNode Create(ISimulationNode Parent, Model Model)
        {
            return new ControlActuator(Parent, Model);
        }
 
        public override async Task FromXml(XmlElement Definition)
        {
            this.controller = new StringAttribute(XML.Attribute(Definition, "controller"));
            this.to = new StringAttribute(XML.Attribute(Definition, "to"));
            this.parameter = new StringAttribute(XML.Attribute(Definition, "parameter"));
 
            await base.FromXml(Definition);
 
            List<ThingReference> Nodes = new List<ThingReference>();
 
            foreach (ISimulationNode Node in this.Children)
            {
                if (Node is NodeReference NodeRef)
                    Nodes.Add(NodeRef.ThingReference);
            }
 
            this.nodes = Nodes.ToArray();
        }
 
        public void Register(IValue Value)
        {
            if (this.value is null)
                this.value = Value;
            else
                throw new Exception("Value already defined.");
        }
 
        public override async Task<LinkedListNode<IActivityNode>> Execute(Variables Variables)
        {
            string ControllerName = await this.controller.GetValueAsync(Variables);
 
            if (!Variables.TryGetVariable(ControllerName, out Waher.Script.Variable v))
                throw new Exception("Controller not found: " + ControllerName);
 
            object Obj = v.ValueObject;
            if (!(Obj is ControlClient Controller))
                throw new Exception("Not a control client object: " + ControllerName);
 
            string To = await this.to.GetValueAsync(Variables);
            string Parameter = await this.parameter.GetValueAsync(Variables);
            object Value = await this.value.EvaluateAsync(Variables);
 
            if (XmppClient.BareJidRegEx.IsMatch(To))
            {
                RosterItem Item = Controller.Client[To]
                    ?? throw new Exception("No connection in roster with Bare JID: " + To);
 
                if (!Item.HasLastPresence || !Item.LastPresence.IsOnline)
                    throw new Exception("Contact not online: " + To);
 
                To = Item.LastPresenceFullJid;
            }
 
            if (Value is bool b)
                await Controller.Set(To, Parameter, b, this.nodes);
            else if (Value is double d)
                await Controller.Set(To, Parameter, d, this.nodes);
            else if (Value is Enum e)
                await Controller.Set(To, Parameter, e, this.nodes);
            else if (Value is int i)
                await Controller.Set(To, Parameter, i, this.nodes);
            else if (Value is long l)
                await Controller.Set(To, Parameter, l, this.nodes);
            else if (Value is string s)
                await Controller.Set(To, Parameter, s, this.nodes);
            else if (Value is TimeSpan TS)
                await Controller.Set(To, Parameter, TS, this.nodes);
            else if (Value is System.DateTime TP)
                await Controller.Set(To, Parameter, TP, TP.TimeOfDay == TimeSpan.Zero, this.nodes);
            else if (Value is Waher.Content.Duration d2)
                await Controller.Set(To, Parameter, d2, this.nodes);
            else if (Value is ColorReference cl)
                await Controller.Set(To, Parameter, cl, this.nodes);
            else if (Value is SKColor cl2)
                await Controller.Set(To, Parameter, new ColorReference(cl2.Red, cl2.Green, cl2.Red, cl2.Alpha), this.nodes);
            else
                throw new Exception("Unsupported control type: " + Value.GetType().FullName);
 
            return null;
        }
 
        public override void ExportPlantUml(StreamWriter Output, int Indentation, char QuoteChar)
        {
            Indent(Output, Indentation);
            Output.Write(":ControlActuator(");
            Output.Write(this.controller.Value);
            Output.Write(", ");
            Output.Write(this.to.Value);
 
            string s = NewMomentaryValues.Join(GetThingReferences(this.nodes));
            if (!string.IsNullOrEmpty(s))
            {
                Output.Write(", ");
                Output.Write(s);
            }
 
            Output.WriteLine(");");
        }
 
        public static string[] GetThingReferences(ThingReference[] Nodes)
        {
            SortedDictionary<string, bool> Sorted = new SortedDictionary<string, bool>();
 
            foreach (ThingReference Node in Nodes)
                Sorted[NewMomentaryValues.GetReference(Node)] = true;
 
            string[] Result = new string[Sorted.Count];
            Sorted.Keys.CopyTo(Result, 0);
 
            return Result;
        }
 
    }
}