using System;
using System.Collections.Generic;
using Vellum;

namespace Ariadne.Vellum.UnitTests
{
    /// <summary>
    /// The context the trigger wait scripts run in, with the triggers they wait on and a log they write to.
    /// </summary>
    public class Hallway
    {
        public Trigger Door = new Trigger();

        public Trigger Alarm = new Trigger();

        public List<string> Log = new List<string>();
    }

    public class HallwayConverter : SaveConverter<Hallway>
    {
        public override SaveNode Write(Hallway value, SaveSession session)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries["door"] = session.ToNode(value.Door);
            returnMe.Entries["alarm"] = session.ToNode(value.Alarm);
            returnMe.Entries["log"] = session.ToNode(value.Log);
            return returnMe;
        }

        public override Hallway Read(SaveNode node, SaveSession session)
        {
            var returnMe = new Hallway();
            session.Publish(node, returnMe);
            returnMe.Door = session.FromNode<Trigger>(node.RequireEntry("door"));
            returnMe.Alarm = session.FromNode<Trigger>(node.RequireEntry("alarm"));
            returnMe.Log = session.FromNode<List<string>>(node.RequireEntry("log"));
            return returnMe;
        }

        public override bool TryListChildren(SaveNode node, ChildList children)
        {
            SaveNode door;
            SaveNode alarm;
            SaveNode log;
            if (!node.TryGetEntry("door", out door) || !node.TryGetEntry("alarm", out alarm)
                || !node.TryGetEntry("log", out log))
            {
                return false;
            }

            children.Add(door, typeof(Trigger));
            children.Add(alarm, typeof(Trigger));
            children.Add(log, typeof(List<string>));
            return true;
        }
    }

    /// <summary>
    /// A hallway and what runs in it, which are saved and loaded together.
    /// </summary>
    public class Scene<ContentType>
    {
        public Hallway Hallway;

        public ContentType Content;
    }

    public class SceneConverter<ContentType> : SaveConverter<Scene<ContentType>>
    {
        public override SaveNode Write(Scene<ContentType> value, SaveSession session)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries["hallway"] = session.ToNode(value.Hallway);
            returnMe.Entries["content"] = session.ToNode(value.Content);
            return returnMe;
        }

        public override Scene<ContentType> Read(SaveNode node, SaveSession session)
        {
            var returnMe = new Scene<ContentType>();
            session.Publish(node, returnMe);
            returnMe.Hallway = session.FromNode<Hallway>(node.RequireEntry("hallway"));
            returnMe.Content = session.FromNode<ContentType>(node.RequireEntry("content"));
            return returnMe;
        }

        public override bool TryListChildren(SaveNode node, ChildList children)
        {
            SaveNode hallway;
            SaveNode content;
            if (!node.TryGetEntry("hallway", out hallway) || !node.TryGetEntry("content", out content))
            {
                return false;
            }

            children.Add(hallway, typeof(Hallway));
            children.Add(content, typeof(ContentType));
            return true;
        }
    }

    /// <summary>
    /// A hallway and what runs in it, whose converter doesn't say what it holds, so a load can't plan ahead.
    /// </summary>
    public class UnplannedScene<ContentType>
    {
        public Hallway Hallway;

        public ContentType Content;
    }

    public class UnplannedSceneConverter<ContentType> : SaveConverter<UnplannedScene<ContentType>>
    {
        public override SaveNode Write(UnplannedScene<ContentType> value, SaveSession session)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries["hallway"] = session.ToNode(value.Hallway);
            returnMe.Entries["content"] = session.ToNode(value.Content);
            return returnMe;
        }

        public override UnplannedScene<ContentType> Read(SaveNode node, SaveSession session)
        {
            var returnMe = new UnplannedScene<ContentType>();
            session.Publish(node, returnMe);
            returnMe.Hallway = session.FromNode<Hallway>(node.RequireEntry("hallway"));
            returnMe.Content = session.FromNode<ContentType>(node.RequireEntry("content"));
            return returnMe;
        }
    }

    /// <summary>
    /// Waits for the door, then logs.
    /// </summary>
    public partial class HallDoorScript : Arc<Hallway>
    {
        protected override void Run(Hallway hallway)
        {
            hallway.Log.Add("start");

        door:
            Wait(hallway.Door);
            hallway.Log.Add("door");
        }
    }

    /// <summary>
    /// Waits for either trigger with a time limit, and logs which one came.
    /// </summary>
    public partial class HallTimedScript : Arc<Hallway>
    {
        public TimeSpan Limit = TimeSpan.FromSeconds(2);

        protected override void Run(Hallway hallway)
        {
            hallway.Log.Add("start");

        either:
            Trigger fired = WaitAny(timeout: Limit, hallway.Door, hallway.Alarm);
            hallway.Log.Add(fired == null ? "timed out" : fired == hallway.Alarm ? "alarm" : "door");
        }
    }

    /// <summary>
    /// Waits for the alarm with a time limit, then for the door.
    /// </summary>
    public partial class HallTimedThenDoorScript : Arc<Hallway>
    {
        public TimeSpan Limit = TimeSpan.FromSeconds(2);

        protected override void Run(Hallway hallway)
        {
        alarm:
            Wait(hallway.Alarm, timeout: Limit);
            hallway.Log.Add("alarm window over");

        door:
            Wait(hallway.Door);
            hallway.Log.Add("door");
        }
    }

    /// <summary>
    /// Waits for the door, then logs its name.
    /// </summary>
    public partial class HallNamedScript : Arc<Hallway>
    {
        public string Name;

        protected override void Run(Hallway hallway)
        {
        door:
            Wait(hallway.Door);
            hallway.Log.Add(Name);
        }
    }

    /// <summary>
    /// Waits for either trigger, and logs which one it was.
    /// </summary>
    public partial class HallEitherScript : Arc<Hallway>
    {
        protected override void Run(Hallway hallway)
        {
        either:
            Trigger fired = WaitAny(hallway.Door, hallway.Alarm);
            hallway.Log.Add(fired == hallway.Alarm ? "alarm" : "door");
        }
    }

    /// <summary>
    /// Waits for both triggers, and logs which one came last.
    /// </summary>
    public partial class HallBothScript : Arc<Hallway>
    {
        protected override void Run(Hallway hallway)
        {
        both:
            Trigger last = WaitAll(hallway.Door, hallway.Alarm);
            hallway.Log.Add(last == hallway.Alarm ? "alarm last" : "door last");
        }
    }

    /// <summary>
    /// Waits for the door twice, with a local counting the trips.
    /// </summary>
    public partial class HallTwiceScript : Arc<Hallway>
    {
        protected override void Run(Hallway hallway)
        {
            int count = 0;
            while (count < 2)
            {
            spin:
                Wait(hallway.Door);
                ++count;
                hallway.Log.Add("door " + count);
            }
        }
    }

    /// <summary>
    /// Offers a passage for other arcs to run, which waits for the door.
    /// </summary>
    public partial class HallLookoutScript : Arc<Hallway>
    {
        public void Watch(Hallway hallway)
        {
        watch:
            Wait(hallway.Door);
            hallway.Log.Add("seen");
        }

        protected override void Run(Hallway hallway)
        {
        }
    }

    /// <summary>
    /// Runs the passage of another arc that waits for the door.
    /// </summary>
    public partial class HallRelayScript : Arc<Hallway>
    {
        public HallLookoutScript Lookout;

        protected override void Run(Hallway hallway)
        {
        relay:
            Lookout.Watch(hallway);
            hallway.Log.Add("relayed");
        }
    }

    /// <summary>
    /// Waits in a generic passage, which keeps its locals in a frame of its own.
    /// </summary>
    public partial class HallGenericScript : Arc<Hallway>
    {
        private Trigger Choose<ItemType>(Hallway hallway, ItemType marker)
        {
        inner:
            return WaitAny(hallway.Door, hallway.Alarm);
        }

        protected override void Run(Hallway hallway)
        {
        outer:
            Trigger picked = Choose(hallway, 5);
            hallway.Log.Add(picked == hallway.Alarm ? "alarm" : "door");
        }
    }
}