using System.IO;
using UnitTestSharp;
using Vellum;

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

        public static KeyFormula RoundTripped(Chord chord)
        {
            return SavedThrough.RoundTrip(chord).Formula;
        }

        public class WriteTests : TestFixture
        {
            public void Press_IsOneTermOfThePressedKey()
            {
                SaveNode node = SavedThrough.Session().ToNode(Chord.Press(KeyCode.Z), typeof(Chord));

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

            public void LayoutChord_NamesTheSpaceInItsTerms()
            {
                SaveNode node = SavedThrough.Session().ToNode(Chord.Press(KeyCode.Z, KeySpace.Layout), typeof(Chord));

                CheckEqual("Pressed(Layout:Z)", node.Items[0].Text);
            }
        }

        public class ReadTests : TestFixture
        {
            public void HandWrittenTerm_LoadsTheChord()
            {
                Chord loaded = Loaded(SavedThrough.Terms("pressed(z)"));

                CheckEqual(KeyFormula.Key(KeyCode.Z, KeyStateKind.Pressed), loaded.Formula);
            }

            public void TermsThatMatchNothing_Throw()
            {
                CheckThrow(typeof(InvalidDataException));
                Loaded(SavedThrough.Terms("Pressed(Z) & ~Pressed(Z)"));
            }

            public void NoTerms_Throw()
            {
                CheckThrow(typeof(InvalidDataException));
                Loaded(SavedThrough.Terms());
            }
        }

        public class RoundTripTests : TestFixture
        {
            public void Press_Survives()
            {
                var chord = Chord.Press(KeyCode.Z);
                CheckEqual(chord.Formula, RoundTripped(chord));
            }

            public void LayoutRepeat_Survives()
            {
                var chord = Chord.Repeat(KeyCode.Z, KeySpace.Layout);
                CheckEqual(chord.Formula, RoundTripped(chord));
            }

            public void PressWithAnyShiftHeld_Survives()
            {
                var chord = Chord.Press(KeyCode.Z).WithAnyHeld(KeyState.Shift);
                CheckEqual(chord.Formula, RoundTripped(chord));
            }

            public void PressWithAllControlAndAltHeld_Survives()
            {
                var chord = Chord.Press(KeyCode.Z).WithAllHeld(KeyState.Control | KeyState.Alt);
                CheckEqual(chord.Formula, RoundTripped(chord));
            }

            public void ChordAcrossBothSpaces_Survives()
            {
                var chord = Chord.Press(KeyCode.Z, KeySpace.Layout).WithAnyHeld(KeyState.Control, KeySpace.Physical);
                CheckEqual(chord.Formula, RoundTripped(chord));
            }

            public void PressOrRepeat_Survives()
            {
                var chord = Chord.PressOrRepeat(KeyCode.Z);
                CheckEqual(chord.Formula, RoundTripped(chord));
            }

            public void ReleaseWithNoShiftHeld_Survives()
            {
                var chord = Chord.Release(KeyCode.Z) & Chord.HoldNone(KeyState.Shift);
                CheckEqual(chord.Formula, RoundTripped(chord));
            }

            public void ExclusiveOr_Survives()
            {
                var chord = Chord.Press(KeyCode.Z) ^ Chord.Press(KeyCode.X);
                CheckEqual(chord.Formula, RoundTripped(chord));
            }
        }
    }
}