using System;
using System.Collections.Generic;
using UnitTestSharp;

namespace Ariadne.UnitTests
{
    public class LatchTests : TestFixture
    {
        /// <summary>
        /// Returns a wait on <paramref name="conditions"/> for an arc that logs <paramref name="tag"/> when woken.
        /// </summary>
        public static TriggerWait WaitOn(List<int> woken, int order, int tag, bool requiresAll,
            params Condition[] conditions)
        {
            var returnMe = new TriggerWait(capacity: Math.Max(1, conditions.Length), onConditions: true);
            returnMe.Begin(new Frame { Wake = new RecordingSlot(woken, order, tag) }, requiresAll);
            foreach (Condition condition in conditions)
            {
                returnMe.Add(condition);
            }

            return returnMe;
        }

        public static TriggerWait WaitOn(List<int> woken, int order, params Condition[] conditions)
        {
            return WaitOn(woken, order, tag: order, requiresAll: false, conditions: conditions);
        }

        public class CtorTests : TestFixture
        {
            public void ByDefault_StartsClear()
            {
                CheckFalse(new Latch().IsSet);
            }

            public void InitiallySet_StartsSet()
            {
                CheckTrue(new Latch(initiallySet: true).IsSet);
            }

            public void MakesItsInverse()
            {
                var latch = new Latch();

                CheckTrue(ReferenceEquals(latch, latch.Inverse.Original));
            }
        }

        public class SetTests : TestFixture
        {
            private List<int> woken;
            private Latch latch;

            public override void TestSetup()
            {
                woken = new List<int>();
                latch = new Latch();
            }

            public void MakesTheLatchSet()
            {
                latch.Set();

                CheckTrue(latch.IsSet);
            }

            public void WakesTheArcsWaitingForTheLatch()
            {
                WaitOn(woken, order: 3, latch);

                latch.Set();

                CheckEqual(new[] { 3 }, woken.ToArray());
            }

            public void LatchThatIsAlreadySet_WakesNobody()
            {
                var set = new Latch(initiallySet: true);
                WaitOn(woken, order: 0, set);

                set.Set();

                CheckEqual(0, woken.Count);
            }

            public void DoesNotWakeTheArcsWaitingForTheInverse()
            {
                WaitOn(woken, order: 0, latch.Inverse);

                latch.Set();

                CheckEqual(0, woken.Count);
            }
        }

        public class ClearTests : TestFixture
        {
            private List<int> woken;
            private Latch latch;

            public override void TestSetup()
            {
                woken = new List<int>();
                latch = new Latch(initiallySet: true);
            }

            public void MakesTheLatchClear()
            {
                latch.Clear();

                CheckFalse(latch.IsSet);
            }

            public void WakesTheArcsWaitingForTheInverse()
            {
                WaitOn(woken, order: 2, latch.Inverse);

                latch.Clear();

                CheckEqual(new[] { 2 }, woken.ToArray());
            }

            public void LatchThatIsAlreadyClear_WakesNobody()
            {
                var clear = new Latch();
                WaitOn(woken, order: 0, clear.Inverse);

                clear.Clear();

                CheckEqual(0, woken.Count);
            }

            public void DoesNotWakeTheArcsWaitingForTheLatch()
            {
                WaitOn(woken, order: 0, latch);

                latch.Clear();

                CheckEqual(0, woken.Count);
            }
        }

        public class ContradictsTests : TestFixture
        {
            public void Inverse_IsContradicted()
            {
                var latch = new Latch();

                CheckTrue(latch.Contradicts(latch.Inverse));
            }

            public void ItselfAndOtherConditions_AreNot()
            {
                var latch = new Latch();

                CheckFalse(latch.Contradicts(latch));
                CheckFalse(latch.Contradicts(new Latch()));
                CheckFalse(latch.Contradicts(new Latch().Inverse));
            }
        }

        public class NotOperatorTests : TestFixture
        {
            public void ReturnsTheInverse()
            {
                var latch = new Latch();

                CheckTrue(ReferenceEquals(latch.Inverse, !latch));
            }

            public void NullLatch_Throws()
            {
                Latch latch = null;

                CheckThrow(typeof(ArgumentNullException));
                InvertedLatch ignored = !latch;
            }
        }
    }
}