using System.Collections.Immutable;
using System.Linq;
using UnitTestSharp;

namespace Vellum.Generator.UnitTests
{
    public class SaveEdgeTests : TestFixture
    {
        public static EquatableArray<string> Ids(params string[] ids)
        {
            return new EquatableArray<string>(ImmutableArray.Create(ids));
        }

        public static SaveEdge Variant(string caller = "M:Store.Put``1(``0)", string callee = "M:Saver.Put``1(``0)",
            int parameter = 0)
        {
            return new SaveEdge(Ids(caller), Ids(callee), new EquatableArray<SaveTemplate>(
                ImmutableArray.Create(SaveTemplate.OfParameter(parameter))));
        }

        public class CtorTests : TestFixture
        {
            public void KeepsEveryArgument()
            {
                SaveEdge edge = Variant();

                CheckEqual(1, edge.OwnCallerCount);

                CheckEqual(new[] { "M:Store.Put``1(``0)" }, edge.CallerIds.Items);
                CheckEqual(new[] { "M:Saver.Put``1(``0)" }, edge.CalleeIds.Items);
                CheckEqual(new[] { SaveTemplate.OfParameter(0) }, edge.Arguments.Items);
            }
        }

        public static EquatableArray<EquatableArray<int>> Maps(params int[][] maps)
        {
            return new EquatableArray<EquatableArray<int>>(ImmutableArray.CreateRange(
                maps.Select(map => new EquatableArray<int>(ImmutableArray.Create(map)))));
        }

        public static EquatableArray<EquatableArray<SaveTemplate>> ClassArguments(params SaveTemplate[][] arguments)
        {
            return new EquatableArray<EquatableArray<SaveTemplate>>(ImmutableArray.CreateRange(
                arguments.Select(list => new EquatableArray<SaveTemplate>(ImmutableArray.Create(list)))));
        }

        public static SaveEdge Full(EquatableArray<EquatableArray<int>> maps,
            EquatableArray<EquatableArray<SaveTemplate>> classArguments)
        {
            return new SaveEdge(Ids("C", "IC"), 1, maps, Ids("A"), classArguments,
                new EquatableArray<SaveTemplate>(ImmutableArray.Create(SaveTemplate.OfParameter(0))));
        }

        public class FullConstructorTests : TestFixture
        {
            public void KeepsTheMapsAndTheCalleesClassArguments()
            {
                SaveEdge edge = Full(Maps(new int[0], new[] { -1, 0 }),
                    ClassArguments(new[] { SaveTemplate.OfParameter(1) }));

                CheckEqual(new[] { -1, 0 }, edge.CallerClassMaps.Items[1].Items);
                CheckEqual(new[] { SaveTemplate.OfParameter(1) }, edge.CalleeClassArguments.Items[0].Items);
            }

            public void ShorterConstructors_LeaveThemEmpty()
            {
                SaveEdge edge = Variant();

                CheckEqual(0, edge.CallerClassMaps.Items.Length);
                CheckEqual(0, edge.CalleeClassArguments.Items.Length);
            }
        }

        public class MapAndClassArgumentEqualsTests : TestFixture
        {
            public void SameMapsAndClassArguments_AreEqual()
            {
                SaveEdge first = Full(Maps(new int[0], new[] { -1, 0 }),
                    ClassArguments(new[] { SaveTemplate.OfParameter(1) }));
                SaveEdge second = Full(Maps(new int[0], new[] { -1, 0 }),
                    ClassArguments(new[] { SaveTemplate.OfParameter(1) }));

                CheckTrue(first.Equals(second));
                CheckEqual(first.GetHashCode(), second.GetHashCode());
            }

            public void DifferentMap_IsNotEqual()
            {
                CheckFalse(Full(Maps(new int[0], new[] { -1, 0 }), default).Equals(
                    Full(Maps(new int[0], new[] { 0, -1 }), default)));
            }

            public void DifferentClassArguments_AreNotEqual()
            {
                CheckFalse(Full(default, ClassArguments(new[] { SaveTemplate.OfParameter(1) })).Equals(
                    Full(default, ClassArguments(new[] { SaveTemplate.OfClassParameter(1) }))));
            }
        }

        public class OwnCallerCountTests : TestFixture
        {
            public void ThreeArgumentConstructor_TakesEveryCallerIdAsTheCallers()
            {
                var edge = new SaveEdge(Ids("A", "B", "C"), Ids("D"), new EquatableArray<SaveTemplate>(
                    ImmutableArray.Create(SaveTemplate.OfParameter(0))));

                CheckEqual(3, edge.OwnCallerCount);
            }

            public void FourArgumentConstructor_KeepsTheCount()
            {
                var edge = new SaveEdge(Ids("A", "B"), 1, Ids("D"), new EquatableArray<SaveTemplate>(
                    ImmutableArray.Create(SaveTemplate.OfParameter(0))));

                CheckEqual(1, edge.OwnCallerCount);
            }
        }

        public class EqualsTests : TestFixture
        {
            public void DifferentOwnCallerCount_IsNotEqual()
            {
                var other = new SaveEdge(Ids("M:Store.Put``1(``0)"), 0, Ids("M:Saver.Put``1(``0)"),
                    new EquatableArray<SaveTemplate>(ImmutableArray.Create(SaveTemplate.OfParameter(0))));

                CheckFalse(Variant().Equals(other));
            }

            public void SameValues_AreEqual()
            {
                CheckTrue(Variant().Equals(Variant()));
                CheckTrue(Variant().Equals((object)Variant()));
            }

            public void Null_IsNotEqual()
            {
                CheckFalse(Variant().Equals((SaveEdge)null));
                CheckFalse(Variant().Equals((object)null));
            }

            public void DifferentCaller_IsNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(caller: "M:Other.Put``1(``0)")));
            }

            public void DifferentCallee_IsNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(callee: "M:Other.Put``1(``0)")));
            }

            public void DifferentArguments_AreNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(parameter: 1)));
            }
        }

        public class GetHashCodeTests : TestFixture
        {
            public void EqualEdges_HaveEqualHashCodes()
            {
                CheckEqual(Variant().GetHashCode(), Variant().GetHashCode());
            }
        }
    }
}