// 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.Threading.Tasks;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.ConvertTypeOfToNameOf;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
 
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertTypeOfToNameOf;
 
using VerifyCS = CSharpCodeFixVerifier<CSharpConvertTypeOfToNameOfDiagnosticAnalyzer,
    CSharpConvertTypeOfToNameOfCodeFixProvider>;
 
[Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)]
public partial class ConvertTypeOfToNameOfTests
{
    [Fact]
    public async Task BasicType()
    {
        var text = """
            class Test
            {
                void Method()
                {
                    var typeName = [|typeof(Test).Name|];
                }
            }
            """;
        var expected = """
            class Test
            {
                void Method()
                {
                    var typeName = nameof(Test);
                }
            }
            """;
        await VerifyCS.VerifyCodeFixAsync(text, expected);
    }
 
    [Fact]
    public async Task ClassLibraryType()
    {
        var text = """
            class Test
            {
                void Method()
                {
                    var typeName = [|typeof(System.String).Name|];
                }
            }
            """;
        var expected = """
            class Test
            {
                void Method()
                {
                    var typeName = nameof(System.String);
                }
            }
            """;
        await VerifyCS.VerifyCodeFixAsync(text, expected);
    }
 
    [Fact]
    public async Task ClassLibraryTypeWithUsing()
    {
        var text = """
            using System;
 
            class Test
            {
                void Method()
                {
                    var typeName = [|typeof(String).Name|];
                }
            }
            """;
        var expected = """
            using System;
 
            class Test
            {
                void Method()
                {
                    var typeName = nameof(String);
                }
            }
            """;
        await VerifyCS.VerifyCodeFixAsync(text, expected);
    }
 
    [Fact]
    public async Task NestedCall()
    {
        var text = """
            using System;
 
            class Test
            {
                void Method()
                {
                    var typeName = Foo([|typeof(System.String).Name|]);
                }
 
                int Foo(String typeName) {
                    return 0;
                }
            }
            """;
        var expected = """
            using System;
 
            class Test
            {
                void Method()
                {
                    var typeName = Foo(nameof(String));
                }
 
                int Foo(String typeName) {
                    return 0;
                }
            }
            """;
        await VerifyCS.VerifyCodeFixAsync(text, expected);
    }
 
    [Fact]
    public async Task NotOnVariableContainingType()
    {
        var text = """
            using System;
 
            class Test
            {
                void Method()
                {
                    var typeVar = typeof(String);
                    var typeName = typeVar.Name;
                }
            }
            """;
        await VerifyCS.VerifyCodeFixAsync(text, text);
    }
 
    [Fact]
    public async Task PrimitiveType()
    {
        var text = """
            class Test
            {
                void Method()
                {
                        var typeName = [|typeof(int).Name|];
                }
            }
            """;
        var expected = """
            class Test
            {
                void Method()
                {
                        var typeName = nameof(System.Int32);
                }
            }
            """;
        await VerifyCS.VerifyCodeFixAsync(text, expected);
    }
 
    [Fact]
    public async Task PrimitiveTypeWithUsing()
    {
        var text = """
            using System;
 
            class Test
            {
                void Method()
                {
                        var typeName = [|typeof(int).Name|];
                }
            }
            """;
        var expected = """
            using System;
 
            class Test
            {
                void Method()
                {
                        var typeName = nameof(Int32);
                }
            }
            """;
        await VerifyCS.VerifyCodeFixAsync(text, expected);
    }
 
    [Fact]
    public async Task NotOnGenericType()
    {
        var text = """
            class Test<T>
            {
                void Method()
                {
                    var typeName = typeof(T).Name;
                }
            }
            """;
        await VerifyCS.VerifyCodeFixAsync(text, text);
    }
 
    [Fact]
    public async Task NotOnSimilarStatements()
    {
        var text = """
            class Test
            {
                void Method()
                {
                    var typeName1 = typeof(Test);
                    var typeName2 = typeof(Test).ToString();
                    var typeName3 = typeof(Test).FullName;
                }
            }
            """;
        await VerifyCS.VerifyCodeFixAsync(text, text);
    }
 
    [Fact]
    public async Task NotInGenericType()
    {
        var text = """
            class Test
            {
                class Goo<T> 
                { 
                    void M() 
                    {
                        _ = typeof(Goo<int>).Name;
                    }
                }
            }
            """;
        await VerifyCS.VerifyCodeFixAsync(text, text);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/47129")]
    public async Task NestedInGenericType()
    {
        var text = """
            class Test
            {
                class Goo<T> 
                { 
                    class Bar 
                    { 
                        void M() 
                        {
                            _ = [|typeof(Bar).Name|];
                        }
                    }
                }
            }
            """;
        var expected = """
            class Test
            {
                class Goo<T> 
                { 
                    class Bar 
                    { 
                        void M() 
                        {
                            _ = nameof(Bar);
                        }
                    }
                }
            }
            """;
        await VerifyCS.VerifyCodeFixAsync(text, expected);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/47129")]
    public async Task NestedInGenericType2()
    {
        var text = """
            using System;
            using System.Collections.Generic;
 
            class Test
            {
                public void M()
                {
                    Console.WriteLine([|typeof(List<int>.Enumerator).Name|]);
                }
            }
            """;
        var expected = """
            using System;
            using System.Collections.Generic;
 
            class Test
            {
                public void M()
                {
                    Console.WriteLine(nameof(List<Int32>.Enumerator));
                }
            }
            """;
        await VerifyCS.VerifyCodeFixAsync(text, expected);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/54233")]
    public async Task NotOnVoid()
    {
        var text = """
            class C
            {
                void M()
                {
                    var x = typeof(void).Name;
                }
            }
            """;
        await VerifyCS.VerifyCodeFixAsync(text, text);
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/47128")]
    public async Task TestNint()
    {
        await new VerifyCS.Test
        {
            TestCode = """
                using System;
 
                class C
                {
                    void M()
                    {
                        Console.WriteLine([|typeof(nint).Name|]);
                    }
                }
                """,
            FixedCode = """
                using System;
 
                class C
                {
                    void M()
                    {
                        Console.WriteLine(nameof(IntPtr));
                    }
                }
                """,
            LanguageVersion = LanguageVersion.CSharp10,
        }.RunAsync();
    }
}