using System.IO;
using UnitTestSharp;
using Vellum;

namespace Ariadne.Vellum.UnitTests
{
    public class LatchConverterTests : TestFixture
    {
        /// <summary>
        /// Returns a begun wait of <paramref name="capacity"/> on <paramref name="conditions"/>.
        /// </summary>
        public static TriggerWait WaitOn(int capacity, bool requiresAll, params Condition[] conditions)
        {
            var returnMe = new TriggerWait(capacity, onConditions: true);
            returnMe.Begin(new Frame { Wake = new WakeSlot() }, requiresAll);
            foreach (Condition condition in conditions)
            {
                returnMe.Add(condition);
            }

            return returnMe;
        }

        public class FromNodeTests : TestFixture
        {
            [IgnoreTest]
            public Latch Reload(Latch latch)
            {
                SaveSession session = ArcConverterTests.Session();
                return (Latch)session.FromNode(session.ToNode(latch, typeof(Latch)), typeof(Latch));
            }

            [IgnoreTest]
            public SaveNode Saved(Latch latch, SaveSession session)
            {
                return session.ToNode(latch, typeof(Latch)).Resolved;
            }

            public void ClearLatch_LoadsClear()
            {
                CheckFalse(Reload(new Latch()).IsSet);
            }

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

            public void LatchWithNoSubscriptions_LoadsWithNoneOnItOrItsInverse()
            {
                Latch loaded = Reload(new Latch());

                CheckEqual(0, loaded.SubscriptionCount);
                CheckEqual(0, loaded.Inverse.SubscriptionCount);
            }

            public void Subscriptions_LoadInTheOrderTheyWereMade()
            {
                var door = new Latch();
                TriggerWait first = WaitOn(1, false, door);
                TriggerWait second = WaitOn(2, true, new Latch(), door);

                Latch loaded = Reload(door);

                CheckEqual(2, loaded.SubscriptionCount);
                CheckEqual(1, loaded.SubscriptionAt(0).Target.Conditions.Length);
                CheckEqual(2, loaded.SubscriptionAt(1).Target.Conditions.Length);
                CheckEqual(1, loaded.SubscriptionAt(1).Index);
                CheckEqual(first.Wait, loaded.WaitAt(0));
                CheckEqual(second.Wait, loaded.WaitAt(1));
            }

            public void SubscriptionsToTheInverse_LoadOnTheLoadedInverse()
            {
                var door = new Latch();
                WaitOn(1, false, door);
                TriggerWait onInverse = WaitOn(1, false, door.Inverse);

                Latch loaded = Reload(door);

                CheckEqual(1, loaded.SubscriptionCount);
                CheckEqual(1, loaded.Inverse.SubscriptionCount);
                CheckEqual(onInverse.Wait, loaded.Inverse.WaitAt(0));
            }

            public void Subscription_LoadsPointingAtTheWaitThatListsTheLoadedLatch()
            {
                var door = new Latch();
                WaitOn(1, false, door);

                Latch loaded = Reload(door);

                TriggerWait wait = loaded.SubscriptionAt(0).Target;
                CheckTrue(ReferenceEquals(loaded, wait.Conditions[0]));
                CheckTrue(ReferenceEquals(wait.Subscriptions[0], loaded.SubscriptionAt(0)));
            }

            public void SubscriptionToTheInverse_LoadsPointingAtTheWaitThatListsTheLoadedInverse()
            {
                var door = new Latch();
                WaitOn(1, false, door.Inverse);

                Latch loaded = Reload(door);

                TriggerWait wait = loaded.Inverse.SubscriptionAt(0).Target;
                CheckTrue(ReferenceEquals(loaded.Inverse, wait.Conditions[0]));
            }

            public void SubscriptionOfAWaitThatBeganAgain_IsLeftOut()
            {
                var door = new Latch();
                TriggerWait wait = WaitOn(1, false, door);
                wait.Begin(new Frame { Wake = wait.Slot }, requiresAll: false);

                CheckEqual(0, Reload(door).SubscriptionCount);
            }

