﻿// 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;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CodeRefactorings;
using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings;
using Microsoft.CodeAnalysis.Shared.Utilities;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Test.Utilities;
using Xunit;

namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeActions
{
    public class ApplyChangesOperationTests : AbstractCSharpCodeActionTest
    {
        protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters)
            => new MyCodeRefactoringProvider((Func<Solution, Solution>)parameters.fixProviderData);

        private class MyCodeRefactoringProvider : CodeRefactoringProvider
        {
            private readonly Func<Solution, Solution> _changeSolution;

            public MyCodeRefactoringProvider(Func<Solution, Solution> changeSolution)
            {
                _changeSolution = changeSolution;
            }

            public sealed override Task ComputeRefactoringsAsync(CodeRefactoringContext context)
            {
                var codeAction = new TestCodeAction(_changeSolution(context.Document.Project.Solution));
                context.RegisterRefactoring(codeAction);
                return Task.CompletedTask;
            }

            private sealed class TestCodeAction : CodeAction
            {
                private readonly Solution _changedSolution;

                public TestCodeAction(Solution changedSolution)
                {
                    _changedSolution = changedSolution;
                }

                public override string Title => "Title";

                protected override Task<Solution?> GetChangedSolutionAsync(CancellationToken cancellationToken)
                    => Task.FromResult<Solution?>(_changedSolution);
            }
        }

        [WpfFact, WorkItem("https://devdiv.visualstudio.com/DevDiv/_queries/edit/1419139")]
        public async Task TestMakeTextChangeWithInterveningEditToDifferentFile()
        {
            // This should succeed as the code action is trying to edit a file that is not touched by the actual
            // workspace edit that already went in.
            await TestSuccessfulApplicationAsync(
@"<Workspace>
    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
        <Document FilePath=""Program1.cs"">
class Program1
{
}
        </Document>
        <Document FilePath=""Program2.cs"">
class Program2
{
}
        </Document>
    </Project>
</Workspace>",
                codeActionTransform: solution =>
                {
                    var document1 = solution.Projects.Single().Documents.Single(d => d.FilePath!.Contains("Program1"));
                    return solution.WithDocumentText(document1.Id, SourceText.From("NewProgram1Content"));
                },
                intermediaryTransform: solution =>
                {
                    var document2 = solution.Projects.Single().Documents.Single(d => d.FilePath!.Contains("Program2"));
                    return solution.WithDocumentText(document2.Id, SourceText.From("NewProgram2Content"));
                });
        }

        [WpfFact, WorkItem("https://devdiv.visualstudio.com/DevDiv/_queries/edit/1419139")]
        public async Task TestMakeTextChangeWithInterveningRemovalToDifferentFile()
        {
            // This should succeed as the code action is trying to edit a file that is not touched by the actual
            // workspace edit that already went in.
            await TestSuccessfulApplicationAsync(
@"<Workspace>
    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
        <Document FilePath=""Program1.cs"">
class Program1
{
}
        </Document>
        <Document FilePath=""Program2.cs"">
class Program2
{
}
        </Document>
    </Project>
</Workspace>",
                codeActionTransform: solution =>
                {
                    var document1 = solution.Projects.Single().Documents.Single(d => d.FilePath!.Contains("Program1"));
                    return solution.WithDocumentText(document1.Id, SourceText.From("NewProgram1Content"));
                },
                intermediaryTransform: solution =>
                {
                    var document2 = solution.Projects.Single().Documents.Single(d => d.FilePath!.Contains("Program2"));
                    return solution.RemoveDocument(document2.Id);
                });
        }

        [WpfFact, WorkItem("https://devdiv.visualstudio.com/DevDiv/_queries/edit/1419139")]
        public async Task TestMakeTextChangeWithInterveningEditToSameFile()
        {
            // This should fail as the code action is trying to edit a file that is was already edited by the actual
            // workspace edit that already went in.
            await TestFailureApplicationAsync(
@"<Workspace>
    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
        <Document FilePath=""Program1.cs"">
class Program1
{
}
        </Document>
        <Document FilePath=""Program2.cs"">
class Program2
{
}
        </Document>
    </Project>
</Workspace>",
                codeActionTransform: solution =>
                {
                    var document1 = solution.Projects.Single().Documents.Single(d => d.FilePath!.Contains("Program1"));
                    return solution.WithDocumentText(document1.Id, SourceText.From("NewProgram1Content1"));
                },
                intermediaryTransform: solution =>
                {
                    var document1 = solution.Projects.Single().Documents.Single(d => d.FilePath!.Contains("Program1"));
                    return solution.WithDocumentText(document1.Id, SourceText.From("NewProgram1Content2"));
                });
        }

        [WpfFact, WorkItem("https://devdiv.visualstudio.com/DevDiv/_queries/edit/1419139")]
        public async Task TestMakeTextChangeWithInterveningRemovalOfThatFile()
        {
            // This should fail as the code action is trying to edit a file that is subsequently removed.
            await TestFailureApplicationAsync(
@"<Workspace>
    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
        <Document FilePath=""Program1.cs"">
class Program1
{
}
        </Document>
        <Document FilePath=""Program2.cs"">
class Program2
{
}
        </Document>
    </Project>
</Workspace>",
                codeActionTransform: solution =>
                {
                    var document1 = solution.Projects.Single().Documents.Single(d => d.FilePath!.Contains("Program1"));
                    return solution.WithDocumentText(document1.Id, SourceText.From("NewProgram1Content1"));
                },
                intermediaryTransform: solution =>
                {
                    var document1 = solution.Projects.Single().Documents.Single(d => d.FilePath!.Contains("Program1"));
                    return solution.RemoveDocument(document1.Id);
                });
        }

        [WpfFact, WorkItem("https://devdiv.visualstudio.com/DevDiv/_queries/edit/1419139")]
        public async Task TestMakeProjectChangeWithInterveningTextEdit()
        {
            // This should fail as we don't want to make non-text changes that may have undesirable results to the solution
            // given the intervening edits.
            await TestFailureApplicationAsync(
@"<Workspace>
    <Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
        <Document FilePath=""Program1.cs"">
class Program1
{
}
        </Document>
        <Document FilePath=""Program2.cs"">
class Program2
{
}
        </Document>
    </Project>
</Workspace>",
                codeActionTransform: solution =>
                {
                    var document1 = solution.Projects.Single().Documents.Single(d => d.FilePath!.Contains("Program1"));
                    return solution.RemoveDocument(document1.Id);
                },
                intermediaryTransform: solution =>
                {
                    var document2 = solution.Projects.Single().Documents.Single(d => d.FilePath!.Contains("Program2"));
                    return solution.WithDocumentText(document2.Id, SourceText.From("NewProgram1Content2"));
                });
        }

        private async Task TestSuccessfulApplicationAsync(
            string workspaceXml,
            Func<Solution, Solution> codeActionTransform,
            Func<Solution, Solution> intermediaryTransform)
        {
            await TestApplicationAsync(workspaceXml, codeActionTransform, intermediaryTransform, success: true);
        }

        private async Task TestFailureApplicationAsync(
            string workspaceXml,
            Func<Solution, Solution> codeActionTransform,
            Func<Solution, Solution> intermediaryTransform)
        {
            await TestApplicationAsync(workspaceXml, codeActionTransform, intermediaryTransform, success: false);
        }

        private async Task TestApplicationAsync(
            string workspaceXml,
            Func<Solution, Solution> codeActionTransform,
            Func<Solution, Solution> intermediaryTransform,
            bool success)
        {
            var parameters = new TestParameters(fixProviderData: codeActionTransform);
            using var workspace = CreateWorkspaceFromOptions(workspaceXml, parameters);

            var originalSolution = workspace.CurrentSolution;

            var document = GetDocument(workspace);
            var provider = CreateCodeRefactoringProvider(workspace, parameters);

            var refactorings = new List<CodeAction>();
            var context = new CodeRefactoringContext(document, new TextSpan(), refactorings.Add, CancellationToken.None);

            // Compute refactorings based on the original solution.
            await provider.ComputeRefactoringsAsync(context);
            var action = refactorings.Single();
            var operations = await action.GetOperationsAsync(CancellationToken.None);
            var operation = operations.Single();

            // Now make an intermediary edit to the workspace that is applied back in.
            var changedSolution = intermediaryTransform(originalSolution);
            Assert.True(workspace.TryApplyChanges(changedSolution));

            // Now try to apply the refactoring, even though an intervening edit happened.
            var result = await operation.TryApplyAsync(workspace, originalSolution, new ProgressTracker(), CancellationToken.None);

            Assert.Equal(success, result);
        }
    }
}
