using UnitTestSharp;

namespace Vellum.Generator.UnitTests
{
    public class InheritorTests : TestFixture
    {
        public const string Zoo = @"
[Saveable] public abstract partial class Animal { public string Name; }
public partial class Wolf : Animal { }
public class Plain { }
public class Hound : Plain { }
[Saveable] public sealed partial class Dog : Animal { }";

        public static Inheritor Variant(SaveableModel model = null, UnsavedSubtype subtype = null)
        {
            return new Inheritor(model, subtype);
        }

        public static Inheritor InheritorOf(string metadataName, string source)
        {
            return Inheritor.Of(SaveableClassTests.TypeOf(metadataName, source));
        }

        public class CtorTests : TestFixture
        {
            public void KeepsEveryArgument()
            {
                SaveableModel model = SaveableClassTests.Described("Dog", Zoo);
                UnsavedSubtype subtype = UnsavedSubtypeTests.Variant();
                Inheritor inheritor = Variant(model, subtype);

                CheckEqual(model, inheritor.Model);
                CheckEqual(subtype, inheritor.Subtype);
            }
        }

        public class OfTests : TestFixture
        {
            public void ClassBelowAMarkedOne_IsItsModel()
            {
                Inheritor inheritor = InheritorOf("Wolf", Zoo);

                CheckEqual("Wolf", inheritor.Model.Checks.Name);
                CheckNull(inheritor.Subtype);
            }

            public void ClassBelowAnUnmarkedOne_IsASubtypeToCheck()
            {
                Inheritor inheritor = InheritorOf("Hound", Zoo);

                CheckNull(inheritor.Model);
                CheckEqual("Hound", inheritor.Subtype.Name);
            }

            public void ClassSayingItIsMarked_IsLeftToTheAttribute()
            {
                CheckNull(InheritorOf("Dog", Zoo));
            }

            public void ClassWithNothingToCheck_IsNull()
            {
                CheckNull(InheritorOf("Plain", Zoo));
            }
        }

        public class EqualsTests : TestFixture
        {
            public void SameValues_AreEqual()
            {
                CheckTrue(Variant(subtype: UnsavedSubtypeTests.Variant())
                    .Equals(Variant(subtype: UnsavedSubtypeTests.Variant())));
                CheckTrue(Variant(subtype: UnsavedSubtypeTests.Variant())
                    .Equals((object)Variant(subtype: UnsavedSubtypeTests.Variant())));
            }

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

            public void OtherType_IsNotEqual()
            {
                CheckFalse(Variant().Equals("Dog"));
            }

            public void DifferentModel_IsNotEqual()
            {
                CheckFalse(Variant(SaveableClassTests.Described("Dog", Zoo))
                    .Equals(Variant(SaveableClassTests.Described("Wolf", Zoo))));
            }

            public void DifferentSubtype_IsNotEqual()
            {
                CheckFalse(Variant(subtype: UnsavedSubtypeTests.Variant())
                    .Equals(Variant(subtype: UnsavedSubtypeTests.Variant(name: "Cat"))));
            }
        }

        public class GetHashCodeTests : TestFixture
        {
            public void EqualInheritors_HaveEqualHashCodes()
            {
                SaveableModel model = SaveableClassTests.Described("Dog", Zoo);

                CheckEqual(Variant(model).GetHashCode(), Variant(model).GetHashCode());
                CheckEqual(Variant(subtype: UnsavedSubtypeTests.Variant()).GetHashCode(),
                    Variant(subtype: UnsavedSubtypeTests.Variant()).GetHashCode());
            }

            public void NeitherModelNorSubtype_HasAHashCode()
            {
                CheckEqual(Variant().GetHashCode(), Variant().GetHashCode());
            }
        }
    }
}