using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Threading;
using Avalonia;
using Cfa.Ui.Graph;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Shouldly;
using Xunit;

namespace Cfa.Ui.Tests.GraphLayoutTests;

public sealed partial class BuildShould
{
    private static readonly INamedTypeSymbol Type = CreateType(
        "Root",
        "Left",
        "Right",
        "Leaf",
        "Other",
        "Shared",
        "Tail",
        "Helper"
    );

    [Fact]
    public void PreserveCallDirectionWithoutRestrictingDistantClustersToSides()
    {
        // Arrange
        var children = Map(("Root", ["Left", "Right"]), ("Left", ["Leaf"]), ("Right", ["Other", "Tail"]));
        var distant = children.ToImmutableDictionary(
            entry => entry.Key,
            entry =>
                (IImmutableList<CallAnalysis>)
                    entry.Value.Select(call => call with { Reach = CallReach.CrossAssembly }).ToImmutableList(),
            SymbolEqualityComparer.Default
        );
        var analysis = Analysis(distant, distant);

        // Act
        var scene = GraphLayout.Build(analysis);

        // Assert
        var origin = scene.Nodes.Single(n => n.IsOrigin);
        origin.Bounds.Center.ShouldBe(new Point(0, 0));
        foreach (
            var group in scene.Nodes.Where(n => !n.IsOrigin).GroupBy(n => n.Symbol, SymbolEqualityComparer.Default)
        )
        {
            var pair = group.ToArray();
            pair.Length.ShouldBe(2);
            pair[0].Location.ShouldNotBe(pair[1].Location);
        }
        foreach (var edge in scene.Edges)
        {
            edge.Source.Bounds.Inflate(0.000001).Contains(edge.Start).ShouldBeTrue();
            edge.Target.Bounds.Inflate(0.000001).Contains(edge.End).ShouldBeTrue();
        }
        AssertNoOverlap(scene);
    }

    [Fact]
    public void PreserveSharedOccurrencesAndTheirDescendantsOnSeparateBranches()
    {
        // Arrange
        var analysis = Analysis(
            Map(("Root", ["Left", "Right"]), ("Left", ["Shared"]), ("Right", ["Shared"]), ("Shared", ["Tail"]))
        );

        // Act
        var scene = GraphLayout.Build(analysis);

        // Assert
        scene.Nodes.Count(n => n.Symbol.Name == "Shared").ShouldBe(2);
        scene.Nodes.Count(n => n.Symbol.Name == "Tail").ShouldBe(2);
        scene.Nodes.Select(n => n.Id).Distinct().Count().ShouldBe(scene.Nodes.Count);
        scene.Nodes.ShouldAllBe(n => !n.IsCycleReference);
        scene.Edges.Count.ShouldBe(scene.Nodes.Count - 1);
        AssertNoOverlap(scene);
    }

    [Fact]
    public void RenderSelfCallsAsOneLoopbackOnTheExistingNode()
    {
        // Arrange
        var calls = Map(("Root", ["Root", "Left"]), ("Left", ["Left"]));
        var analysis = Analysis(calls, Map(("Root", ["Root"])));

        // Act
        var scene = GraphLayout.Build(analysis);

        // Assert
        scene.Nodes.Count.ShouldBe(2);
        var loops = scene.Edges.Where(e => e.IsLoopback).ToArray();
        loops.Length.ShouldBe(2);
        foreach (var loop in loops)
        {
            loop.Source.ShouldBeSameAs(loop.Target);
            loop.Start.ShouldNotBe(loop.End);
            loop.Start.X.ShouldBe(loop.Source.Bounds.Right + loop.Thickness / 2);
            loop.End.X.ShouldBe(loop.Source.Bounds.Right + loop.Thickness / 2);
            loop.Start.Y.ShouldBeGreaterThan(loop.Source.Bounds.Top);
            loop.End.Y.ShouldBeLessThan(loop.Source.Bounds.Bottom);
        }
        scene.Nodes.ShouldAllBe(n => !n.IsCycleReference);
    }

