using System.IO;
using UnitTestSharp;
using Vellum;

namespace Ariadne.Vellum.UnitTests
{
    public class TriggerConverterTests : TestFixture
    {
        /// <summary>
        /// Returns a wait of <paramref name="capacity"/> that has begun and been given <paramref name="triggers"/>.
        /// </summary>
        public static TriggerWait WaitOn(int capacity, bool requiresAll, params Trigger[] triggers)
        {
            var returnMe = new TriggerWait(capacity);
            returnMe.Begin(new Frame { Wake = new WakeSlot() }, requiresAll);
            foreach (Trigger trigger in triggers)
            {
                returnMe.Add(trigger);
            }

            return returnMe;
        }

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

            public void TriggerWithNoSubscriptions_LoadsWithNone()
            {
                CheckEqual(0, Reload(new Trigger()).SubscriptionCount);
            }

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

                Trigger loaded = Reload(door);

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

            public void Subscription_LoadsPointingAtTheWaitThatListsTheLoadedTrigger()
            {
                var door = new Trigger();
                WaitOn(1, false, door);

                Trigger loaded = Reload(door);

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

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

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

            public void SubscriptionOfAWaitThatIsOver_IsLeftOut()
            {
                var door = new Trigger();
                WaitOn(1, false, door).Mark(0);

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

            public void SubscriptionOfADroppedSlot_IsLeftOut()
            {
                var door = new Trigger();
                WaitOn(1, false, door).Slot.Dropped = true;

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

            public void SubscriptionOfAnUnattachedWait_IsKept()
            {
                var door = new Trigger();
                WaitOn(1, false, door).Slot = null;

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

            public void NodeThatIsNotAList_Throws()
            {
                SaveSession session = ArcConverterTests.Session();
                SaveNode node = SaveNode.NewTable();
                node.Entries["wait"] = session.ToNode(1);

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

            public void EntryWithNoWait_Throws()
            {
                var door = new Trigger();
                WaitOn(1, false, door);
                SaveSession session = ArcConverterTests.Session();
                SaveNode node = session.ToNode(door, typeof(Trigger)).Resolved;
                node.Items[0].Entries.Remove("wait");

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

            public void PositionPastTheWaitsCapacity_Throws()
            {
                var door = new Trigger();
                WaitOn(1, false, door);
                SaveSession session = ArcConverterTests.Session();
                SaveNode node = session.ToNode(door, typeof(Trigger)).Resolved;
                node.Items[0].Entries["index"] = session.ToNode(1);

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

            public void NegativePosition_Throws()
            {
                var door = new Trigger();
                WaitOn(1, false, door);
                SaveSession session = ArcConverterTests.Session();
                SaveNode node = session.ToNode(door, typeof(Trigger)).Resolved;
                node.Items[0].Entries["index"] = session.ToNode(-1);

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

            public void PositionThatTheWaitHoldsAnotherTriggerAt_Throws()
            {
                var door = new Trigger();
                WaitOn(2, false, new Trigger(), door);
                SaveSession session = ArcConverterTests.Session();
                SaveNode node = session.ToNode(door, typeof(Trigger)).Resolved;
                node.Items[0].Entries["index"] = session.ToNode(0);

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

            public void PositionPastWhatTheWaitHolds_Throws()
            {
                var door = new Trigger();
                WaitOn(2, false, door);
                SaveSession session = ArcConverterTests.Session();
                SaveNode node = session.ToNode(door, typeof(Trigger)).Resolved;
                node.Items[0].Entries["index"] = session.ToNode(1);

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