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

namespace Ariadne.UnitTests
{
    public class ConditionTests : TestFixture
    {
        /// <summary>
        /// A condition that is always set and leaves what it contradicts to the base.
        /// </summary>
        public class AlwaysSet : Condition
        {
            public override bool IsSet => true;
        }

        public class ContradictsTests : TestFixture
        {
            public void ConditionThatDoesNotOverrideIt_ContradictsNothing()
            {
                var condition = new AlwaysSet();

                CheckFalse(condition.Contradicts(condition));
                CheckFalse(condition.Contradicts(new AlwaysSet()));
                CheckFalse(condition.Contradicts(new Latch()));
            }
        }

        public class WakeWaitersTests : TestFixture
        {
            private List<int> woken;
            private Latch door;
            private Latch alarm;

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

            public void NothingWaiting_DoesNothing()
            {
                door.WakeWaiters();

                CheckEqual(0, woken.Count);
            }

            public void WakesTheArcsInTheOrderTheyWereAddedToTheirScheduler()
            {
                LatchTests.WaitOn(woken, order: 2, door);
                LatchTests.WaitOn(woken, order: 0, door);
                LatchTests.WaitOn(woken, order: 1, door);

                door.WakeWaiters();

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

            public void KeepsTheSubscriptions()
            {
                LatchTests.WaitOn(woken, order: 0, door);

                door.WakeWaiters();

                CheckEqual(1, door.SubscriptionCount);
            }

            public void WakesTheSameArcAgainOnTheNextCall()
            {
                LatchTests.WaitOn(woken, order: 4, door);

                door.WakeWaiters();
                door.WakeWaiters();

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

            public void WaitForEveryOneThatIsNotMet_StaysAsleep()
            {
                LatchTests.WaitOn(woken, order: 0, tag: 0, requiresAll: true, door, alarm);

                door.WakeWaiters();

                CheckEqual(0, woken.Count);
            }

            public void WaitForEveryOneThatIsMet_WakesOnceTheLastIsSet()
            {
                LatchTests.WaitOn(woken, order: 0, tag: 0, requiresAll: true, door, alarm);

                alarm.Set();

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

            public void WaitThatBeganAgain_IsNotWokenForItsEarlierConditions()
            {
                TriggerWait wait = LatchTests.WaitOn(woken, order: 0, door);
                wait.Begin(new Frame { Wake = wait.Slot }, requiresAll: false);
                wait.Add(alarm);

                door.WakeWaiters();

                CheckEqual(0, woken.Count);
            }

            public void WaitThatWasFinished_IsNotWoken()
            {
                TriggerWait wait = LatchTests.WaitOn(woken, order: 0, door);
                wait.Finish();

                door.WakeWaiters();

                CheckEqual(0, woken.Count);
            }

            public void FinishedWait_IsSweptFromTheSubscriptions()
            {
                LatchTests.WaitOn(woken, order: 0, door).Finish();

                door.WakeWaiters();

                CheckEqual(0, door.SubscriptionCount);
            }

            public void ArcThatWasDropped_IsNotWoken()
            {
                LatchTests.WaitOn(woken, order: 0, door).Slot.Dropped = true;

                door.WakeWaiters();

                CheckEqual(0, woken.Count);
            }

            public void WaitWhoseArcIsNotHeldByAScheduler_Throws()
            {
                LatchTests.WaitOn(woken, order: 0, door).Slot = null;

                CheckThrow(typeof(InvalidOperationException));
                door.WakeWaiters();
            }

            public void LatchSetAgainAfterBeingCleared_WakesTheArcAgain()
            {
                LatchTests.WaitOn(woken, order: 6, alarm);
                alarm.Set();
                alarm.Clear();

                alarm.Set();

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