    [Fact]
    public void EndMultiNodeCyclesWithAReferencePerPath()
    {
        // Arrange
        var analysis = Analysis(Map(("Root", ["Left", "Right"]), ("Left", ["Root"]), ("Right", ["Left"])));

        // Act
        var scene = GraphLayout.Build(analysis);

        // Assert
        var references = scene.Nodes.Where(n => n.IsCycleReference).ToArray();
        references.Length.ShouldBe(2);
        references.ShouldAllBe(n => n.Symbol.Name == "Root" && !n.IsOrigin);
        references.ShouldAllBe(n => n.Label == "Methods.Root()");
        references.ShouldAllBe(n => !scene.Edges.Any(e => ReferenceEquals(e.Source, n)));
        scene.Nodes.Count(n => n.Symbol.Name == "Left").ShouldBe(2);
        scene.Edges.ShouldAllBe(e => !e.IsLoopback);
        AssertNoOverlap(scene);
    }

    [Fact]
    public void ProduceDeterministicPositionsAndEdgesWithoutModifyingEarlierScenes()
    {
        // Arrange
        var analysis = Analysis(
            Map(
                ("Root", ["Left", "Right", "Helper"]),
                ("Left", ["Shared", "Tail"]),
                ("Right", ["Shared"]),
                ("Shared", ["Leaf"])
            )
        );

        // Act
        var first = GraphLayout.Build(analysis);
        var positions = first.Nodes.Select(n => (n.Id, n.Location)).ToArray();
        var second = GraphLayout.Build(analysis);

        // Assert
        second.Nodes.Select(n => (n.Id, n.Location)).ShouldBe(positions);
        first.Nodes.Select(n => (n.Id, n.Location)).ShouldBe(positions);
        second
            .Edges.Select(e => (e.Source.Id, e.Target.Id, e.Start, e.End))
            .ShouldBe(first.Edges.Select(e => (e.Source.Id, e.Target.Id, e.Start, e.End)));
        AssertNoOverlap(second);
    }

    [Fact]
    public void IncreaseExclusionRadiusAndThicknessWithReachAndKind()
    {
        // Arrange
        var call = new CallAnalysis(Symbol("Left"), LinkKind.Direct, CallReach.SameType);

        // Act
        var kinds = new[] { LinkKind.Direct, LinkKind.Abstract, LinkKind.Event };
        var reaches = Enum.GetValues<CallReach>();

        // Assert
        foreach (var reach in reaches)
        {
            var lengths = kinds
                .Select(kind => GraphLayout.CalculateEdgeLength(call with { LinkKind = kind, Reach = reach }))
                .ToArray();
            lengths[0].ShouldBeLessThan(lengths[1]);
            lengths[1].ShouldBeLessThan(lengths[2]);
        }
        foreach (var kind in kinds)
        {
            var lengths = reaches
                .Select(reach => GraphLayout.CalculateEdgeLength(call with { LinkKind = kind, Reach = reach }))
                .ToArray();
            for (var i = 1; i < lengths.Length; i++)
                lengths[i].ShouldBeGreaterThan(lengths[i - 1]);
        }
        GraphLayout
            .CalculateThickness(call with { LinkKind = LinkKind.Abstract })
            .ShouldBeGreaterThan(GraphLayout.CalculateThickness(call));
        GraphLayout
            .CalculateThickness(call with { LinkKind = LinkKind.Event })
            .ShouldBeGreaterThan(GraphLayout.CalculateThickness(call));
    }

    [Fact]
    public void KeepNodeDimensionsAndFontsIndependentOfAppearanceCountsForNow()
    {
        // Arrange
        var graph = Analysis(Map(("Root", ["Left", "Helper"])));

        // Act
        var scene = GraphLayout.Build(graph with { Appearances = graph.Appearances.SetItem(Symbol("Helper"), 100) });

        // Assert
        scene.Nodes.ShouldAllBe(node => node.Width == 200 && node.Height == 72 && node.FontSize == 13);
    }

