InitScriptFile.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Threading.Tasks;
using Waher.Runtime.Inventory;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Content.Markdown.Functions
{
    public class InitScriptFile : FunctionOneScalarStringVariable
    {
        private static readonly Dictionary<string, DateTime> lastExecuted = new Dictionary<string, DateTime>();
 
        public InitScriptFile(ScriptNode Argument, int Start, int Length, Expression Expression)
            : base(Argument, Start, Length, Expression)
        {
        }
 
        public override string FunctionName => nameof(InitScriptFile);
 
        public override string[] DefaultArgumentNames => new string[] { "FileName" };
 
        public override bool IsAsynchronous => true;
 
        public override IElement EvaluateScalar(string Argument, Variables Variables)
        {
            return this.EvaluateScalarAsync(Argument, Variables).Result;
        }
 
        public override async Task<IElement> EvaluateScalarAsync(string Argument, Variables Variables)
        {
            string Source = this.Expression.Source;
            if (string.IsNullOrEmpty(Source))
                throw new ScriptRuntimeException("Script has no source.", this);
 
            Source = Path.Combine(Source, Argument);
 
            if (await NeedsExecution(Source))
            {
                string Script = await Resources.ReadAllTextAsync(Source);
                Expression Exp = new Expression(Script, Source);
 
                return await Exp.Root.EvaluateAsync(Variables);
            }
            else
                return ObjectValue.Null;
        }
 
        public static async Task<bool> NeedsExecution(string FileName)
        {
            DateTime Timestamp = File.GetLastWriteTime(FileName);
            DateTime? LastExecuted;
            Type RuntimeSettings = null;
            MethodInfo GetAsync;
            MethodInfo SetAsync;
 
            lock (lastExecuted)
            {
                if (lastExecuted.TryGetValue(FileName, out DateTime TP))
                    LastExecuted = TP;
                else
                    LastExecuted = null;
            }
 
            if (LastExecuted.HasValue && LastExecuted.Value >= Timestamp)
                return false;
 
            if (!LastExecuted.HasValue &&
                !((RuntimeSettings = Types.GetType("Waher.Runtime.Settings.RuntimeSettings")) is null) &&
                !((GetAsync = RuntimeSettings.GetRuntimeMethod("GetAsync", new Type[] { typeof(string), typeof(DateTime) })) is null) &&
                GetAsync.ReturnType == typeof(Task<DateTime>))
            {
                LastExecuted = await (Task<DateTime>)GetAsync.Invoke(null, new object[] { FileName, DateTime.MinValue });
 
                if (LastExecuted.HasValue && LastExecuted.Value >= Timestamp)
                {
                    lock (lastExecuted)
                    {
                        lastExecuted[FileName] = LastExecuted.Value;
                    }
 
                    return false;
                }
            }
 
            lock (lastExecuted)
            {
                lastExecuted[FileName] = Timestamp;
            }
 
            if (RuntimeSettings is null)
                RuntimeSettings = Types.GetType("Waher.Runtime.Settings.RuntimeSettings");
 
            if (!(RuntimeSettings is null) &&
                !((SetAsync = RuntimeSettings.GetRuntimeMethod("SetAsync", new Type[] { typeof(string), typeof(DateTime) })) is null) &&
                SetAsync.ReturnType == typeof(Task<bool>))
            {
                Task<bool> Result = (Task<bool>)SetAsync.Invoke(null, new object[] { FileName, Timestamp });
                await Result;
            }
 
            return true;
        }
    }
}