ScriptConsolidator.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content.Markdown;
using Waher.Content.Markdown.Consolidation;
using Waher.Events;
using Waher.Networking.HTTP;
using Waher.Persistence.Serialization;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Objects;
using Waher.Script.Operators.Vectors;
 
namespace Waher.Service.IoTBroker.Admin.Muc
{
    public class ScriptConsolidator : IConsolidator
    {
        private readonly SortedDictionary<string, IElement> content = new SortedDictionary<string, IElement>();
        private readonly Variables variables = HttpServer.CreateSessionVariables();
        private readonly string threadId;
        private readonly int expectedSources;
        private object tag = null;
 
        public ScriptConsolidator(string ThreadId, int ExpectedSources)
        {
            this.threadId = ThreadId;
            this.expectedSources = ExpectedSources;
        }
 
        public string ThreadId
        {
            get => this.threadId;
        }
 
        public int ExpectedSources
        {
            get => this.expectedSources;
        }
 
        public object Tag
        {
            get => this.tag;
            set => this.tag = value;
        }
 
        public Task<string[]> GetSources()
        {
            lock (this.content)
            {
                string[] Result = new string[this.content.Count];
                this.content.Keys.CopyTo(Result, 0);
                return Task.FromResult<string[]>(Result);
            }
        }
        public Task<int> GetNrReportedSources()
        {
            lock (this.content)
            {
                return Task.FromResult<int>(this.content.Count);
            }
        }
 
        public async Task<bool> Add(string Source, MarkdownDocument Markdown)
        {
            return await this.Add(Source, await Markdown.GenerateMarkdown(false));
        }
 
        public async Task<bool> Add(string Source, MarkdownDocument Markdown, string Id)
        {
            return await this.Add(Source, await Markdown.GenerateMarkdown(false), Id);
        }
 
        public Task<bool> Add(string Source, string Text)
        {
            return this.Add(Source, Text, string.Empty);
        }
 
        public Task<bool> Add(string Source, string Text, string Id)
        {
            return this.Add(Source, Text, Id, false);
        }
 
        public async Task<bool> Update(string Source, MarkdownDocument Markdown, string Id)
        {
            return await this.Update(Source, await Markdown.GenerateMarkdown(false), Id);
        }
 
        public Task<bool> Update(string Source, string Text, string Id)
        {
            return this.Add(Source, Text, Id, true);
        }
 
        private async Task<bool> Add(string Source, string Text, string _, bool Update)
        {
            IElement Content;
            bool Result;
 
            try
            {
                Expression Exp = new Expression(Text);
                if (!(Exp.Root is null))
                    Content = await Exp.Root.EvaluateAsync(this.variables);
                else
                    Content = ObjectValue.Null;
            }
            catch (ScriptReturnValueException ex)
            {
                Content = ex.ReturnValue;
                //ScriptReturnValueException.Reuse(ex);
            }
            catch (ScriptBreakLoopException ex)
            {
                Content = ex.LoopValue ?? ObjectValue.Null;
                //ScriptBreakLoopException.Reuse(ex);
            }
            catch (ScriptContinueLoopException ex)
            {
                Content = ex.LoopValue ?? ObjectValue.Null;
                //ScriptContinueLoopException.Reuse(ex);
            }
            catch (Exception ex)
            {
                Content = new ObjectValue(ex);
            }
 
            LinkedList<IDisposableAsync> ToDispose = null;
 
            lock (this.content)
            {
                if (this.content.ContainsKey(Source))
                {
                    if (Update)
                        this.content[Source] = Content;
                    else if (Content is IDisposableAsync DisposableAsync)
                    {
                        ToDispose ??= new LinkedList<IDisposableAsync>();
                        ToDispose.AddLast(DisposableAsync);
                    }
                    else if (Content is IDisposable Disposable)
                        Disposable.Dispose();
 
                    Result = false;
                }
                else
                {
                    this.content[Source] = Content;
                    Result = true;
                }
            }
 
            if (!(ToDispose is null))
            {
                foreach (IDisposableAsync DisposableAsync in ToDispose)
                    await DisposableAsync.DisposeAsync();
            }
 
            EventHandlerAsync<SourceEventArgs> h = Update ? this.Updated : this.Added;
            await h.Raise(this, new SourceEventArgs(Source));
 
            return Result;
        }
 
        [Obsolete("Use DisposeAsync() instead.")]
        public void Dispose()
        {
            try
            {
                this.DisposeAsync().Wait();
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public Task DisposeAsync()
        { 
            return this.Disposed.Raise(this, EventArgs.Empty, false);
        }
 
        public event EventHandlerAsync<SourceEventArgs> Added = null;
 
        public event EventHandlerAsync<SourceEventArgs> Updated = null;
 
        public event EventHandlerAsync Disposed = null;
 
        public IVector GetResult()
        {
            LinkedList<IElement> Elements = new LinkedList<IElement>();
 
            lock (this.content)
            {
                foreach (KeyValuePair<string, IElement> P in this.content)
                {
                    if (P.Value is IVector Vector)
                    {
                        foreach (IElement E in Vector.ChildElements)
                            Elements.AddLast(this.Append(E, P.Key));
                    }
                    else
                        Elements.AddLast(this.Append(P.Value, P.Key));
                }
            }
 
            return VectorDefinition.Encapsulate(Elements, false, null);
        }
 
        private IElement Append(IElement Element, string Source)
        {
            object Obj = Element.AssociatedObjectValue;
 
            if (Obj is GenericObject GenObj)
            {
                GenObj["Source"] = Source;
                return Element;
            }
            else if (Obj is IDictionary<string, IElement> ObjExNihilo)
            {
                ObjExNihilo["Source"] = new StringValue(Source);
                return Element;
            }
            else
                return Element;
        }
 
    }
}