    [Fact]
    public void ApplyReachAndLinkKindToActualSingleBranchSpacing()
    {
        // Arrange
        var target = Symbol("Left");
        var calls = Enum.GetValues<LinkKind>()
            .SelectMany(kind => Enum.GetValues<CallReach>().Select(reach => new CallAnalysis(target, kind, reach)))
            .ToArray();

        // Act
        var scenes = calls
            .Select(call => GraphLayout.Build(Analysis(EmptyMap().Add(Symbol("Root"), ImmutableList.Create(call)))))
            .ToArray();

        // Assert
        for (var i = 0; i < scenes.Length; i++)
        {
            var edge = scenes[i].Edges.Single();
            var delta = edge.Target.Bounds.Center - edge.Source.Bounds.Center;
            var distance = new Vector(delta.X, delta.Y).Length;
            distance.ShouldBe(GraphLayout.CalculateEdgeLength(calls[i]) * 1.05, 2);
        }
    }

    [Fact]
    public void IncludeLoopCurvesAndArrowheadsInSceneBounds()
    {
        // Arrange
        var analysis = Analysis(Map(("Root", ["Left"]), ("Left", ["Left"])));

        // Act
        var scene = GraphLayout.Build(analysis);

        // Assert
        var loop = scene.Edges.Single(e => e.IsLoopback);
        scene.Bounds.Right.ShouldBeGreaterThan(scene.Nodes.Max(n => n.Bounds.Right));
        foreach (var node in scene.Nodes)
            scene.Bounds.Contains(node.Bounds).ShouldBeTrue();
        foreach (var edge in scene.Edges)
        {
            for (var i = 0; i <= 100; i++)
            {
                var t = i / 100d;
                var u = 1 - t;
                var point = new Point(
                    u * u * u * edge.Start.X
                        + 3 * u * u * t * edge.Control1.X
                        + 3 * u * t * t * edge.Control2.X
                        + t * t * t * edge.End.X,
                    u * u * u * edge.Start.Y
                        + 3 * u * u * t * edge.Control1.Y
                        + 3 * u * t * t * edge.Control2.Y
                        + t * t * t * edge.End.Y
                );
                scene.Bounds.Contains(new Rect(point, default(Size)).Inflate(edge.Thickness / 2)).ShouldBeTrue();
            }
            var direction = new Vector(edge.End.X - edge.Control2.X, edge.End.Y - edge.Control2.Y);
            direction /= direction.Length;
            var normal = new Vector(-direction.Y, direction.X);
            scene.Bounds.Contains(edge.End - direction * 13 + normal * 6).ShouldBeTrue();
            scene.Bounds.Contains(edge.End - direction * 13 - normal * 6).ShouldBeTrue();
        }
    }

    [Fact]
    public void PlaceLocalHelpersOnBothSidesRatherThanInTreeColumns()
    {
        // Arrange
        var analysis = Analysis(Map(("Root", ["Left", "Helper", "Right"])));

        // Act
        var scene = GraphLayout.Build(analysis);

        // Assert
        var edges = scene.Edges.ToArray();
        scene.Nodes.ShouldContain(node => node.Bounds.Center.Y > 0);
        scene.Nodes.ShouldContain(node => node.Bounds.Center.Y < 0);
        foreach (var edge in edges)
        {
            var delta = edge.Target.Bounds.Center - edge.Source.Bounds.Center;
            new Vector(delta.X, delta.Y).Length.ShouldBeGreaterThanOrEqualTo(209.9);
        }
        AssertNoOverlap(scene);
    }

