using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Threading.Tasks;

using Microsoft.CodeAnalysis.CSharp.Formatting;

using Microsoft.CodeAnalysis.CSharp.Scripting;

using Microsoft.CodeAnalysis.Formatting;

using Microsoft.CodeAnalysis.Scripting;

using Scripty.Core.ProjectTree;

namespace Scripty.Core

{

using System.Collections;

using System.Reflection;

using Output;

using Resolvers;

public class ScriptEngine

{

private readonly string _projectFilePath;

public ScriptEngine(string projectFilePath)

: this(projectFilePath, null, null)

{

}

public ScriptEngine(string projectFilePath, string solutionFilePath, IReadOnlyDictionary<string, string> properties)

{

if (string.IsNullOrEmpty(projectFilePath))

{

throw new ArgumentException("Value cannot be null or empty.", nameof(projectFilePath));

}

if (!Path.IsPathRooted(projectFilePath))

{

throw new ArgumentException("Project path must be absolute", nameof(projectFilePath));

}

// The solution path is optional. If it's provided, the solution will be loaded and

// the project found in the solution. If not, then the project is loaded directly.

if (solutionFilePath != null)

{

if (!Path.IsPathRooted(solutionFilePath))

{

throw new ArgumentException("Solution path must be absolute", nameof(solutionFilePath));

}

}

_projectFilePath = projectFilePath;

ProjectRoot = new ProjectRoot(projectFilePath, solutionFilePath, properties);

}

public ProjectRoot ProjectRoot { get; }

public async Task<ScriptResult> Evaluate(ScriptSource source)

{

var resolver = new InterceptDirectiveResolver();

var assembliesToRef = new List<Assembly>

{

typeof(object).Assembly, //mscorlib

typeof(Microsoft.CodeAnalysis.Project).Assembly, // Microsoft.CodeAnalysis.Workspaces

typeof(Microsoft.Build.Evaluation.Project).Assembly, // Microsoft.Build

typeof(ScriptEngine).Assembly // Scripty.Core

};

var namepspaces = new List<string>

{

"System",

"Scripty.Core",

"Scripty.Core.Output",

"Scripty.Core.ProjectTree"

};

var options = ScriptOptions.Default

.WithFilePath(source.FilePath)

.WithReferences(assembliesToRef)

.WithImports(namepspaces)

.WithSourceResolver(resolver);

using (ScriptContext context = GetContext(source.FilePath))

{

try

{

await CSharpScript.EvaluateAsync(source.Code, options, context);

foreach (var outputFile in context.Output.OutputFiles)

{

(outputFile as OutputFile).Close();

if (outputFile.FormatterEnabled)

{

var document = ProjectRoot.Analysis.AddDocument(outputFile.FilePath, File.ReadAllText(outputFile.FilePath));

var resultDocument = await Formatter.FormatAsync(

document,

outputFile.FormatterOptions.Apply(ProjectRoot.Workspace.Options)

);

var resultContent = await resultDocument.GetTextAsync();

File.WriteAllText(outputFile.FilePath, resultContent.ToString());

}

}

}

catch (CompilationErrorException compilationError)

{

return new ScriptResult(context.Output.OutputFiles,

compilationError.Diagnostics

.Select(x => new ScriptError

{

Message = x.GetMessage(),

Line = x.Location.GetLineSpan().StartLinePosition.Line,

Column = x.Location.GetLineSpan().StartLinePosition.Character

})

.ToList());

}

catch (AggregateException aggregateException)

{

return new ScriptResult(context.Output.OutputFiles,

aggregateException.InnerExceptions

.Select(x => new ScriptError

{

Message = x.ToString()

}).ToList());

}

catch (Exception ex)

{

return new ScriptResult(context.Output.OutputFiles,

new[]

{

new ScriptError

{

Message = ex.ToString()

}

});

}

return new ScriptResult(context.Output.OutputFiles);

}

}

private ScriptContext GetContext(string scriptFilePath)

{

if (scriptFilePath == null)

{

throw new ArgumentNullException(nameof(scriptFilePath));

}

return new ScriptContext(scriptFilePath, _projectFilePath, ProjectRoot);

}

}

}