// 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 Xunit;
 
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.SplitOrMergeIfStatements
{
    public sealed partial class MergeConsecutiveIfStatementsTests
    {
        [Theory]
        [InlineData("[||]if (a)")]
        [InlineData("i[||]f (a)")]
        [InlineData("if[||] (a)")]
        [InlineData("if [||](a)")]
        [InlineData("if (a)[||]")]
        [InlineData("[|if|] (a)")]
        [InlineData("[|if (a)|]")]
        public async Task MergedOnIfSpans(string ifLine)
        {
            await TestInRegularAndScriptAsync(
@"class C
{
    void M(bool a, bool b)
    {
        " + ifLine + @"
        {
        }
        else if (b)
        {
        }
    }
}",
@"class C
{
    void M(bool a, bool b)
    {
        if (a || b)
        {
        }
    }
}");
        }
 
        [Fact]
        public async Task MergedOnIfExtendedHeaderSelection()
        {
            await TestInRegularAndScriptAsync(
@"class C
{
    void M(bool a, bool b)
    {
[|        if (a)
|]        {
        }
        else if (b)
        {
        }
    }
}",
@"class C
{
    void M(bool a, bool b)
    {
        if (a || b)
        {
        }
    }
}");
        }
 
        [Fact]
        public async Task MergedOnIfFullSelectionWithoutElseIfClause()
        {
            await TestInRegularAndScriptAsync(
@"class C
{
    void M(bool a, bool b)
    {
        [|if (a)
        {
        }|]
        else if (b)
        {
        }
        else
        {
        }
    }
}",
@"class C
{
    void M(bool a, bool b)
    {
        if (a || b)
        {
        }
        else
        {
        }
    }
}");
        }
 
        [Fact]
        public async Task MergedOnIfExtendedFullSelectionWithoutElseIfClause()
        {
            await TestInRegularAndScriptAsync(
@"class C
{
    void M(bool a, bool b)
    {
[|        if (a)
        {
        }
|]        else if (b)
        {
        }
        else
        {
        }
    }
}",
@"class C
{
    void M(bool a, bool b)
    {
        if (a || b)
        {
        }
        else
        {
        }
    }
}");
        }
 
        [Fact]
        public async Task NotMergedOnIfFullSelectionWithElseIfClause()
        {
            await TestMissingInRegularAndScriptAsync(
@"class C
{
    void M(bool a, bool b)
    {
        [|if (a)
        {
        }
        else if (b)
        {
        }|]
        else
        {
        }
    }
}");
        }
 
        [Fact]
        public async Task NotMergedOnIfExtendedFullSelectionWithElseIfClause()
        {
            await TestMissingInRegularAndScriptAsync(
@"class C
{
    void M(bool a, bool b)
    {
[|        if (a)
        {
        }
        else if (b)
        {
        }
|]        else
        {
        }
    }
}");
        }
 
        [Fact]
        public async Task NotMergedOnIfFullSelectionWithElseIfElseClauses()
        {
            await TestMissingInRegularAndScriptAsync(
@"class C
{
    void M(bool a, bool b)
    {
        [|if (a)
        {
        }
        else if (b)
        {
        }
        else
        {
        }|]
    }
}");
        }
 
        [Fact]
        public async Task NotMergedOnIfExtendedFullSelectionWithElseIfElseClauses()
        {
            await TestMissingInRegularAndScriptAsync(
@"class C
{
    void M(bool a, bool b)
    {
[|        if (a)
        {
        }
        else if (b)
        {
        }
        else
        {
        }
|]    }
}");
        }
 
        [Theory]
        [InlineData("if ([||]a)")]
        [InlineData("[|i|]f (a)")]
        [InlineData("[|if (|]a)")]
        [InlineData("if [|(|]a)")]
        [InlineData("if (a[|)|]")]
        [InlineData("if ([|a|])")]
        [InlineData("if [|(a)|]")]
        public async Task NotMergedOnIfSpans(string ifLine)
        {
            await TestMissingInRegularAndScriptAsync(
@"class C
{
    void M(bool a, bool b)
    {
        " + ifLine + @"
        {
        }
        else if (b)
        {
        }
    }
}");
        }
 
        [Fact]
        public async Task NotMergedOnIfOverreachingSelection1()
        {
            await TestMissingInRegularAndScriptAsync(
@"class C
{
    void M(bool a, bool b)
    {
        [|if (a)
        |]{
        }
        else if (b)
        {
        }
    }
}");
        }
 
        [Fact]
        public async Task NotMergedOnIfOverreachingSelection2()
        {
            await TestMissingInRegularAndScriptAsync(
@"class C
{
    void M(bool a, bool b)
    {
        [|if (a)
        {|]
        }
        else if (b)
        {
        }
    }
}");
        }
 
        [Fact]
        public async Task NotMergedOnIfBodySelection()
        {
            await TestMissingInRegularAndScriptAsync(
@"class C
{
    void M(bool a, bool b)
    {
        if (a)
        [|{
        }|]
        else if (b)
        {
        }
    }
}");
        }
 
        [Fact]
        public async Task NotMergedOnIfBodyCaret1()
        {
            await TestMissingInRegularAndScriptAsync(
@"class C
{
    void M(bool a, bool b)
    {
        if (a)
        [||]{
        }
        else if (b)
        {
        }
    }
}");
        }
 
        [Fact]
        public async Task NotMergedOnIfBodyCaret2()
        {
            await TestMissingInRegularAndScriptAsync(
@"class C
{
    void M(bool a, bool b)
    {
        if (a)
        {
        }[||]
        else if (b)
        {
        }
    }
}");
        }
    }
}