// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Formatting;
using Microsoft.CodeAnalysis.Host;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Test.Utilities;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Xunit;
 
namespace Microsoft.CodeAnalysis.UnitTests.Formatting;
 
[UseExportProvider]
public abstract class FormattingTestBase
{
    private protected Task AssertFormatAsync(
        string expected,
        string code,
        string language,
        OptionsCollection? changedOptionSet = null,
        bool testWithTransformation = true)
    {
        return AssertFormatAsync(expected, code, [new TextSpan(0, code.Length)], language, changedOptionSet, testWithTransformation);
    }
 
    private protected async Task AssertFormatAsync(
        string expected,
        string code,
        IEnumerable<TextSpan> spans,
        string language,
        OptionsCollection? changedOptions = null,
        bool treeCompare = true,
        ParseOptions? parseOptions = null)
    {
        using var workspace = new AdhocWorkspace();
        var project = workspace.CurrentSolution.AddProject("Project", "Project.dll", language);
        if (parseOptions != null)
        {
            project = project.WithParseOptions(parseOptions);
        }
 
        var document = project.AddDocument("Document", SourceText.From(code));
 
        var formattingService = document.GetRequiredLanguageService<ISyntaxFormattingService>();
        var formattingOptions = changedOptions != null
            ? formattingService.GetFormattingOptions(changedOptions)
            : formattingService.DefaultOptions;
 
        var syntaxTree = await document.GetRequiredSyntaxTreeAsync(CancellationToken.None);
        var root = await syntaxTree.GetRootAsync();
        await AssertFormatAsync(workspace.Services.SolutionServices, expected, root, spans.AsImmutable(), formattingOptions, await document.GetTextAsync());
 
        // format with node and transform
        AssertFormatWithTransformation(workspace.Services.SolutionServices, expected, root, spans, formattingOptions, treeCompare, parseOptions);
    }
 
    protected abstract SyntaxNode ParseCompilation(string text, ParseOptions? parseOptions);
 
    internal void AssertFormatWithTransformation(
        SolutionServices services, string expected, SyntaxNode root, IEnumerable<TextSpan> spans, SyntaxFormattingOptions options, bool treeCompare = true, ParseOptions? parseOptions = null)
    {
        var newRootNode = Formatter.Format(root, spans, services, options, rules: default, CancellationToken.None);
 
        Assert.Equal(expected, newRootNode.ToFullString());
 
        // test doesn't use parsing option. add one if needed later
        var newRootNodeFromString = ParseCompilation(expected, parseOptions);
 
        if (treeCompare)
        {
            // simple check to see whether two nodes are equivalent each other.
            Assert.True(newRootNodeFromString.IsEquivalentTo(newRootNode));
        }
    }
 
    private static async Task AssertFormatAsync(SolutionServices services, string expected, SyntaxNode root, ImmutableArray<TextSpan> spans, SyntaxFormattingOptions options, SourceText sourceText)
    {
        // Verify formatting the input code produces the expected result
        var result = Formatter.GetFormattedTextChanges(root, spans, services, options);
        AssertResult(expected, sourceText, result);
 
        // Verify formatting the output code produces itself (formatting is idempotent)
        var resultText = sourceText.WithChanges(result);
        if (TryAdjustSpans(sourceText, result, resultText, spans, out var adjustedSpans))
        {
            var resultRoot = await root.SyntaxTree.WithChangedText(resultText).GetRootAsync();
            var idempotentResult = Formatter.GetFormattedTextChanges(resultRoot, adjustedSpans, services, options);
            AssertResult(expected, resultText, idempotentResult);
        }
    }
 
    private static bool TryAdjustSpans(SourceText inputText, IList<TextChange> changes, SourceText outputText, ImmutableArray<TextSpan> inputSpans, out ImmutableArray<TextSpan> outputSpans)
    {
        if (changes.Count == 0)
        {
            outputSpans = inputSpans;
            return true;
        }
 
        var outputBuilder = ImmutableArray.CreateBuilder<TextSpan>(inputSpans.Length);
        for (var i = 0; i < inputSpans.Length; i++)
        {
            var span = inputSpans[i];
            if (span.Start == 0 && span.End == inputText.Length)
            {
                // The input span is the full document
                outputBuilder.Add(TextSpan.FromBounds(0, outputText.Length));
                continue;
            }
 
            // The input span cannot be automatically adjusted
            outputSpans = default;
            return false;
        }
 
        outputSpans = outputBuilder.MoveToImmutable();
        return true;
    }
 
    protected static void AssertResult(string expected, SourceText sourceText, IList<TextChange> result)
    {
        var actual = sourceText.WithChanges(result).ToString();
        AssertEx.EqualOrDiff(expected, actual);
    }
}