// 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;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CSharp.KeywordHighlighting.KeywordHighlighters;
using Microsoft.CodeAnalysis.Test.Utilities;
using Xunit;
 
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.KeywordHighlighting
{
    [Trait(Traits.Feature, Traits.Features.KeywordHighlighting)]
    public class ReturnStatementHighlighterTests : AbstractCSharpKeywordHighlighterTests
    {
        internal override Type GetHighlighterType()
            => typeof(ReturnStatementHighlighter);
 
        [Fact]
        public async Task TestInLambda()
        {
            await TestAsync(
@"static double CalculateArea(double radius)
{
    Func<double, double> f = r => {
        if (Double.IsNan(r))
        {
            {|Cursor:[|return|]|} Double.NaN;
        }
        else
        {
            [|return|] r * r * Math.PI;
        }
    };
    return calcArea(radius);
}");
        }
 
        [Fact]
        public async Task TestInLambda_NotOnReturnValue()
        {
            await TestAsync(
@"class C
{
    static double CalculateArea(double radius)
    {
        Func<double, double> f = r => {
            if (Double.IsNan(r))
            {
                return {|Cursor:Double.NaN|};
            }
            else
            {
                return r * r * Math.PI;
            }
        };
        return calcArea(radius);
    }
}");
        }
 
        [Fact]
        public async Task TestInLambda_OnSemicolon()
        {
            await TestAsync(
@"class C
{
    static double CalculateArea(double radius)
    {
        Func<double, double> f = r => {
            if (Double.IsNan(r))
            {
                [|return|] Double.NaN;{|Cursor:|}
            }
            else
            {
                [|return|] r * r * Math.PI;
            }
        };
        return calcArea(radius);
    }
}");
        }
 
        [Fact]
        public async Task TestInLambda_SecondOccurence()
        {
            await TestAsync(
@"class C
{
    static double CalculateArea(double radius)
    {
        Func<double, double> f = r => {
            if (Double.IsNan(r))
            {
                [|return|] Double.NaN;
            }
            else
            {
                {|Cursor:[|return|]|} r * r * Math.PI;
            }
        };
        return calcArea(radius);
    }
}");
        }
 
        [Fact]
        public async Task TestInLambda_SecondOccurence_NotOnReturnValue()
        {
            await TestAsync(
@"class C
{
    static double CalculateArea(double radius)
    {
        Func<double, double> f = r => {
            if (Double.IsNan(r))
            {
                return Double.NaN;
            }
            else
            {
                return {|Cursor:r * r * Math.PI|};
            }
        };
        return calcArea(radius);
    }
}");
        }
 
        [Fact]
        public async Task TestInLambda_SecondOccurence_OnSemicolon()
        {
            await TestAsync(
@"class C
{
    static double CalculateArea(double radius)
    {
        Func<double, double> f = r => {
            if (Double.IsNan(r))
            {
                [|return|] Double.NaN;
            }
            else
            {
                [|return|] r * r * Math.PI;{|Cursor:|}
            }
        };
        return calcArea(radius);
    }
}");
        }
 
        [Fact]
        public async Task TestInMethodWithLambda()
        {
            await TestAsync(
@"class C
{
    static double CalculateArea(double radius)
    {
        Func<double, double> f = r => {
            if (Double.IsNan(r))
            {
                return Double.NaN;
            }
            else
            {
                return r * r * Math.PI;
            }
        };
        {|Cursor:[|return|]|} calcArea(radius);
    }
}");
        }
 
        [Fact]
        public async Task TestInMethodWithLambda_NotOnReturnValue()
        {
            await TestAsync(
@"class C
{
    static double CalculateArea(double radius)
    {
        Func<double, double> f = r => {
            if (Double.IsNan(r))
            {
                return Double.NaN;
            }
            else
            {
                return r * r * Math.PI;
            }
        };
        return {|Cursor:calcArea(radius)|};
    }
}");
        }
 
        [Fact]
        public async Task TestInMethodWithLambda_OnSemicolon()
        {
            await TestAsync(
@"class C
{
    static double CalculateArea(double radius)
    {
        Func<double, double> f = r => {
            if (Double.IsNan(r))
            {
                return Double.NaN;
            }
            else
            {
                return r * r * Math.PI;
            }
        };
        [|return|] calcArea(radius);{|Cursor:|}
    }
}");
        }
 
        [Fact]
        public async Task TestInConstructor()
        {
            await TestAsync(
@"class C
{
    C()
    {
        {|Cursor:[|return|]|};
        [|return|];
    }
}");
        }
 
        [Fact]
        public async Task TestInDestructor()
        {
            await TestAsync(
@"class C
{
    ~C()
    {
        {|Cursor:[|return|]|};
        [|return|];
    }
}");
        }
 
        [Fact]
        public async Task TestInOperator()
        {
            await TestAsync(
@"class C
{
    public static string operator +(C a)
    {
        {|Cursor:[|return|]|} null;
        [|return|] null;
    }
}");
        }
 
        [Fact]
        public async Task TestInConversionOperator()
        {
            await TestAsync(
@"class C
{
    public static explicit operator string(C a)
    {
        {|Cursor:[|return|]|} null;
        [|return|] null;
    }
}");
        }
 
        [Fact]
        public async Task TestInGetter()
        {
            await TestAsync(
@"class C
{
    int P
    {
        get
        {
            {|Cursor:[|return|]|} 0;
            [|return|] 0;
        }
        set
        {
            return;
            return;
        }
    }
}");
        }
 
        [Fact]
        public async Task TestInSetter()
        {
            await TestAsync(
@"class C
{
    int P
    {
        get
        {
            return 0;
            return 0;
        }
        set
        {
            {|Cursor:[|return|]|};
            [|return|];
        }
    }
}");
        }
 
        [Fact]
        public async Task TestInInit()
        {
            await TestAsync(
@"class C
{
    int P
    {
        get
        {
            return 0;
            return 0;
        }
        init
        {
            {|Cursor:[|return|]|};
            [|return|];
        }
    }
}");
        }
 
        [Fact]
        public async Task TestInAdder()
        {
            await TestAsync(
@"class C
{
    event EventHandler E
    {
        add
        {
            {|Cursor:[|return|]|};
            [|return|];
        }
        remove
        {
            return;
            return;
        }
    }
}");
        }
 
        [Fact]
        public async Task TestInRemover()
        {
            await TestAsync(
@"class C
{
    event EventHandler E
    {
        add
        {
            return;
            return;
        }
        remove
        {
            {|Cursor:[|return|]|};
            [|return|];
        }
    }
}");
        }
 
        [Fact]
        public async Task TestInLocalFunction()
        {
            await TestAsync(
@"class C
{
    void M()
    {
        void F()
        {
            {|Cursor:[|return|]|};
            [|return|];
        }
 
        return;
    }
}");
        }
 
        [Fact]
        public async Task TestInSimpleLambda()
        {
            await TestAsync(
@"class C
{
    void M()
    {
        Action<string> f = s =>
        {
            {|Cursor:[|return|]|};
            [|return|];
        };
 
        return;
    }
}");
        }
 
        [Fact]
        public async Task TestInParenthesizedLambda()
        {
            await TestAsync(
@"class C
{
    void M()
    {
        Action<string> f = (s) =>
        {
            {|Cursor:[|return|]|};
            [|return|];
        };
 
        return;
    }
}");
        }
 
        [Fact]
        public async Task TestInAnonymousMethod()
        {
            await TestAsync(
@"class C
{
    void M()
    {
        Action<string> f = delegate
        {
            {|Cursor:[|return|]|};
            [|return|];
        };
 
        return;
    }
}");
        }
 
        [Fact]
        public async Task TestInTopLevelStatements()
        {
            await TestAsync(
@"if (args.Length > 0) [|return|] 0;
{|Cursor:[|return|]|} 1;");
        }
    }
}