            public void SubscriptionOfAFinishedWait_IsLeftOut()
            {
                var door = new Latch(initiallySet: true);
                WaitOn(1, false, door).Finish();

                CheckEqual(0, Reload(door).SubscriptionCount);
            }

            public void SubscriptionOfAWaitThatIsSatisfiedButNotFinished_IsKept()
            {
                var door = new Latch(initiallySet: true);
                WaitOn(1, false, door);

                CheckEqual(1, Reload(door).SubscriptionCount);
            }

            public void NodeWithNoSetFlag_Throws()
            {
                SaveSession session = ArcConverterTests.Session();
                SaveNode node = Saved(new Latch(), session);
                node.Entries.Remove("set");

                CheckThrow(typeof(InvalidDataException));
                session.FromNode(node, typeof(Latch));
            }

            public void NodeWithNoWaiters_Throws()
            {
                SaveSession session = ArcConverterTests.Session();
                SaveNode node = Saved(new Latch(), session);
                node.Entries.Remove("waiters");

                CheckThrow(typeof(InvalidDataException));
                session.FromNode(node, typeof(Latch));
            }

            public void NodeWithNoInverseWaiters_Throws()
            {
                SaveSession session = ArcConverterTests.Session();
                SaveNode node = Saved(new Latch(), session);
                node.Entries.Remove("inverseWaiters");

                CheckThrow(typeof(InvalidDataException));
                session.FromNode(node, typeof(Latch));
            }

            public void WaitersThatAreNotAList_Throw()
            {
                SaveSession session = ArcConverterTests.Session();
                SaveNode node = Saved(new Latch(), session);
                node.Entries["waiters"] = session.ToNode(5);

                CheckThrow(typeof(InvalidDataException));
                session.FromNode(node, typeof(Latch));
            }

            public void InverseWaitersThatAreNotAList_Throw()
            {
                SaveSession session = ArcConverterTests.Session();
                SaveNode node = Saved(new Latch(), session);
                node.Entries["inverseWaiters"] = session.ToNode(5);

                CheckThrow(typeof(InvalidDataException));
                session.FromNode(node, typeof(Latch));
            }

            public void SubscriptionWithNoWait_Throws()
            {
                SaveSession session = ArcConverterTests.Session();
                var door = new Latch();
                WaitOn(1, false, door);
                SaveNode node = Saved(door, session);
                node.Entries["waiters"].Items[0].Entries.Remove("wait");

                CheckThrow(typeof(InvalidDataException));
                session.FromNode(node, typeof(Latch));
            }

            public void SubscriptionForAPositionPastTheWaitsCapacity_Throws()
            {
                SaveSession session = ArcConverterTests.Session();
                var door = new Latch();
                WaitOn(2, false, door);
                SaveNode node = Saved(door, session);
                node.Entries["waiters"].Items[0].Entries["index"] = session.ToNode(5);

                CheckThrow(typeof(InvalidDataException));
                session.FromNode(node, typeof(Latch));
            }

            public void SubscriptionForAPositionTheWaitDoesNotList_Throws()
            {
                SaveSession session = ArcConverterTests.Session();
                var door = new Latch();
                WaitOn(2, false, door);
                SaveNode node = Saved(door, session);
                node.Entries["waiters"].Items[0].Entries["index"] = session.ToNode(1);

                CheckThrow(typeof(InvalidDataException));
                session.FromNode(node, typeof(Latch));
            }

            public void SubscriptionToTheInverseForAPositionTheWaitDoesNotList_Throws()
            {
                SaveSession session = ArcConverterTests.Session();
                var door = new Latch();
                WaitOn(2, false, door.Inverse);
                SaveNode node = Saved(door, session);
                node.Entries["inverseWaiters"].Items[0].Entries["index"] = session.ToNode(1);

                CheckThrow(typeof(InvalidDataException));
                session.FromNode(node, typeof(Latch));
            }
        }
    }
}