// 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.
 
#nullable disable
 
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using Roslyn.Test.Utilities;
using Xunit;
 
namespace Microsoft.CodeAnalysis.Editor.UnitTests.Semantics;
 
public abstract class SpeculationAnalyzerTestsBase : TestBase
{
    protected const string CompilationName = "SemanticModelTestCompilation";
 
    protected readonly Regex UnderTestRegex = new Regex(@"\[\|(?<content>.*?)\|\]");
 
    protected readonly MetadataReference[] References =
    [
        MscorlibRef,
        SystemRef,
        SystemCoreRef,
        MsvbRef
    ];
 
    protected void Test(string code, string replacementExpression, bool semanticChanges, string expressionToAnalyze = null, bool isBrokenCode = false)
    {
        var initialMatch = UnderTestRegex.Match(code);
        Assert.True(initialMatch.Success);
        var initialExpression = initialMatch.Groups["content"].Value;
 
        var initialTree = Parse(UnderTestRegex.Replace(code, m => m.Groups["content"].Value));
        var initialNode = initialTree.GetRoot().DescendantNodes().First(n => IsExpressionNode(n) && n.ToString() == (expressionToAnalyze ?? initialExpression));
 
        var replacementTree = Parse(UnderTestRegex.Replace(code, replacementExpression));
        var replacementNode = replacementTree.GetRoot().DescendantNodes().First(n => IsExpressionNode(n) && n.ToString() == (expressionToAnalyze ?? replacementExpression));
 
        var initialCompilation = CreateCompilation(initialTree);
        var initialModel = initialCompilation.GetSemanticModel(initialTree);
 
        if (!isBrokenCode)
        {
            CheckCompilation(initialCompilation);
            CheckCompilation(CreateCompilation(replacementTree));
        }
 
        Assert.Equal(semanticChanges, ReplacementChangesSemantics(initialNode, replacementNode, initialModel));
    }
 
    private void CheckCompilation(Compilation compilation)
    {
        using var temporaryStream = new MemoryStream();
        Assert.True(CompilationSucceeded(compilation, temporaryStream));
    }
 
    protected abstract SyntaxTree Parse(string text);
 
    protected abstract bool IsExpressionNode(SyntaxNode node);
 
    protected abstract Compilation CreateCompilation(SyntaxTree tree);
 
    protected abstract bool CompilationSucceeded(Compilation compilation, Stream temporaryStream);
 
    protected abstract bool ReplacementChangesSemantics(SyntaxNode initialNode, SyntaxNode replacementNode, SemanticModel initialModel);
}