    [Fact]
    public void PreserveIdenticalSourceMembersFromDifferentProjectCompilations()
    {
        // Arrange
        var tree = CSharpSyntaxTree.ParseText(
            "class Linked { void Shared(int value) { } }",
            path: "/project/Linked.cs"
        );
        var first = CSharpCompilation
            .Create("ProjectOne", [tree])
            .GetTypeByMetadataName("Linked")!
            .GetMembers("Shared")
            .Single();
        var second = CSharpCompilation
            .Create("ProjectTwo", [tree])
            .GetTypeByMetadataName("Linked")!
            .GetMembers("Shared")
            .Single();
        var analysis = Analysis(
            EmptyMap()
                .Add(
                    Symbol("Root"),
                    ImmutableList.Create(
                        new CallAnalysis(first, LinkKind.Direct, CallReach.CrossAssembly),
                        new CallAnalysis(second, LinkKind.Direct, CallReach.CrossAssembly)
                    )
                )
        );

        // Act
        var nodes = GraphLayout.Build(analysis).Nodes.Where(n => !n.IsOrigin).ToArray();

        // Assert
        nodes.Length.ShouldBe(2);
        nodes[0].Symbol.ShouldBeSameAs(first);
        nodes[1].Symbol.ShouldBeSameAs(second);
        nodes[0].Label.ShouldBe("Linked.Shared()");
        nodes[1].Label.ShouldBe(nodes[0].Label);
        nodes[0].SourceLink.ShouldStartWith("file:///project/Linked.cs#1:");
        nodes[1].SourceLink.ShouldBe(nodes[0].SourceLink);
        nodes.ShouldAllBe(n => !n.IsCycleReference);
    }

    [Fact]
    public void IncludeTheTypeWithoutParametersOrNamespacesAndPreserveSourceLinks()
    {
        // Arrange
        var tree = CSharpSyntaxTree.ParseText(
            "namespace Example { class Container { public string Root(int value, string text) => text; } }",
            path: "/project/Example.cs"
        );
        var compilation = CSharpCompilation.Create("Labels", [tree]);
        var symbol = compilation.GetTypeByMetadataName("Example.Container")!.GetMembers("Root").Single();
        var analysis = new CallGraphAnalysis(
            symbol,
            EmptyMap(),
            EmptyMap(),
            ImmutableDictionary.Create<ISymbol, uint>(SymbolEqualityComparer.Default)
        );

        // Act
        var node = GraphLayout.Build(analysis).Nodes.Single();

        // Assert
        node.Label.ShouldBe("Container.Root()");
        var start = tree.GetLineSpan(symbol.DeclaringSyntaxReferences[0].Span).StartLinePosition;
        node.SourceLink.ShouldBe($"file:///project/Example.cs#{start.Line + 1}:{start.Character + 1}");
        node.Label.ShouldNotContain("Example");
    }

    [Fact]
    public void QualifyConstructorsPropertiesAndIndexersWithAllContainingTypes()
    {
        // Arrange
        var tree = CSharpSyntaxTree.ParseText(
            """
            namespace Example
            {
                class Outer<T>
                {
                    class Middle
                    {
                        class Container<U>
                        {
                            public Container(int id) { }
                            public string Name { get; set; }
                            public string this[int index] => Name;
                            public void Run<V>(int value) { }
                            public void Run<V>(string value) { }
                        }
                    }
                }
            }
            """
        );
        var type = CSharpCompilation
            .Create("Members", [tree])
            .GetTypeByMetadataName("Example.Outer`1+Middle+Container`1")!;
        var members = new[]
        {
            type.InstanceConstructors.Single(),
            type.GetMembers("Name").Single(),
            type.GetMembers().OfType<IPropertySymbol>().Single(p => p.IsIndexer),
        }.Concat(type.GetMembers("Run"));

        // Act
        var labels = members
            .Select(symbol =>
                GraphLayout
                    .Build(
                        new CallGraphAnalysis(
                            symbol,
                            EmptyMap(),
                            EmptyMap(),
                            ImmutableDictionary.Create<ISymbol, uint>(SymbolEqualityComparer.Default)
                        )
                    )
                    .Nodes.Single()
                    .Label
            )
            .ToArray();

        // Assert
        labels.ShouldBe(
            new[]
            {
                "new Outer<T>.Middle.Container<U>()",
                "Outer<T>.Middle.Container<U>.Name",
                "Outer<T>.Middle.Container<U>.this[]",
                "Outer<T>.Middle.Container<U>.Run<V>()",
                "Outer<T>.Middle.Container<U>.Run<V>()",
            }
        );
    }

