using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using UnitTestSharp;

namespace Vellum.Generator.UnitTests
{
    public class SaveableMarkTests : TestFixture
    {
        public static SaveableMark Variant(string name = "ItemType", string owner = "Holder",
            SaveableMark.Problems problem = SaveableMark.Problems.NotAConverter, SourcePlace place = null)
        {
            return new SaveableMark(name, owner, problem, place ?? SourcePlaceTests.Variant());
        }

        public class CtorTests : TestFixture
        {
            public void KeepsEveryArgument()
            {
                SaveableMark mark = Variant(problem: SaveableMark.Problems.FamilySubject);

                CheckEqual("ItemType", mark.Name);
                CheckEqual("Holder", mark.Owner);
                CheckEqual(SaveableMark.Problems.FamilySubject, mark.Problem);
                CheckEqual(SourcePlaceTests.Variant(), mark.Place);
            }
        }

        public class OfTests : TestFixture
        {
            public static SaveableMark Marked(string source, string typeName)
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs", source));
                INamedTypeSymbol type = compilation.GetTypeByMetadataName(typeName);
                INamedTypeSymbol converterBase = compilation.GetTypeByMetadataName(ConverterScan.ConverterMetadataName);

                return SaveableMark.Of(type.TypeParameters[0], converterBase);
            }

            public void ParameterOfAConverter_IsFine()
            {
                CheckNull(Marked(ConverterScanTests.Box + ConverterScanTests.Converter("BoxConverter<ItemType>",
                    "Box<ItemType>"), "BoxConverter`1"));
            }

            public void ParameterOfAClassThatIsNotAConverter_IsNotAConverter()
            {
                SaveableMark mark = Marked("public class Holder<[Saveable] ItemType> { }", "Holder`1");

                CheckEqual(SaveableMark.Problems.NotAConverter, mark.Problem);
                CheckEqual("ItemType", mark.Name);
                CheckEqual("Holder", mark.Owner);
            }

            public void ParameterAFamilyStandsFor_IsTheFamilySubject()
            {
                SaveableMark mark = Marked(ConverterScanTests.DescribeTests.Creature + ConverterScanTests.Family(
                    "CreatureConverter<[Saveable] CreatureType>", "CreatureType", "Creature"), "CreatureConverter`1");

                CheckEqual(SaveableMark.Problems.FamilySubject, mark.Problem);
            }

            public void ParameterOfAMethod_IsNotAConverter()
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs",
                    "public class Helper { public void Use<[Saveable] ItemType>() { } }"));
                var method = (IMethodSymbol)compilation.GetTypeByMetadataName("Helper").GetMembers("Use")[0];
                INamedTypeSymbol converterBase = compilation.GetTypeByMetadataName(ConverterScan.ConverterMetadataName);

                CheckEqual(SaveableMark.Problems.NotAConverter,
                    SaveableMark.Of(method.TypeParameters[0], converterBase).Problem);
                CheckEqual("Use", SaveableMark.Of(method.TypeParameters[0], converterBase).Owner);
            }
        }

        public class ToDiagnosticTests : TestFixture
        {
            public void NotAConverter_IsVEL0012()
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs", ""));

                Diagnostic diagnostic = Variant().ToDiagnostic(compilation);

                CheckEqual("VEL0012", diagnostic.Id);
                CheckTrue(diagnostic.GetMessage().StartsWith("'ItemType' of 'Holder' is marked [Saveable]"));
            }

            public void FamilySubject_IsVEL0013()
            {
                CSharpCompilation compilation = VellumRun.Compile(("Source.cs", ""));

                CheckEqual("VEL0013",
                    Variant(problem: SaveableMark.Problems.FamilySubject).ToDiagnostic(compilation).Id);
            }
        }

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

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

            public void DifferentName_IsNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(name: "Other")));
            }

            public void DifferentOwner_IsNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(owner: "Other")));
            }

            public void DifferentProblem_IsNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(problem: SaveableMark.Problems.FamilySubject)));
            }

            public void DifferentPlace_IsNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(place: SourcePlaceTests.Variant(start: 2))));
            }
        }

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