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

namespace Clave.Vellum
{
    /// <summary>
    /// Saves a KeyFormula as a list of terms, each one line of text that spells the keys that must all hold.  The
    /// formula matches when any term does.
    /// </summary>
    /// <remarks>
    /// The terms are written with key and space names, never the numbers a formula's diagram asks about, so a save
    /// outlives a change to how those are numbered.  See <see cref="KeyTermText"/> for the spelling.
    /// </remarks>
    public sealed class KeyFormulaConverter : SaveConverter<KeyFormula>
    {
        /// <summary>
        /// The most terms a formula may write.  A formula that needs more fails to save instead of making a file nobody
        /// can read.
        /// </summary>
        public const int MaxTerms = 1024;

        /// <summary>
        /// Returns the list of terms that <paramref name="value"/> is saved as.
        /// </summary>
        public static SaveNode ToTermsNode(KeyFormula value)
        {
            SaveNode returnMe = SaveNode.NewList();
            foreach (KeyLiteral[] term in value.ToTerms(MaxTerms))
            {
                returnMe.Items.Add(SaveNode.OfText(KeyTermText.Format(term)));
            }

            return returnMe;
        }

        /// <summary>
        /// Returns the formula that the list of terms in <paramref name="node"/> spells.
        /// </summary>
        /// <exception cref="InvalidDataException">The node isn't a list of terms.</exception>
        public static KeyFormula FromTermsNode(SaveNode node)
        {
            IReadOnlyList<SaveNode> saved = node.RequireItems();
            var terms = new List<List<KeyLiteral>>(saved.Count);
            for (int i = 0; i < saved.Count; ++i)
            {
                string text = saved[i].Text;
                if (text == null)
                {
                    throw new InvalidDataException("Term " + i + " of a saved key formula isn't text.");
                }

                terms.Add(KeyTermText.Parse(text));
            }

            return KeyFormula.FromTerms(terms);
        }

        public override SaveNode Write(KeyFormula value, SaveSession session)
        {
            return ToTermsNode(value);
        }

        public override KeyFormula Read(SaveNode node, SaveSession session)
        {
            return FromTermsNode(node);
        }

        public override bool TryListChildren(SaveNode node, ChildList children)
        {
            // Everything it reads is built-in, and so left out.
            IReadOnlyList<SaveNode> items;
            return node.TryGetItems(out items);
        }
    }
}