using System;
using System.IO;
using UnitTestSharp;
using Vellum;

namespace Clave.Vellum.UnitTests
{
    public class KeyFormulaConverterTests : TestFixture
    {
        public static KeyFormula Loaded(SaveNode node)
        {
            return (KeyFormula)SavedThrough.Session().FromNode(node, typeof(KeyFormula));
        }

        public class WriteTests : TestFixture
        {
            public void Never_IsNoTerms()
            {
                SaveNode node = SavedThrough.Session().ToNode(KeyFormula.Never, typeof(KeyFormula));

                CheckEqual(0, node.Items.Count);
            }

            public void Always_IsOneEmptyTerm()
            {
                SaveNode node = SavedThrough.Session().ToNode(KeyFormula.Always, typeof(KeyFormula));

                CheckEqual(1, node.Items.Count);
                CheckEqual("", node.Items[0].Text);
            }

            public void Or_IsOneTermPerBranch()
            {
                KeyFormula formula = KeyFormula.Key(KeyCode.Z, KeyStateKind.Held) |
                    KeyFormula.Key(KeyCode.X, KeyStateKind.Held);

                SaveNode node = SavedThrough.Session().ToNode(formula, typeof(KeyFormula));

                CheckEqual(2, node.Items.Count);
            }

            public void FormulaNeedingMoreThanMaxTerms_Throws()
            {
                // Parity of twelve keys needs a term for every combination of them.
                KeyFormula formula = KeyFormula.Never;
                for (int i = 0; i < 12; ++i)
                {
                    formula ^= KeyFormula.Key(KeyCode.A + i, KeyStateKind.Held);
                }

                CheckThrow(typeof(InvalidOperationException));
                SavedThrough.Session().ToNode(formula, typeof(KeyFormula));
            }
        }

        public class ReadTests : TestFixture
        {
            public void NoTerms_IsNever()
            {
                CheckEqual(KeyFormula.Never, Loaded(SavedThrough.Terms()));
            }

            public void EmptyTerm_IsAlways()
            {
                CheckEqual(KeyFormula.Always, Loaded(SavedThrough.Terms("")));
            }

            public void SeveralTerms_AreOredTogether()
            {
                KeyFormula expected = KeyFormula.Key(KeyCode.Z, KeyStateKind.Held) |
                    KeyFormula.Key(KeyCode.X, KeyStateKind.Held);

                CheckEqual(expected, Loaded(SavedThrough.Terms("Held(Z)", "Held(X)")));
            }

            public void OverlappingTerms_LoadAsTheirUnion()
            {
                KeyFormula expected = KeyFormula.Key(KeyCode.Z, KeyStateKind.Held);

                CheckEqual(expected, Loaded(SavedThrough.Terms("Held(Z)", "Held(Z) & Held(X)")));
            }

            public void TermThatIsNotText_Throws()
            {
                SaveNode node = SaveNode.NewList();
                node.Items.Add(SaveNode.NewTable());

                CheckThrow(typeof(InvalidDataException));
                Loaded(node);
            }

            public void TermThatDoesNotParse_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Loaded(SavedThrough.Terms("Held(NoSuchKey)"));
            }

            public void NodeThatIsNotAList_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Loaded(SaveNode.OfText("Held(Z)"));
            }
        }

        public class RoundTripTests : TestFixture
        {
            public void Negation_Survives()
            {
                KeyFormula formula = KeyFormula.Key(KeyCode.Z, KeyStateKind.Pressed, KeySpace.Layout) &
                    ~KeyFormula.Key(KeyCode.ShiftLeft, KeyStateKind.Held);

                CheckEqual(formula, SavedThrough.RoundTrip(formula));
            }

            public void Never_Survives()
            {
                CheckEqual(KeyFormula.Never, SavedThrough.RoundTrip(KeyFormula.Never));
            }

            public void Always_Survives()
            {
                CheckEqual(KeyFormula.Always, SavedThrough.RoundTrip(KeyFormula.Always));
            }
        }
    }
}