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

namespace Vellum.Generator.UnitTests
{
    public class ConverterListTests : TestFixture
    {
        public static EquatableArray<ConverterModel> Named(string name)
        {
            return new EquatableArray<ConverterModel>(ImmutableArray.Create(ConverterModelTests.Variant(name: name)));
        }

        public static ConverterList Of(string usableName, string problemName)
        {
            return new ConverterList(Named(usableName), Named(problemName));
        }

        public class CtorTests : TestFixture
        {
            public void KeepsBothLists()
            {
                ConverterList list = Of("Good", "Bad");

                CheckEqual("Good", list.Usable.Items[0].Name);
                CheckEqual("Bad", list.Problems.Items[0].Name);
            }
        }

        public class ConvertedNamesTests : TestFixture
        {
            public void UsableConvertersOnly_AreNamedByWhatTheyConvert()
            {
                var list = new ConverterList(
                    new EquatableArray<ConverterModel>(ImmutableArray.Create(
                        ConverterModelTests.Variant(name: "Good", convertedName: "Point"),
                        ConverterModelTests.Variant(name: "Box", convertedName: "Box<ItemType>"))),
                    Named("Bad"));

                CheckEqual(new[] { "Box<ItemType>", "Point" },
                    list.ConvertedNames().OrderBy(name => name, System.StringComparer.Ordinal).ToArray());
            }

            public void NoConverters_NamesNothing()
            {
                var list = new ConverterList(new EquatableArray<ConverterModel>(),
                    new EquatableArray<ConverterModel>());

                CheckEqual(0, list.ConvertedNames().Count);
            }

            public void Family_IsNotCountedAsConvertingItsBaseClass()
            {
                ConverterList list = FamilyList();

                CheckEqual(new[] { "Point" }, list.ConvertedNames().ToArray());
            }
        }

        public static ConverterList FamilyList()
        {
            return new ConverterList(
                new EquatableArray<ConverterModel>(ImmutableArray.Create(
                    ConverterModelTests.Variant(name: "Good", convertedName: "Point"),
                    ConverterModelTests.Variant(name: "Family", convertedName: "type derived from Creature",
                        familyBase: "Creature"))),
                Named("Bad"));
        }

        public class SaveableArgumentsTests : TestFixture
        {
            public void UsableConverters_AreListedWithTheirMarkedPositionsByWhatTheyConvert()
            {
                var list = new ConverterList(
                    new EquatableArray<ConverterModel>(ImmutableArray.Create(
                        ConverterModelTests.Variant(name: "Box", convertedName: "Box<ItemType>",
                            saveablePositions: new[] { 0 }),
                        ConverterModelTests.Variant(name: "Good", convertedName: "Point"))),
                    Named("Bad"));
                Dictionary<string, EquatableArray<int>> arguments = list.SaveableArguments();

                CheckEqual(new[] { 0 }, arguments["Box<ItemType>"].Items.ToArray());
                CheckEqual(0, arguments["Point"].Items.Length);
                CheckEqual(2, arguments.Count);
            }

            public void Family_IsNotListed()
            {
                CheckFalse(FamilyList().SaveableArguments().ContainsKey("type derived from Creature"));
            }
        }

        public class InterfaceFamiliesTests : TestFixture
        {
            public void UsableInterfaceFamiliesOnly_AreListedWithTheInterfacesTheyExtend()
            {
                var list = new ConverterList(
                    new EquatableArray<ConverterModel>(ImmutableArray.Create(
                        ConverterModelTests.Variant(name: "Dog", familyBase: "IDog", familyIsInterface: true,
                            familyExtends: new[] { "IPet" }),
                        ConverterModelTests.Variant(name: "Creature", familyBase: "Creature"),
                        ConverterModelTests.Variant(name: "Good", convertedName: "Point"))),
                    Named("Bad"));
                Dictionary<string, EquatableArray<string>> families = list.InterfaceFamilies();

                CheckEqual(new[] { "IDog" }, families.Keys.ToArray());
                CheckEqual(new[] { "IPet" }, families["IDog"].Items.ToArray());
            }
        }

        public class InterfaceFamilyAssembliesTests : TestFixture
        {
            public void UsableInterfaceFamiliesOnly_NameTheirInterfacesAssemblies()
            {
                var list = new ConverterList(
                    new EquatableArray<ConverterModel>(ImmutableArray.Create(
                        ConverterModelTests.Variant(name: "Pet", familyBase: "IPet", familyIsInterface: true,
                            familyBaseAssembly: "Pets"),
                        ConverterModelTests.Variant(name: "Dog", familyBase: "IDog", familyIsInterface: true,
                            familyBaseAssembly: "Pets"),
                        ConverterModelTests.Variant(name: "Fish", familyBase: "IFish", familyIsInterface: true,
                            familyBaseAssembly: "Aquarium"),
                        ConverterModelTests.Variant(name: "Creature", familyBase: "Creature",
                            familyBaseAssembly: "Zoo"),
                        ConverterModelTests.Variant(name: "Good", convertedName: "Point"))),
                    Named("Bad"));

                CheckEqual(new[] { "Aquarium", "Pets" },
                    list.InterfaceFamilyAssemblies().OrderBy(name => name, System.StringComparer.Ordinal).ToArray());
            }

            public void NoInterfaceFamilies_NamesNothing()
            {
                CheckEqual(0, FamilyList().InterfaceFamilyAssemblies().Count);
            }
        }

        public class FamilyBaseNamesTests : TestFixture
        {
            public void UsableFamiliesOnly_AreNamedByTheirBaseClass()
            {
                CheckEqual(new[] { "Creature" }, FamilyList().FamilyBaseNames().Keys.ToArray());
            }

            public void NoFamilies_NamesNothing()
            {
                CheckEqual(0, Of("Good", "Bad").FamilyBaseNames().Count);
            }
        }

        public class EqualsTests : TestFixture
        {
            public void SameLists_AreEqual()
            {
                CheckTrue(Of("Good", "Bad").Equals(Of("Good", "Bad")));
                CheckTrue(Of("Good", "Bad").Equals((object)Of("Good", "Bad")));
            }

            public void DifferentUsable_IsNotEqual()
            {
                CheckFalse(Of("Good", "Bad").Equals(Of("Other", "Bad")));
            }

            public void DifferentProblems_AreNotEqual()
            {
                CheckFalse(Of("Good", "Bad").Equals(Of("Good", "Other")));
            }

            public void Null_IsNotEqual()
            {
                CheckFalse(Of("Good", "Bad").Equals((ConverterList)null));
                CheckFalse(Of("Good", "Bad").Equals((object)null));
            }
        }

        public class GetHashCodeTests : TestFixture
        {
            public void EqualLists_HaveEqualHashCodes()
            {
                CheckEqual(Of("Good", "Bad").GetHashCode(), Of("Good", "Bad").GetHashCode());
            }
        }
    }
}