using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Emit;

namespace Ariadne.Generator.UnitTests
{
    /// <summary>
    /// Compiles scripts in memory the way a build does: through ArcScriptGenerator, then StepLabelSuppressor.
    /// </summary>
    public class GeneratorRun
    {
        /// <summary>
        /// This field holds the usings put ahead of every script file.
        /// </summary>
        public const string Usings = "using System.Collections.Generic;\nusing System.Linq;\nusing Ariadne;\n\n";

        /// <summary>
        /// This field holds the context type every test script runs against.
        /// </summary>
        public const string World =
            "public class World\n{\n    public readonly System.Collections.Generic.HashSet<string> Open = " +
            "new System.Collections.Generic.HashSet<string>();\n}\n";

        public static readonly CSharpParseOptions ParseOptions = new CSharpParseOptions(LanguageVersion.CSharp13);

        public static readonly MetadataReference[] References =
        {
            MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
            MetadataReference.CreateFromFile(typeof(Uri).Assembly.Location),
            MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location),
            MetadataReference.CreateFromFile(
                Path.Combine(RuntimeEnvironment.GetRuntimeDirectory(), "netstandard.dll")),
            MetadataReference.CreateFromFile(typeof(Arc<>).Assembly.Location),
            MetadataReference.CreateFromFile(typeof(Amphora.Duration).Assembly.Location),
        };

        /// <summary>
        /// This field holds the generator's own diagnostics, each as "Id:the text it points at".
        /// </summary>
        public readonly List<string> Reported;

        /// <summary>
        /// Holds the same diagnostics as Reported, each as "Id:the message".
        /// </summary>
        public readonly List<string> Messages;

        /// <summary>
        /// This field holds the compiler's errors and unsuppressed warnings with the generated code included, each as
        /// "Id:the text it points at".
        /// </summary>
        public readonly List<string> Compiled;

        /// <summary>
        /// This field holds the same diagnostics as Compiled, each as "Id:File(line,column)" where #line maps it.
        /// </summary>
        public readonly List<string> CompiledAt;

        /// <summary>
        /// This field holds each generated code-behind's text, by file name.
        /// </summary>
        public readonly Dictionary<string, string> CodeBehinds;

        private GeneratorRun(List<string> reported, List<string> messages, List<string> compiled,
            List<string> compiledAt, Dictionary<string, string> codeBehinds)
        {
            Reported = reported;
            Messages = messages;
            Compiled = compiled;
            CompiledAt = compiledAt;
            CodeBehinds = codeBehinds;
        }

        /// <summary>
        /// Gets the only code-behind, or "" if nothing was generated.
        /// </summary>
        public string CodeBehind
        {
            get
            {
                return CodeBehinds.Values.SingleOrDefault() ?? "";
            }
        }

        public static string Describe(Diagnostic diagnostic)
        {
            Location location = diagnostic.Location;
            if (location.SourceTree == null)
            {
                return diagnostic.Id;
            }

            return diagnostic.Id + ":" + location.SourceTree.GetText().ToString(location.SourceSpan);
        }

        public static string DescribeWhere(Diagnostic diagnostic)
        {
            FileLinePositionSpan span = diagnostic.Location.GetMappedLineSpan();
            return diagnostic.Id + ":" + Path.GetFileName(span.Path) + "(" + (span.StartLinePosition.Line + 1) + "," +
                (span.StartLinePosition.Character + 1) + ")";
        }

        private static List<string> Sorted(IEnumerable<Diagnostic> diagnostics, Func<Diagnostic, string> describe)
        {
            return diagnostics
                .OrderBy(diagnostic => diagnostic.Location.SourceTree?.FilePath, StringComparer.Ordinal)
                .ThenBy(diagnostic => diagnostic.Location.SourceSpan.Start)
                .ThenBy(diagnostic => diagnostic.Id, StringComparer.Ordinal)
                .Select(describe).ToList();
        }

