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

namespace Ariadne.Generator.UnitTests
{
    public class ArcOutputTests : TestFixture
    {
        public const string Class = "partial class A\r\n{\r\n}\r\n";

        public static EquatableArray<DiagnosticData> Problems(params DiagnosticData[] problems)
        {
            return new EquatableArray<DiagnosticData>(problems.ToImmutableArray());
        }

        /// <summary>
        /// Returns an output that differs from the default one only in the arguments given.
        /// </summary>
        public static ArcOutput Variant(string filePath = "A.cs", string typeName = "A", int start = 1,
            string[] usings = null, string classText = Class, DiagnosticData[] classProblems = null,
            DiagnosticData[] scriptProblems = null)
        {
            return new ArcOutput(filePath, typeName, SourcePlaceTests.Variant(filePath: filePath, start: start),
                new EquatableArray<string>((usings ?? new[] { "using System;" }).ToImmutableArray()), classText,
                Problems(classProblems ?? new DiagnosticData[0]), Problems(scriptProblems ?? new DiagnosticData[0]));
        }

        public class CtorTests : TestFixture
        {
            public void KeepsEveryArgument()
            {
                DiagnosticData classProblem = DiagnosticDataTests.Variant(message: "class");
                DiagnosticData scriptProblem = DiagnosticDataTests.Variant(message: "script");
                ArcOutput output = Variant(classProblems: new[] { classProblem },
                    scriptProblems: new[] { scriptProblem });

                CheckEqual("A.cs", output.FilePath);
                CheckEqual("A", output.TypeName);
                CheckEqual(SourcePlaceTests.Variant(filePath: "A.cs"), output.TypePlace);
                CheckEqual(new[] { "using System;" }, output.FileUsings.Items.ToArray());
                CheckEqual(Class, output.ClassText);
                CheckEqual(classProblem, output.ClassProblems.Items.Single());
                CheckEqual(scriptProblem, output.ScriptProblems.Items.Single());
            }
        }

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

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

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

            public void DifferentFilePath_IsNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(filePath: "B.cs")));
            }

            public void DifferentTypeName_IsNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(typeName: "B")));
            }

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

            public void DifferentFileUsings_AreNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(usings: new[] { "using System.Linq;" })));
            }

            public void DifferentClassText_IsNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(classText: "partial class B\r\n{\r\n}\r\n")));
            }

            public void NoClassTextOnOneSideOnly_IsNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(classText: null)));
                CheckFalse(Variant(classText: null).Equals(Variant()));
                CheckTrue(Variant(classText: null).Equals(Variant(classText: null)));
            }

            public void DifferentClassProblems_AreNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(classProblems: new[] { DiagnosticDataTests.Variant() })));
            }

            public void DifferentScriptProblems_AreNotEqual()
            {
                CheckFalse(Variant().Equals(Variant(scriptProblems: new[] { DiagnosticDataTests.Variant() })));
            }
        }

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