using Vellum;

namespace Ariadne.Vellum
{
    /// <summary>
    /// Saves a latch as whether it is set, and the waits that are subscribed to it and to its inverse.
    /// </summary>
    /// <remarks>
    /// The inverse is part of its latch, since the latch makes it, so it needs no converter of its own.
    /// </remarks>
    public class LatchConverter : SaveConverter<Latch>
    {
        private const string SetKey = "set";
        private const string WaitersKey = "waiters";
        private const string InverseWaitersKey = "inverseWaiters";

        public override SaveNode Write(Latch value, SaveSession session)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries[SetKey] = session.ToNode(value.IsSet);
            returnMe.Entries[WaitersKey] = SavedSubscriptions.Write(value, session);
            returnMe.Entries[InverseWaitersKey] = SavedSubscriptions.Write(value.Inverse, session);
            return returnMe;
        }

        public override Latch Allocate(SaveNode node, SaveSession session)
        {
            return new Latch(session.FromNode<bool>(node.RequireEntry(SetKey)));
        }

        public override void Fill(Latch blank, SaveNode node, SaveSession session)
        {
            SavedSubscriptions.Fill(blank, node.RequireEntry(WaitersKey), session);
            SavedSubscriptions.Fill(blank.Inverse, node.RequireEntry(InverseWaitersKey), session);
        }

        public override void Complete(Latch blank, SaveNode node, SaveSession session)
        {
            SavedSubscriptions.Check(blank);
            SavedSubscriptions.Check(blank.Inverse);
        }

        public override bool TryListChildren(SaveNode node, ChildList children)
        {
            SaveNode waiters;
            SaveNode inverseWaiters;
            return node.TryGetEntry(WaitersKey, out waiters)
                && node.TryGetEntry(InverseWaitersKey, out inverseWaiters)
                && SavedSubscriptions.ListChildren(waiters, children)
                && SavedSubscriptions.ListChildren(inverseWaiters, children);
        }

        public override Latch Read(SaveNode node, SaveSession session)
        {
            Latch returnMe = Allocate(node, session);
            session.Publish(node, returnMe);
            Fill(returnMe, node, session);
            return returnMe;
        }
    }
}