// 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.AssignOutParameters;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Test.Utilities;
using Microsoft.CodeAnalysis.Testing;
using Xunit;
 
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.AssignOutParameters
{
    using VerifyCS = CSharpCodeFixVerifier<
        EmptyDiagnosticAnalyzer,
        AssignOutParametersAboveReturnCodeFixProvider>;
 
    [Trait(Traits.Feature, Traits.Features.CodeActionsAssignOutParameters)]
    public class AssignOutParametersAboveReturnTests
    {
        [Fact]
        public async Task TestForSimpleReturn()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    char M(out int i)
                    {
                        {|CS0177:return 'a';|}
                    }
                }
                """,
                """
                class C
                {
                    char M(out int i)
                    {
                        i = 0;
                        return 'a';
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestForSwitchSectionReturn()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    char M(out int i)
                    {
                        switch (0)
                        {
                            default:
                                {|CS0177:return 'a';|}
                        }
                    }
                }
                """,
                """
                class C
                {
                    char M(out int i)
                    {
                        switch (0)
                        {
                            default:
                                i = 0;
                                return 'a';
                        }
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestMissingWhenVariableAssigned()
        {
            var code = """
                class C
                {
                    char M(out int i)
                    {
                        i = 0;
                        return 'a';
                    }
                }
                """;
 
            await VerifyCS.VerifyCodeFixAsync(code, code);
        }
 
        [Fact]
        public async Task TestWhenNotAssignedThroughAllPaths1()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    char M(bool b, out int i)
                    {
                        if (b)
                            i = 1;
                        
                        {|CS0177:return 'a';|}
                    }
                }
                """,
                """
                class C
                {
                    char M(bool b, out int i)
                    {
                        if (b)
                            i = 1;
                        i = 0;
                        return 'a';
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestWhenNotAssignedThroughAllPaths2()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    bool M(out int i1, out int i2)
                    {
                        {|CS0177:return Try(out i1) || Try(out i2);|}
                    }
 
                    bool Try(out int i)
                    {
                        i = 0;
                        return true;
                    }
                }
                """,
                """
                class C
                {
                    bool M(out int i1, out int i2)
                    {
                        i2 = 0;
                        return Try(out i1) || Try(out i2);
                    }
 
                    bool Try(out int i)
                    {
                        i = 0;
                        return true;
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestMissingWhenAssignedThroughAllPaths()
        {
            var code = """
                class C
                {
                    char M(bool b, out int i)
                    {
                        if (b)
                            i = 1;
                        else
                            i = 2;
                        
                        return 'a';
                    }
                }
                """;
 
            await VerifyCS.VerifyCodeFixAsync(code, code);
        }
 
        [Fact]
        public async Task TestMultiple()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    char M(out int i, out string s)
                    {
                        {|CS0177:{|CS0177:return 'a';|}|}
                    }
                }
                """,
                """
                class C
                {
                    char M(out int i, out string s)
                    {
                        i = 0;
                        s = null;
                        return 'a';
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestMultiple_AssignedInReturn1()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    string M(out int i, out string s)
                    {
                        {|CS0177:return s = "";|}
                    }
                }
                """,
                """
                class C
                {
                    string M(out int i, out string s)
                    {
                        i = 0;
                        return s = "";
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestMultiple_AssignedInReturn2()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    string M(out int i, out string s)
                    {
                        {|CS0177:return (i = 0).ToString();|}
                    }
                }
                """,
                """
                class C
                {
                    string M(out int i, out string s)
                    {
                        s = null;
                        return (i = 0).ToString();
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestNestedReturn()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    char M(out int i)
                    {
                        if (true)
                        {
                            {|CS0177:return 'a';|}
                        }
                    }
                }
                """,
                """
                class C
                {
                    char M(out int i)
                    {
                        if (true)
                        {
                            i = 0;
                            return 'a';
                        }
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestNestedReturnNoBlock()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    char M(out int i)
                    {
                        if (true)
                            {|CS0177:return 'a';|}
                    }
                }
                """,
                """
                class C
                {
                    char M(out int i)
                    {
                        if (true)
                        {
                            i = 0;
                            return 'a';
                        }
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestNestedReturnEvenWhenWrittenAfter()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    char M(bool b, out int i)
                    {
                        if (b)
                        {
                            {|CS0177:return 'a';|}
                        }
 
                        i = 1;
                        throw null;
                    }
                }
                """,
                """
                class C
                {
                    char M(bool b, out int i)
                    {
                        if (b)
                        {
                            i = 0;
                            return 'a';
                        }
 
                        i = 1;
                        throw null;
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestForExpressionBodyMember()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    char M(out int i) => {|CS0177:'a'|};
                }
                """,
                """
                class C
                {
                    char M(out int i)
                    {
                        i = 0;
                        return 'a';
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestForLambdaExpressionBody()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    delegate char D(out int i);
                    void X()
                    {
                        D d = (out int i) => {|CS0177:'a'|};
                    }
                }
                """,
                """
                class C
                {
                    delegate char D(out int i);
                    void X()
                    {
                        D d = (out int i) => { i = 0; return 'a'; };
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestMissingForLocalFunctionExpressionBody()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    void X()
                    {
                        char {|CS0177:D|}(out int i) => 'a';
                        D(out _);
                    }
                }
                """,
                """
                class C
                {
                    void X()
                    {
                        char D(out int i) { i = 0; return 'a'; }
 
                        D(out _);
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestForLambdaBlockBody()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    delegate char D(out int i);
                    void X()
                    {
                        D d = (out int i) =>
                        {
                            {|CS0177:return 'a';|}
                        };
                    }
                }
                """,
                """
                class C
                {
                    delegate char D(out int i);
                    void X()
                    {
                        D d = (out int i) =>
                        {
                            i = 0;
                            return 'a';
                        };
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestForLocalFunctionBlockBody()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    void X()
                    {
                        char D(out int i)
                        {
                            {|CS0177:return 'a';|}
                        }
 
                        D(out _);
                    }
                }
                """,
                """
                class C
                {
                    void X()
                    {
                        char D(out int i)
                        {
                            i = 0;
                            return 'a';
                        }
 
                        D(out _);
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestForOutParamInSinglePath()
        {
            var code = """
                class C
                {
                    char M(bool b, out int i)
                    {
                        if (b)
                            i = 1;
                        else
                            SomeMethod(out i);
 
                        return 'a';
                    }
 
                    void SomeMethod(out int i) => i = 0;
                }
                """;
 
            await VerifyCS.VerifyCodeFixAsync(code, code);
        }
 
        [Fact]
        public async Task TestFixAll1()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    char M(bool b, out int i, out int j)
                    {
                        if (b)
                        {
                            {|CS0177:{|CS0177:return 'a';|}|}
                        }
                        else
                        {
                            {|CS0177:{|CS0177:return 'a';|}|}
                        }
                    }
                }
                """,
                """
                class C
                {
                    char M(bool b, out int i, out int j)
                    {
                        if (b)
                        {
                            i = 0;
                            j = 0;
                            return 'a';
                        }
                        else
                        {
                            i = 0;
                            j = 0;
                            return 'a';
                        }
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestFixAll1_MultipleMethods()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    char M(bool b, out int i, out int j)
                    {
                        if (b)
                        {
                            {|CS0177:{|CS0177:return 'a';|}|}
                        }
                        else
                        {
                            {|CS0177:{|CS0177:return 'a';|}|}
                        }
                    }
                    char N(bool b, out int i, out int j)
                    {
                        if (b)
                        {
                            {|CS0177:{|CS0177:return 'a';|}|}
                        }
                        else
                        {
                            {|CS0177:{|CS0177:return 'a';|}|}
                        }
                    }
                }
                """,
                """
                class C
                {
                    char M(bool b, out int i, out int j)
                    {
                        if (b)
                        {
                            i = 0;
                            j = 0;
                            return 'a';
                        }
                        else
                        {
                            i = 0;
                            j = 0;
                            return 'a';
                        }
                    }
                    char N(bool b, out int i, out int j)
                    {
                        if (b)
                        {
                            i = 0;
                            j = 0;
                            return 'a';
                        }
                        else
                        {
                            i = 0;
                            j = 0;
                            return 'a';
                        }
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestFixAll2()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    char M(bool b, out int i, out int j)
                    {
                        if (b)
                            {|CS0177:{|CS0177:return 'a';|}|}
                        else
                            {|CS0177:{|CS0177:return 'a';|}|}
                    }
                }
                """,
                """
                class C
                {
                    char M(bool b, out int i, out int j)
                    {
                        if (b)
                        {
                            i = 0;
                            j = 0;
                            return 'a';
                        }
                        else
                        {
                            i = 0;
                            j = 0;
                            return 'a';
                        }
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestFixAll2_MultipleMethods()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    char M(bool b, out int i, out int j)
                    {
                        if (b)
                            {|CS0177:{|CS0177:return 'a';|}|}
                        else
                            {|CS0177:{|CS0177:return 'a';|}|}
                    }
                    char N(bool b, out int i, out int j)
                    {
                        if (b)
                            {|CS0177:{|CS0177:return 'a';|}|}
                        else
                            {|CS0177:{|CS0177:return 'a';|}|}
                    }
                }
                """,
                """
                class C
                {
                    char M(bool b, out int i, out int j)
                    {
                        if (b)
                        {
                            i = 0;
                            j = 0;
                            return 'a';
                        }
                        else
                        {
                            i = 0;
                            j = 0;
                            return 'a';
                        }
                    }
                    char N(bool b, out int i, out int j)
                    {
                        if (b)
                        {
                            i = 0;
                            j = 0;
                            return 'a';
                        }
                        else
                        {
                            i = 0;
                            j = 0;
                            return 'a';
                        }
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestFixAll3()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    char M(bool b, out int i, out int j)
                    {
                        if (b)
                        {
                            i = 0;
                            {|CS0177:return 'a';|}
                        }
                        else
                        {
                            j = 0;
                            {|CS0177:return 'a';|}
                        }
                    }
                }
                """,
                """
                class C
                {
                    char M(bool b, out int i, out int j)
                    {
                        if (b)
                        {
                            i = 0;
                            j = 0;
                            return 'a';
                        }
                        else
                        {
                            j = 0;
                            i = 0;
                            return 'a';
                        }
                    }
                }
                """);
        }
 
        [Fact]
        public async Task TestFixAll3_MultipleMethods()
        {
            await VerifyCS.VerifyCodeFixAsync(
                """
                class C
                {
                    char M(bool b, out int i, out int j)
                    {
                        if (b)
                        {
                            i = 0;
                            {|CS0177:return 'a';|}
                        }
                        else
                        {
                            j = 0;
                            {|CS0177:return 'a';|}
                        }
                    }
                    char N(bool b, out int i, out int j)
                    {
                        if (b)
                        {
                            i = 0;
                            {|CS0177:return 'a';|}
                        }
                        else
                        {
                            j = 0;
                            {|CS0177:return 'a';|}
                        }
                    }
                }
                """,
                """
                class C
                {
                    char M(bool b, out int i, out int j)
                    {
                        if (b)
                        {
                            i = 0;
                            j = 0;
                            return 'a';
                        }
                        else
                        {
                            j = 0;
                            i = 0;
                            return 'a';
                        }
                    }
                    char N(bool b, out int i, out int j)
                    {
                        if (b)
                        {
                            i = 0;
                            j = 0;
                            return 'a';
                        }
                        else
                        {
                            j = 0;
                            i = 0;
                            return 'a';
                        }
                    }
                }
                """);
        }
    }
}