inabox/inabox.scripting/ScriptDocument.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using InABox.Core;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Scripting;
using Microsoft.CodeAnalysis.CSharp.Scripting.Hosting;
using Microsoft.CodeAnalysis.Scripting;
using Microsoft.CodeAnalysis.Scripting.Hosting;
using RoslynPad.Roslyn;

namespace InABox.Scripting;

public class ScriptProperty : Dictionary<string, object>
{
    public ScriptProperty(string name, object? value)
    {
        Name = name;
        Value = value;
    }

    public string Name { get; set; }
    public object? Value { get; set; }
}

public class CompileException : Exception
{
    public CompileException() : base("Unable to compile script!") { }
}

public class ScriptDocument : INotifyPropertyChanged
{
    private string _result;

    private string _text = "";
    private bool? compiled;
    private object? obj;

    private Type? type;

    static ScriptDocument()
    {
        DefaultAssemblies = new FluentList<Assembly>()
            .Add(typeof(object).Assembly)
            .Add(typeof(Regex).Assembly)
            .Add(typeof(List<>).Assembly)
            .Add(typeof(Enumerable).Assembly)
            .Add(typeof(Bitmap).Assembly)
            .Add(typeof(Expression).Assembly)
            .Add(typeof(DataTable).Assembly);
    }


    public ScriptDocument(string text)
    {
        if (Host == null)
            Initialize();
        Text = text;
        Properties = new List<ScriptProperty>();
    }

    private static Task<RoslynHost>? _hostTask;
    private static RoslynHost? _host;
    public static RoslynHost Host => _host ?? InitializeHost().Result;

    public static FluentList<Assembly> DefaultAssemblies { get; }

    public Script<object> Script { get; private set; }

    public string Text
    {
        get => _text;
        set => SetProperty(ref _text, value);
    }

    public DocumentId Id { get; set; }

    public string Result
    {
        get => _result;
        private set => SetProperty(ref _result, value);
    }

    public List<Diagnostic> Diagnostics { get; } = new();

