// 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.Threading.Tasks;
using Microsoft.CodeAnalysis.Editor.UnitTests.ChangeSignature;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
 
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ChangeSignature;
 
[Trait(Traits.Feature, Traits.Features.ChangeSignature)]
public partial class ChangeSignatureTests : AbstractChangeSignatureTests
{
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/8333")]
    public async Task TestNotInExpressionBody()
    {
        var markup = """
            class Ext
            {
                void Goo(int a, int b) => [||]0;
            }
            """;
 
        await TestChangeSignatureViaCodeActionAsync(markup, expectedCodeAction: false);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/1905")]
    public async Task TestAfterSemicolonForInvocationInExpressionStatement_ViaCommand()
    {
        var markup = """
            class Program
            {
                static void Main(string[] args)
                {
                    M1(1, 2);$$
                    M2(1, 2, 3);
                }
 
                static void M1(int x, int y) { }
 
                static void M2(int x, int y, int z) { }
            }
            """;
        var expectedCode = """
            class Program
            {
                static void Main(string[] args)
                {
                    M1(2, 1);
                    M2(1, 2, 3);
                }
 
                static void M1(int y, int x) { }
 
                static void M2(int x, int y, int z) { }
            }
            """;
 
        await TestChangeSignatureViaCommandAsync(
            LanguageNames.CSharp,
            markup: markup,
            updatedSignature: [1, 0],
            expectedUpdatedInvocationDocumentCode: expectedCode);
    }
 
    [Fact]
    public async Task TestOnLambdaWithTwoDiscardParameters_ViaCommand()
    {
        var markup = """
            class Program
            {
                static void M()
                {
                    System.Func<int, string, int> f = $$(int _, string _) => 1;
                }
            }
            """;
        var expectedCode = """
            class Program
            {
                static void M()
                {
                    System.Func<int, string, int> f = (string _, int _) => 1;
                }
            }
            """;
 
        await TestChangeSignatureViaCommandAsync(
            LanguageNames.CSharp,
            markup: markup,
            updatedSignature: [1, 0],
            expectedUpdatedInvocationDocumentCode: expectedCode);
    }
 
    [Fact]
    public async Task TestOnAnonymousMethodWithTwoParameters_ViaCommand()
    {
        var markup = """
            class Program
            {
                static void M()
                {
                    System.Func<int, string, int> f = [||]delegate(int x, string y) { return 1; };
                }
            }
            """;
        await TestMissingAsync(markup);
    }
 
    [Fact]
    public async Task TestOnAnonymousMethodWithTwoDiscardParameters_ViaCommand()
    {
        var markup = """
            class Program
            {
                static void M()
                {
                    System.Func<int, string, int> f = [||]delegate(int _, string _) { return 1; };
                }
            }
            """;
        await TestMissingAsync(markup);
    }
 
    [Fact]
    public async Task TestAfterSemicolonForInvocationInExpressionStatement_ViaCodeAction()
    {
        var markup = """
            class Program
            {
                static void Main(string[] args)
                {
                    M1(1, 2);[||]
                    M2(1, 2, 3);
                }
 
                static void M1(int x, int y) { }
 
                static void M2(int x, int y, int z) { }
            }
            """;
 
        await TestMissingAsync(markup);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/17309")]
    public async Task TestNotInLeadingWhitespace()
    {
        var markup = """
            class Ext
            {
                [||]
                void Goo(int a, int b)
                {
                };
            }
            """;
 
        await TestChangeSignatureViaCodeActionAsync(markup, expectedCodeAction: false);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/17309")]
    public async Task TestNotInLeadingTrivia()
    {
        var markup = """
            class Ext
            {
                // [||]
                void Goo(int a, int b)
                {
                };
            }
            """;
 
        await TestChangeSignatureViaCodeActionAsync(markup, expectedCodeAction: false);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/17309")]
    public async Task TestNotInLeadingTrivia2()
    {
        var markup = """
            class Ext
            {
                [||]//
                void Goo(int a, int b)
                {
                };
            }
            """;
 
        await TestChangeSignatureViaCodeActionAsync(markup, expectedCodeAction: false);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/17309")]
    public async Task TestNotInLeadingDocComment()
    {
        var markup = """
            class Ext
            {
                /// [||]
                void Goo(int a, int b)
                {
                };
            }
            """;
 
        await TestChangeSignatureViaCodeActionAsync(markup, expectedCodeAction: false);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/17309")]
    public async Task TestNotInLeadingDocComment2()
    {
        var markup = """
            class Ext
            {
                [||]///
                void Goo(int a, int b)
                {
                };
            }
            """;
 
        await TestChangeSignatureViaCodeActionAsync(markup, expectedCodeAction: false);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/17309")]
    public async Task TestNotInLeadingAttributes1()
    {
        var markup = """
            class Ext
            {
                [||][X]
                void Goo(int a, int b)
                {
                };
            }
            """;
 
        await TestChangeSignatureViaCodeActionAsync(markup, expectedCodeAction: false);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/17309")]
    public async Task TestNotInLeadingAttributes2()
    {
        var markup = """
            class Ext
            {
                [[||]X]
                void Goo(int a, int b)
                {
                };
            }
            """;
 
        await TestChangeSignatureViaCodeActionAsync(markup, expectedCodeAction: false);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/17309")]
    public async Task TestNotInLeadingAttributes3()
    {
        var markup = """
            class Ext
            {
                [X][||]
                void Goo(int a, int b)
                {
                };
            }
            """;
 
        await TestChangeSignatureViaCodeActionAsync(markup, expectedCodeAction: false);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/17309")]
    public async Task TestNotInConstraints()
    {
        var markup = """
            class Ext
            {
                void Goo<T>(int a, int b) where [||]T : class
                {
                };
            }
            """;
 
        await TestChangeSignatureViaCodeActionAsync(markup, expectedCodeAction: false);
    }
}