using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Shouldly;
using Xunit;

namespace Cfa.Tests.CallGraphBuilderTests;

public sealed class FindCalleesShould
{
    [Theory]
    [InlineData("Value")]
    [InlineData("this.Value")]
    public async Task FindExpressionBodiedProperties(string access)
    {
        // Arrange
        var source = $$"""
            class Example
            {
                int Value => 1;
                void Start() { _ = {{access}}; }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start].ShouldHaveSingleItem().Target.Name.ShouldBe("Value");
    }

    [Fact]
    public async Task FollowMethodCallsInsideProperties()
    {
        // Arrange
        const string source = """
            class Example
            {
                int Value => GetValue();
                int GetValue() => 1;
                void Start() { _ = Value; }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var property = calls[start].ShouldHaveSingleItem();
        property.Target.Name.ShouldBe("Value");
        calls[property.Target].ShouldHaveSingleItem().Target.Name.ShouldBe("GetValue");
    }

    [Theory]
    [InlineData("int Value { get { return 1; } }", "_ = Value;")]
    [InlineData("int Value { get => 1; }", "_ = Value;")]
    [InlineData("int Value { set { } }", "Value = 1;")]
    public async Task FindPropertiesWithAccessorBodies(string declaration, string access)
    {
        // Arrange
        var source = $$"""
            class Example
            {
                {{declaration}}
                void Start() { {{access}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start].ShouldHaveSingleItem().Target.Name.ShouldBe("Value");
    }

    [Theory]
    [InlineData("set { Save(value); }", "Value = 1;")]
    [InlineData("set { Save(value); }", "this.Value = 1;")]
    [InlineData("set => Save(value);", "Value = 1;")]
    [InlineData("set => Save(value);", "this.Value = 1;")]
    public async Task FollowAssignedPropertiesAndMethodCallsInsideTheirSetters(string setter, string assignment)
    {
        // Arrange
        var source = $$"""
            class Example
            {
                int Value { {{setter}} }
                void Save(int value) { }
                void Start() { {{assignment}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var property = calls[start].ShouldHaveSingleItem();
        property.Target.Name.ShouldBe("Value");
        calls[property.Target].ShouldHaveSingleItem().Target.Name.ShouldBe("Save");
    }

    [Theory]
    [InlineData("_ = this.Value;")]
    [InlineData("this.Value = 2;")]
    public async Task IgnoreAutoPropertiesEvenWhenTheyHaveInitializers(string access)
    {
        // Arrange
        var source = $$"""
            class Example
            {
                int Value { get; set; } = 1;
                void Start() { {{access}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start].ShouldBeEmpty();
    }

    [Theory]
    [InlineData("int this[int index] => Read();", "_ = this[0];", "Read")]
    [InlineData("int this[int index] => Read();", "_ = this?[0];", "Read")]
    [InlineData("int this[int index] { get { return Read(); } }", "_ = this[0];", "Read")]
    [InlineData("int this[int index] { get => Read(); }", "_ = this[0];", "Read")]
    [InlineData("int this[int index] { set { Save(value); } }", "this[0] = 1;", "Save")]
    [InlineData("int this[int index] { set => Save(value); }", "this[0] = 1;", "Save")]
    public async Task FollowIndexersWithBodies(string declaration, string access, string method)
    {
        // Arrange
        var source = $$"""
            class Example
            {
                {{declaration}}
                int Read() => 1;
                void Save(int value) { }
                void Start() { {{access}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var indexer = calls[start].ShouldHaveSingleItem();
        indexer.Target.ShouldBeAssignableTo<IPropertySymbol>().IsIndexer.ShouldBeTrue();
        calls[indexer.Target].ShouldHaveSingleItem().Target.Name.ShouldBe(method);
    }

    [Fact]
    public async Task IgnoreIndexersWithoutBodies()
    {
        // Arrange
        const string source = """
            abstract class Example
            {
                public abstract int this[int index] { get; set; }
                void Start() { _ = this[0]; this[0] = 1; }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start].ShouldBeEmpty();
    }

    [Theory]
    [InlineData("void Run();", "public void Run() => Helper();", "service.Run();")]
    [InlineData("void Run();", "void IService.Run() => Helper();", "service.Run();")]
    [InlineData("int Value { get; }", "public int Value => Helper();", "_ = service.Value;")]
    [InlineData("int Value { get; }", "int IService.Value => Helper();", "_ = service.Value;")]
    [InlineData("int this[int index] { get; }", "public int this[int index] => Helper();", "_ = service[0];")]
    public async Task FollowSourceImplementationsOfInterfaces(string contract, string implementation, string access)
    {
        // Arrange
        var source = $$"""
            interface IService { {{contract}} }
            class Example : IService
            {
                {{implementation}}
                int Helper() => 1;
                void Start(IService service) { {{access}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.Target.ContainingType.Name.ShouldBe("Example");
        calls[call.Target].ShouldHaveSingleItem().Target.Name.ShouldBe("Helper");
    }

    [Fact]
    public async Task NotListTheAbstractMemberOnlyTheImplementation()
    {
        // Arrange
        const string source = """
            interface IService { void Run(); }
            class Example : IService
            {
                public void Run() { }
                void Start(IService service) { service.Run(); }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.Target.ContainingType.Name.ShouldBe("Example");
    }

    [Fact]
    public async Task FollowImplementationsOfInterfacesFromMetadata()
    {
        // Arrange
        const string source = """
            class Example : System.IDisposable
            {
                public void Dispose() => Cleanup();
                void Cleanup() { }
                void Start(System.IDisposable service) { service.Dispose(); }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.Target.Name.ShouldBe("Dispose");
        call.LinkKind.ShouldBe(LinkKind.Abstract);
        calls[call.Target].ShouldHaveSingleItem().Target.Name.ShouldBe("Cleanup");
    }

    [Theory]
    [InlineData("service.Run(); Run();")]
    [InlineData("Run(); service.Run();")]
    public async Task PreferDirectCallsOverInterfaceLinks(string body)
    {
        // Arrange
        var source = $$"""
            interface IService { void Run(); }
            class Example : IService
            {
                public void Run() { }
                void Start(IService service) { {{body}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.LinkKind.ShouldBe(LinkKind.Direct);
    }

    [Fact]
    public async Task IgnoreInterfaceImplementationsWithoutPropertyBodies()
    {
        // Arrange
        const string source = """
            interface IService { int Value { get; } }
            class Example : IService
            {
                public int Value { get; set; }
                void Start(IService service) { _ = service.Value; }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start].ShouldBeEmpty();
    }

    [Theory]
    [InlineData("public abstract void Run();", "public override void Run() => Helper();", "service.Run();")]
    [InlineData("public abstract int Value { get; }", "public override int Value => Helper();", "_ = service.Value;")]
    [InlineData(
        "public abstract int this[int index] { get; }",
        "public override int this[int index] => Helper();",
        "_ = service[0];"
    )]
    public async Task FollowOverridesOfAbstractMembers(string contract, string implementation, string access)
    {
        // Arrange
        var source = $$"""
            abstract class Service { {{contract}} }
            class Example : Service
            {
                {{implementation}}
                int Helper() => 1;
                void Start(Service service) { {{access}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.Target.ContainingType.Name.ShouldBe("Example");
        calls[call.Target].ShouldHaveSingleItem().Target.Name.ShouldBe("Helper");
    }

    [Fact]
    public async Task FollowOverridesThroughIntermediateAbstractClasses()
    {
        // Arrange
        const string source = """
            abstract class Service { public abstract void Run(); }
            abstract class Middle : Service { public abstract override void Run(); }
            class Example : Middle
            {
                public override void Run() { }
                void Start(Service service) { service.Run(); }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.Target.ContainingType.Name.ShouldBe("Example");
    }

    [Theory]
    [InlineData("service.Run(); Run();")]
    [InlineData("Run(); service.Run();")]
    public async Task PreferDirectCallsOverAbstractDispatch(string body)
    {
        // Arrange
        var source = $$"""
            abstract class Service { public abstract void Run(); }
            class Example : Service
            {
                public override void Run() { }
                void Start(Service service) { {{body}} }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.LinkKind.ShouldBe(LinkKind.Direct);
    }

    [Fact]
    public async Task FollowVirtualMemberImplementations()
    {
        // Arrange
        const string source = """
            class Service { public virtual void Run() { } }
            class Example : Service
            {
                public override void Run() { }
                void Start(Service service) { service.Run(); }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start]
            .ShouldContain(call => call.Target.ContainingType.Name == "Service" || call.LinkKind == LinkKind.Direct);
        calls[start]
            .ShouldContain(call => call.Target.ContainingType.Name == "Example" || call.LinkKind == LinkKind.Abstract);
    }

    [Fact]
    public async Task NotFollowVirtualMemberImplementation_WhenOverrideIsCalledDirectly()
    {
        // Arrange
        const string source = """
            class Service { public virtual void Run() { } }
            class Example : Service
            {
                public override void Run() { }
                void Start() { Run(); }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var call = calls[start].ShouldHaveSingleItem();
        call.Target.ContainingType.Name.ShouldBe("Example");
        call.LinkKind.ShouldBe(LinkKind.Direct);
    }

    [Theory]
    [InlineData("new Service()")]
    [InlineData("new()")]
    public async Task FollowConstructorsAndTheirMethodCalls(string creation)
    {
        // Arrange
        var source = $$"""
            class Service
            {
                public Service() { Initialize(); }
                void Initialize() { }
            }
            class Example
            {
                void Start() { Service service = {{creation}}; }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var constructor = calls[start].ShouldHaveSingleItem();
        constructor.Target.ShouldBeAssignableTo<IMethodSymbol>().MethodKind.ShouldBe(MethodKind.Constructor);
        constructor.LinkKind.ShouldBe(LinkKind.Direct);
        calls[constructor.Target].ShouldHaveSingleItem().Target.Name.ShouldBe("Initialize");
    }

    [Theory]
    [InlineData("this")]
    [InlineData("base")]
    public async Task FollowChainedConstructors(string initializer)
    {
        // Arrange
        var source = $$"""
            class Parent
            {
                public Parent() { }
                public Parent(int value) { }
            }
            class Service : Parent
            {
                public Service() : {{initializer}}(1) { }
                public Service(int value) { }
            }
            class Example
            {
                void Start() { _ = new Service(); }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        var constructor = calls[start].ShouldHaveSingleItem();
        var chained = calls[constructor.Target].ShouldHaveSingleItem();
        var method = chained.Target.ShouldBeAssignableTo<IMethodSymbol>();
        method.MethodKind.ShouldBe(MethodKind.Constructor);
        method.Parameters.ShouldHaveSingleItem().Type.SpecialType.ShouldBe(SpecialType.System_Int32);
        method.ContainingType.Name.ShouldBe(initializer is "this" ? "Service" : "Parent");
        chained.LinkKind.ShouldBe(LinkKind.Direct);
    }

    [Fact]
    public async Task IgnoreConstructorsWithoutSourceDeclarations()
    {
        // Arrange
        const string source = """
            class Service { }
            class Example
            {
                void Start() { _ = new Service(); _ = new object(); }
            }
            """;

        // Act
        var (start, calls) = await source.FindCallees();

        // Assert
        calls[start].ShouldBeEmpty();
    }
}