    private static MethodInfo HasSubmissionResult { get; } =
        typeof(Compilation).GetMethod(nameof(HasSubmissionResult), BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
            ?? throw new NullReferenceException();

    private static PrintOptions PrintOptions { get; } = new() { MemberDisplayFormat = MemberDisplayFormat.SeparateLines };

    public List<ScriptProperty> Properties { get; }

    public event PropertyChangedEventHandler? PropertyChanged;

    private static IEnumerable<MetadataReference> CompilationReferences;

    private static Task<RoslynHost> InitializeHost()
    {
        _hostTask ??= Task.Run(() =>
        {
            using var profiler = new Profiler(true, "ScriptDocument");
            var assemblies = new HashSet<Assembly>();
            var typelist = CoreUtils.TypeList(
                AppDomain.CurrentDomain.GetAssemblies(),
                x =>
                {
                    if (x.IsClass && !x.IsGenericType && x.IsSubclassOf(typeof(BaseObject)))
                    {
                        var module = x.Assembly.Modules.FirstOrDefault();
                        if(module != null && !module.FullyQualifiedName.Equals("<Unknown>"))
                        {
                            assemblies.Add(x.Assembly);
                            return true;
                        }
                    }
                    return false;
                });
            DefaultAssemblies.AddRange(assemblies);

            var references = Directory.GetFiles(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "refs"), "*.dll")
                .Select(x => MetadataReference.CreateFromFile(x)).ToArray();

            var files = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, "*.dll").Where(
                x => !Path.GetFileName(x).ToLower().StartsWith("gsdll")
                     && !Path.GetFileName(x).ToLower().StartsWith("pdfium")
                     && !Path.GetFileName(x).ToLower().StartsWith("ikvm-native")
                     && !Path.GetFileName(x).ToLower().StartsWith("sqlite.interop")
                     && !Path.GetFileName(x).ToLower().StartsWith("microsoft.codeanalysis")
            );

            var hostReferences = RoslynHostReferences.NamespaceDefault.With(
                typeNamespaceImports: typelist
                //, assemblyReferences: DefaultAssemblies
                , assemblyPathReferences: files,
                references: references
            );
            CompilationReferences = RoslynHostReferences.NamespaceDefault.With(
                typeNamespaceImports: typelist
                , assemblyReferences: DefaultAssemblies
                , assemblyPathReferences: files
            ).GetReferences();

            _host = new RoslynHost(
                DefaultAssemblies.ToArray(),
                hostReferences
            );
            return _host;
        });
        return _hostTask;
    }

    public static void Initialize()
    {
        if(_hostTask is null)
        {
            InitializeHost();
        }
    }

    public class Diagnostic(DiagnosticSeverity severity, string contents)
    {
        public DiagnosticSeverity Severity { get; } = severity;

        public string Contents { get; } = contents;
    }
    
    static ScriptOptions AddTrustedPlatformAssemblies(ScriptOptions options)
    {
        var tpa = (string?)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES");
        if (string.IsNullOrWhiteSpace(tpa))
            return options;

        var paths = tpa.Split(Path.PathSeparator);

        return options.AddReferences(paths.Select(p => MetadataReference.CreateFromFile(p)));
    }

    public bool Compile()
    {
        Result = null;
        compiled = null;

        var options = AddTrustedPlatformAssemblies(ScriptOptions.Default);
        Script = CSharpScript.Create(Text, options
            .AddReferences(CompilationReferences)
            .AddImports(Host.DefaultImports)
            .AddImports(
                "System",
                "System.Net",
                "System.Net.Http",
                "System.Net.Http.Headers",
                "System.Globalization"
            )
        );

        var compilation = Script.GetCompilation();
        var hasResult = (bool)HasSubmissionResult.Invoke(compilation, null);
        var diagnostics = Script.Compile();
        Diagnostics.Clear();
        foreach(var diagnostic in diagnostics)
        {
            var formatted = FormatObject(diagnostic);
            if (!formatted.StartsWith("CSDiagnostic(")) continue;

            var content = formatted.Split(new[] { Environment.NewLine }, StringSplitOptions.None).First().Replace("CSDiagnostic(", "").Replace(") {", "");
            Diagnostics.Add(new(diagnostic.Severity, content));
        }

        if (Diagnostics.Any(x => x.Severity == DiagnosticSeverity.Error))
        {
            var result = new List<string>();
            foreach (var diagnostic in Diagnostics)
                result.Add(diagnostic.Contents);
            Result = string.Join(Environment.NewLine, result);
            return false;
        }

        return true;
    }

    public void SetValue(string name, object? value)
    {
        var prop = Properties.FirstOrDefault(x => x.Name.Equals(name));
        if (prop == null)
            Properties.Add(new ScriptProperty(name, value));
        else
            prop.Value = value;
    }

    public object? GetValue(string name, object? defaultvalue = null)
    {
        var prop = Properties.FirstOrDefault(x => x.Name.Equals(name));
        return prop != null ? prop.Value : defaultvalue;
    }

    public Type? GetClassType(string className = "Module")
    {
        if (!compiled.HasValue)
        {
            compiled = false;
            var stream = new MemoryStream();
            var emitResult = Script.GetCompilation().Emit(stream);
            if (emitResult.Success)
            {
                var asm = Assembly.Load(stream.ToArray());
                type = asm.GetTypes().Where(x => x.Name.Equals(className)).FirstOrDefault();
                if (type != null)
                {
                    obj = Activator.CreateInstance(type);
                    compiled = true;
                }
            }
        }
        return type;
    }

    public object? GetObject(string className = "Module")
    {
        GetClassType(className);
        return obj;
    }

    public MethodInfo? GetMethod(string className = "Module", string methodName = "Execute")
    {
        var type = GetClassType(className);
        if (compiled == true && type != null)
        {
            return type.GetMethod(methodName);
        }
        else
        {
            return null;
        }
    }

    public bool Execute(string classname = "Module", string methodname = "Execute", object?[]? parameters = null, bool defaultResult = false)
    {
        var result = defaultResult;

        var type = GetClassType(classname);
        var obj = GetObject(classname);
        var method = GetMethod(classname, methodname);

        if (compiled == true && type != null && method != null)
        {
            foreach (var property in Properties)
            {
                var prop = type.GetProperty(property.Name);
                prop?.SetValue(obj, property.Value);
            }

            if (method.ReturnType == typeof(bool))
            {
                result = (bool)(method.Invoke(obj, parameters ?? []) ?? false);
            }
            else
            {
                method.Invoke(obj, parameters ?? []);
                result = true;
            }

            if (result)
            {
                foreach (var property in Properties)
                {
                    var prop = type.GetProperty(property.Name);
                    if (prop != null)
                        property.Value = prop.GetValue(obj);
                }
            }
        }

        return result;
    }

    private static string FormatException(Exception ex)
    {
        return CSharpObjectFormatter.Instance.FormatException(ex);
    }

    private static string FormatObject(object o)
    {
        return CSharpObjectFormatter.Instance.FormatObject(o, PrintOptions);
    }

    protected bool SetProperty<T>(ref T field, T value, [CallerMemberName] string? propertyName = null)
    {
        if (!EqualityComparer<T>.Default.Equals(field, value))
        {
            field = value;
            // ReSharper disable once ExplicitCallerInfoArgument
            OnPropertyChanged(propertyName);
            return true;
        }

        return false;
    }

    protected virtual void OnPropertyChanged([CallerMemberName] string? propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    public static bool RunCustomModule(DataModel model, Dictionary<string, object[]> selected, string code)
    {
        var script = new ScriptDocument(code);
        if (!script.Compile())
        {
            throw new CompileException();
        }

        script.SetValue("Data", selected);
        script.SetValue("Model", model);

        script.Execute(methodname: "BeforeLoad");
        var tableNames = model.DefaultTableNames.ToList();
        script.Execute(methodname: "CheckTables", parameters: new[] { tableNames });

        model.LoadModel(tableNames);

        return script.Execute();
    }
}