    [Fact]
    public void SupportDeepGraphsWithoutRecursiveTraversalOrHiddenDepthLimits()
    {
        // Arrange
        const int depth = 3000;
        var type = CreateType(Enumerable.Range(0, depth).Select(i => $"M{i}").ToArray());
        var symbols = Enumerable.Range(0, depth).Select(i => type.GetMembers($"M{i}").Single()).ToArray();
        var builder = ImmutableDictionary.CreateBuilder<ISymbol, IImmutableList<CallAnalysis>>(
            SymbolEqualityComparer.Default
        );
        for (var i = 0; i < depth - 1; i++)
            builder.Add(
                symbols[i],
                ImmutableList.Create(new CallAnalysis(symbols[i + 1], LinkKind.Direct, CallReach.SameType))
            );
        var analysis = new CallGraphAnalysis(
            symbols[0],
            builder.ToImmutable(),
            EmptyMap(),
            ImmutableDictionary.Create<ISymbol, uint>(SymbolEqualityComparer.Default)
        );

        // Act
        var scene = GraphLayout.Build(analysis);

        // Assert
        scene.Nodes.Count.ShouldBe(depth);
        scene.Edges.Count.ShouldBe(depth - 1);
        scene.Nodes[^1].Location.ShouldNotBe(scene.Nodes[^2].Location);
    }

    [Fact]
    public void HonorCancellation()
    {
        // Arrange
        var analysis = Analysis(Map(("Root", ["Left"])));
        using var cancellation = new CancellationTokenSource();
        cancellation.Cancel();

        // Act
        var build = () => GraphLayout.Build(analysis, cancellation.Token);

        // Assert
        build.ShouldThrow<OperationCanceledException>();
    }

    private static INamedTypeSymbol CreateType(params string[] methods)
    {
        var source = "class Methods { " + string.Join(" ", methods.Select(name => $"void {name}() {{ }}")) + " }";
        return CSharpCompilation
            .Create("GraphLayoutTests", [CSharpSyntaxTree.ParseText(source)])
            .GetTypeByMetadataName("Methods")!;
    }

    private static ISymbol Symbol(string name) => Type.GetMembers(name).Single();

    private static IImmutableDictionary<ISymbol, IImmutableList<CallAnalysis>> EmptyMap() =>
        ImmutableDictionary.Create<ISymbol, IImmutableList<CallAnalysis>>(SymbolEqualityComparer.Default);

    private static IImmutableDictionary<ISymbol, IImmutableList<CallAnalysis>> Map(
        params (string Source, string[] Targets)[] entries
    ) =>
        entries.Aggregate(
            EmptyMap(),
            (map, entry) =>
                map.Add(
                    Symbol(entry.Source),
                    entry
                        .Targets.Select(name => new CallAnalysis(Symbol(name), LinkKind.Direct, CallReach.SameType))
                        .ToImmutableList()
                )
        );

    private static CallGraphAnalysis Analysis(
        IImmutableDictionary<ISymbol, IImmutableList<CallAnalysis>> outgoing,
        IImmutableDictionary<ISymbol, IImmutableList<CallAnalysis>>? incoming = null
    ) =>
        new(
            Symbol("Root"),
            outgoing,
            incoming ?? EmptyMap(),
            ImmutableDictionary.Create<ISymbol, uint>(SymbolEqualityComparer.Default)
        );

    private static void AssertNoOverlap(GraphScene scene)
    {
        for (var i = 0; i < scene.Nodes.Count; i++)
        for (var j = i + 1; j < scene.Nodes.Count; j++)
            scene
                .Nodes[i]
                .Bounds.Intersects(scene.Nodes[j].Bounds)
                .ShouldBeFalse($"Nodes {scene.Nodes[i].Id} and {scene.Nodes[j].Id} overlap");
    }
}