using System;
using System.Linq;
using UnitTestSharp;

namespace Amphora.UnitTests
{
    public class StatusTests : TestFixture
    {
        public class LayoutTests : TestFixture
        {
            public void IsThreeFlatFields()
            {
                var fields = FlatLayout.InstanceFields(typeof(Status));

                CheckEqual(3, fields.Length);
                CheckTrue(fields.All(FlatLayout.IsFlat));
            }
        }

        public class EqualityTests : EqualityTestFixture<Status>
        {
            public EqualityTests() : base(Status.FromWire(FailureTestKinds.Unreachable, reference: "ref", bits: 5))
            {
            }
        }

        public class EqualsTests : TestFixture
        {
            public void EqualStringRefs_AreEqualEvenAsDifferentInstances()
            {
                string reference = "ref";
                string copy = new string(reference.ToCharArray());

                CheckEqual(
                    Status.FromWire(FailureTestKinds.Unreachable, reference, bits: 5),
                    Status.FromWire(FailureTestKinds.Unreachable, copy, bits: 5));
            }
        }

        public class GetHashCodeTests : TestFixture
        {
            public void EqualStatuses_HashTheSame()
            {
                string reference = "ref";
                string copy = new string(reference.ToCharArray());

                CheckEqual(
                    Status.FromWire(FailureTestKinds.Unreachable, reference, bits: 5).GetHashCode(),
                    Status.FromWire(FailureTestKinds.Unreachable, copy, bits: 5).GetHashCode());
            }

            public void Ok_HashesWithoutThrowing()
            {
                Status.Ok.GetHashCode();
            }
        }

        public class OperatorEqualsTests : TestFixture
        {
            public void EqualStatuses_AreEqual()
            {
                Status status = FailureTestKinds.Unreachable.Fail();

                CheckTrue(status == FailureTestKinds.Unreachable.Fail());
                CheckFalse(status != FailureTestKinds.Unreachable.Fail());
            }

            public void DifferentStatuses_AreNotEqual()
            {
                Status status = FailureTestKinds.Unreachable.Fail();

                CheckFalse(status == Status.Ok);
                CheckTrue(status != Status.Ok);
            }
        }

        public class OkTests : TestFixture
        {
            public void IsTheDefault()
            {
                CheckEqual(default(Status), Status.Ok);
            }
        }

        public class IsOkTests : TestFixture
        {
            public void Ok_IsTrue()
            {
                CheckTrue(Status.Ok.IsOk);
            }

            public void Failed_IsFalse()
            {
                CheckFalse(FailureTestKinds.Unreachable.Fail().IsOk);
            }
        }

        public class OkWireIdTests : TestFixture
        {
            public void IsZero()
            {
                CheckEqual(0UL, Status.OkWireId);
            }
        }

        public class WireIdTests : TestFixture
        {
            public void Ok_IsOkWireId()
            {
                CheckEqual(Status.OkWireId, Status.Ok.WireId);
            }

            public void Failed_IsTheKindsId()
            {
                CheckEqual(BlockedCellKind.Instance.Id, BlockedCellKind.Instance.Fail(FailureTestKinds.Wall).WireId);
            }
        }

        public class WireRefTests : TestFixture
        {
            public void Ok_IsNull()
            {
                CheckNull(Status.Ok.WireRef);
            }

            public void String_IsTheRef()
            {
                CheckEqual("a wall", BlockedCellKind.Instance.Fail(FailureTestKinds.Wall).WireRef);
            }

            public void ObjectTheKindRefuses_IsNull()
            {
                Status status = Status.FromWire(FailureTestKinds.Unreachable, reference: new object(), bits: 0);

                CheckNull(status.WireRef);
            }

            public void ObjectTheKindAccepts_IsTheRef()
            {
                var reference = new object();
                Status status = Status.FromWire(new HeapRefKind(), reference, bits: 0);

                CheckEqual(reference, status.WireRef);
            }
        }

        public class FromWireTests : TestFixture
        {
            public void KeepsEveryPart()
            {
                Status status = Status.FromWire(FailureTestKinds.Unreachable, reference: "ref", bits: -5);

                CheckEqual(FailureTestKinds.Unreachable, status.Kind);
                CheckEqual("ref", status.Ref);
                CheckEqual(-5L, status.Bits);
            }

            public void NullKind_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                Status.FromWire(kind: null, reference: null, bits: 0);
            }
        }

        public class DescribeTests : TestFixture
        {
            public void AsksTheKindWithTheContext()
            {
                Status status = BlockedCellKind.Instance.Fail(FailureTestKinds.Wall);

                CheckEqual("The pawn can't reach (-3, 7) past a wall.", status.Describe("The pawn"));
            }

            public void NoContext_PassesNull()
            {
                Status status = BlockedCellKind.Instance.Fail(FailureTestKinds.Wall);

                CheckEqual(" can't reach (-3, 7) past a wall.", status.Describe());
            }

            public void Ok_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                Status.Ok.Describe();
            }
        }
    }
}