        /// <summary>
        /// Compiles the World context type plus <paramref name="files"/>, each a path and a script with Usings put
        /// ahead of it.
        /// </summary>
        public static CSharpCompilation Compile(MetadataReference[] libraries,
            params (string Path, string Script)[] files)
        {
            var trees = new List<SyntaxTree> { CSharpSyntaxTree.ParseText(World, ParseOptions, "World.cs") };
            foreach ((string path, string script) in files)
            {
                trees.Add(CSharpSyntaxTree.ParseText(Usings + script, ParseOptions, path));
            }

            return CSharpCompilation.Create("Scripts", trees, References.Concat(libraries),
                new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
        }

        public static CSharpCompilation Compile(params (string Path, string Script)[] files)
        {
            return Compile(new MetadataReference[0], files);
        }

        /// <summary>
        /// Compiles <paramref name="source"/>, with Usings ahead of it, into an assembly a script can reference, eg:
        /// a game's base class for its scripts.
        /// </summary>
        /// <exception cref="InvalidOperationException">The source doesn't compile.</exception>
        public static MetadataReference CompileLibrary(string name, string source)
        {
            CSharpCompilation library = CSharpCompilation.Create(name,
                new[] { CSharpSyntaxTree.ParseText(Usings + source, ParseOptions) },
                References,
                new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
            using (var image = new MemoryStream())
            {
                EmitResult result = library.Emit(image);
                if (!result.Success)
                {
                    throw new InvalidOperationException(string.Join("\n", result.Diagnostics));
                }

                return MetadataReference.CreateFromImage(image.ToArray());
            }
        }

        /// <summary>
        /// Compiles <paramref name="source"/> as <see cref="CompileLibrary"/> does, but through ArcScriptGenerator
        /// first, so the assembly holds the passages and frames a project that uses the generator would build.
        /// </summary>
        /// <exception cref="InvalidOperationException">The source or its generated code doesn't compile.</exception>
        public static MetadataReference CompileGeneratedLibrary(string name, string source)
        {
            GeneratorDriver driver = CSharpGeneratorDriver.Create(
                new[] { new ArcScriptGenerator().AsSourceGenerator() }, parseOptions: ParseOptions,
                optionsProvider: new ProjectOptions(null));
            CSharpCompilation library = CSharpCompilation.Create(name,
                new[] { CSharpSyntaxTree.ParseText(Usings + source, ParseOptions, name + ".cs") },
                References,
                new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
            Compilation generated;
            ImmutableArray<Diagnostic> reported;
            driver.RunGeneratorsAndUpdateCompilation(library, out generated, out reported);
            using (var image = new MemoryStream())
            {
                EmitResult result = generated.Emit(image);
                if (!result.Success || reported.Any(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error))
                {
                    throw new InvalidOperationException(string.Join("\n", reported.Concat(result.Diagnostics)));
                }

                return MetadataReference.CreateFromImage(image.ToArray());
            }
        }

        /// <summary>
        /// Holds the build properties a build passes the compiler, which here is only where the project is.
        /// </summary>
        public class ProjectOptions : AnalyzerConfigOptionsProvider
        {
            private class Options : AnalyzerConfigOptions
            {
                private readonly string projectDirectory;

                public Options(string projectDirectory)
                {
                    this.projectDirectory = projectDirectory;
                }

                public override bool TryGetValue(string key, out string value)
                {
                    value = null;
                    if (key == ArcScriptGenerator.ProjectDirectoryOption && projectDirectory != null)
                    {
                        value = projectDirectory;
                    }

                    return value != null;
                }
            }

            private readonly AnalyzerConfigOptions options;

            public ProjectOptions(string projectDirectory)
            {
                options = new Options(projectDirectory);
            }

            public override AnalyzerConfigOptions GlobalOptions
            {
                get
                {
                    return options;
                }
            }

            public override AnalyzerConfigOptions GetOptions(SyntaxTree tree)
            {
                return options;
            }

            public override AnalyzerConfigOptions GetOptions(AdditionalText textFile)
            {
                return options;
            }
        }

        /// <summary>
        /// Compiles <paramref name="files"/> in a project at <paramref name="projectDirectory"/>, which is null for a
        /// build that doesn't say.
        /// </summary>
        public static GeneratorRun OfProject(string projectDirectory, params (string Path, string Script)[] files)
        {
            return Of(null, new MetadataReference[0], projectDirectory, files);
        }

        /// <param name="analyzer">Another analyzer to run alongside, eg: a save library's, or null for none.</param>
        public static GeneratorRun Of(DiagnosticAnalyzer analyzer, MetadataReference[] libraries,
            params (string Path, string Script)[] files)
        {
            return Of(analyzer, libraries, null, files);
        }

        private static GeneratorRun Of(DiagnosticAnalyzer analyzer, MetadataReference[] libraries,
            string projectDirectory, (string Path, string Script)[] files)
        {
            GeneratorDriver driver = CSharpGeneratorDriver.Create(
                new[] { new ArcScriptGenerator().AsSourceGenerator() }, parseOptions: ParseOptions,
                optionsProvider: new ProjectOptions(projectDirectory));
            Compilation generated;
            ImmutableArray<Diagnostic> reported;
            driver = driver.RunGeneratorsAndUpdateCompilation(Compile(libraries, files), out generated,
                out reported);

            var analyzers = new List<DiagnosticAnalyzer> { new StepLabelSuppressor() };
            if (analyzer != null)
            {
                analyzers.Add(analyzer);
            }

            List<Diagnostic> compiled = generated
                .WithAnalyzers(analyzers.ToImmutableArray())
                .GetAllDiagnosticsAsync().Result
                .Where(diagnostic => diagnostic.Severity >= DiagnosticSeverity.Warning && !diagnostic.IsSuppressed)
                .ToList();

            var codeBehinds = new Dictionary<string, string>(StringComparer.Ordinal);
            foreach (GeneratedSourceResult source in driver.GetRunResult().Results.Single().GeneratedSources)
            {
                codeBehinds.Add(source.HintName, source.SourceText.ToString());
            }

            return new GeneratorRun(Sorted(reported, Describe),
                Sorted(reported, diagnostic => diagnostic.Id + ":" + diagnostic.GetMessage()), Sorted(compiled, Describe),
                Sorted(compiled, DescribeWhere), codeBehinds);
        }

        public static GeneratorRun Of(MetadataReference[] libraries, params (string Path, string Script)[] files)
        {
            return Of(null, libraries, files);
        }

        public static GeneratorRun Of(params (string Path, string Script)[] files)
        {
            return Of(new MetadataReference[0], files);
        }

        public static GeneratorRun Of(string script)
        {
            return Of(("Script.cs", script));
        }

        /// <summary>
        /// Runs <paramref name="script"/> in a compilation that also references <paramref name="library"/>.
        /// </summary>
        public static GeneratorRun Of(MetadataReference library, string script)
        {
            return Of(new[] { library }, ("Script.cs", script));
        }

        public static GeneratorRun Of(DiagnosticAnalyzer analyzer, string script)
        {
            return Of(analyzer, new MetadataReference[0], ("Script.cs", script));
        }
    }
}