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

namespace Ariadne.Generator.UnitTests
{
    public class DiagnosticDataTests : TestFixture
    {
        public static readonly DiagnosticDescriptor Warning = new DiagnosticDescriptor(
            "TST0001", "A test warning", "'{0}' is a test warning", "Test", DiagnosticSeverity.Warning,
            isEnabledByDefault: true, description: "More on the test warning", helpLinkUri: "http://example.com/tst");

        public static readonly CSharpCompilation Compilation =
            GeneratorRun.Compile(("Source.cs", "public class Foo { }"));

        public static DiagnosticData Variant(DiagnosticDescriptor descriptor = null, string message = "Message",
            string filePath = "File.cs", int start = 1)
        {
            return new DiagnosticData(descriptor ?? ScriptDiagnostics.NotPartial, message,
                SourcePlaceTests.Variant(filePath: filePath, start: start));
        }

        public class CtorTests : TestFixture
        {
            public void KeepsEveryArgument()
            {
                DiagnosticData data = Variant();

                CheckTrue(data.Descriptor == ScriptDiagnostics.NotPartial);
                CheckEqual("Message", data.Message);
                CheckEqual(SourcePlaceTests.Variant(), data.Place);
            }
        }

        public class CreateTests : TestFixture
        {
            public void Descriptor_HasItsArgumentsFilledInAtThePlace()
            {
                DiagnosticData data = DiagnosticData.Create(ScriptDiagnostics.NotPartial, SourcePlaceTests.Variant(),
                    "Foo");

                CheckTrue(data.Descriptor == ScriptDiagnostics.NotPartial);
                CheckTrue(data.Message.StartsWith("'Foo' overrides Arc.Run"));
                CheckEqual(SourcePlaceTests.Variant(), data.Place);
            }
        }

        public class OfTests : TestFixture
        {
            public void Diagnostic_KeepsItsDescriptorFilledInMessageAndPlace()
            {
                INamedTypeSymbol type = Compilation.GetTypeByMetadataName("Foo");
                Diagnostic diagnostic = Diagnostic.Create(ScriptDiagnostics.NotPartial, type.Locations[0], "Foo");
                DiagnosticData data = DiagnosticData.Of(diagnostic);

                CheckTrue(data.Descriptor == ScriptDiagnostics.NotPartial);
                CheckEqual(diagnostic.GetMessage(), data.Message);
                CheckEqual(SourcePlace.Of(type.Locations[0]), data.Place);
            }
        }

        public class ToDiagnosticTests : TestFixture
        {
            public void Error_IsTheSameDiagnosticAtItsPlaceInTheCompilation()
            {
                INamedTypeSymbol type = Compilation.GetTypeByMetadataName("Foo");
                Diagnostic original = Diagnostic.Create(ScriptDiagnostics.NotPartial, type.Locations[0], "Foo");
                Diagnostic diagnostic = DiagnosticData.Of(original).ToDiagnostic(Compilation);

                CheckEqual("ARI0001", diagnostic.Id);
                CheckEqual(original.GetMessage(), diagnostic.GetMessage());
                CheckEqual(DiagnosticSeverity.Error, diagnostic.Severity);
                CheckEqual(0, diagnostic.WarningLevel);
                CheckTrue(diagnostic.Location.SourceTree == type.Locations[0].SourceTree);
                CheckEqual(type.Locations[0].SourceSpan, diagnostic.Location.SourceSpan);
            }

            public void Warning_KeepsItsSeverityAndDescriptorDetails()
            {
                Diagnostic diagnostic = Variant(Warning, "'x' is a test warning").ToDiagnostic(Compilation);

                CheckEqual(DiagnosticSeverity.Warning, diagnostic.Severity);
                CheckEqual(1, diagnostic.WarningLevel);
                CheckEqual("A test warning", diagnostic.Descriptor.Title.ToString());
                CheckEqual("More on the test warning", diagnostic.Descriptor.Description.ToString());
                CheckEqual("http://example.com/tst", diagnostic.Descriptor.HelpLinkUri);
                CheckEqual("'x' is a test warning", diagnostic.GetMessage());
            }

            public void PlaceWithNoFile_HasNoLocation()
            {
                Diagnostic diagnostic = DiagnosticData.Of(Diagnostic.Create(ScriptDiagnostics.NotPartial,
                    Location.None, "Foo")).ToDiagnostic(Compilation);

                CheckEqual(Location.None, diagnostic.Location);
            }
        }

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

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

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

            public void DifferentDescriptor_IsNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(descriptor: ScriptDiagnostics.NotPartialContainer)));
            }

            public void DifferentMessage_IsNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(message: "Other")));
            }

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

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