using System.IO;
using UnitTestSharp;
using Vellum;

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

        public static System.Collections.Generic.List<Chord> ChordsOf(ChordSet set)
        {
            var returnMe = new System.Collections.Generic.List<Chord>();
            foreach (Chord chord in set)
            {
                returnMe.Add(chord);
            }

            return returnMe;
        }

        public static SaveNode Entry(string chord, string priority = null, string enabled = null)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries[ChordSetConverter.ChordKey] = SavedThrough.Terms(chord);
            if (priority != null)
            {
                returnMe.Entries[ChordSetConverter.PriorityKey] = SaveNode.OfText(priority);
            }

            if (enabled != null)
            {
                returnMe.Entries[ChordSetConverter.EnabledKey] = SaveNode.OfText(enabled);
            }

            return returnMe;
        }

        public static SaveNode Saved(params SaveNode[] entries)
        {
            SaveNode list = SaveNode.NewList();
            list.Items.AddRange(entries);
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries[ChordSetConverter.ChordsKey] = list;
            return returnMe;
        }

        public class WriteTests : TestFixture
        {
            public void EmptySet_IsNoChords()
            {
                SaveNode node = SavedThrough.Session().ToNode(ChordSet.Empty, typeof(ChordSet));

                CheckEqual(0, node.RequireEntry(ChordSetConverter.ChordsKey).Items.Count);
            }

            public void EachChord_IsSavedWithItsPriorityAndEnabledFlag()
            {
                var set = new ChordSetBuilder();
                Chord chord = set.Add(Chord.Press(KeyCode.Z), priority: 7);
                set.SetEnabled(chord, false);

                SaveNode entry = SavedThrough.Session().ToNode(set.Build(), typeof(ChordSet))
                    .RequireEntry(ChordSetConverter.ChordsKey).Items[0];

                CheckEqual("7", entry.RequireEntry(ChordSetConverter.PriorityKey).Text);
                CheckEqual("false", entry.RequireEntry(ChordSetConverter.EnabledKey).Text);
            }
        }

        public class ReadTests : TestFixture
        {
            public void MissingPriorityAndEnabled_DefaultToZeroAndEnabled()
            {
                ChordSet loaded = Loaded(Saved(Entry("Pressed(Z)")));
                Chord chord = ChordsOf(loaded)[0];

                CheckEqual(0, loaded.PriorityOf(chord));
                CheckTrue(loaded.IsEnabled(chord));
            }

            public void PriorityAndDisabled_AreApplied()
            {
                ChordSet loaded = Loaded(Saved(Entry("Pressed(Z)", priority: "3", enabled: "false")));
                Chord chord = ChordsOf(loaded)[0];

                CheckEqual(3, loaded.PriorityOf(chord));
                CheckFalse(loaded.IsEnabled(chord));
            }

            public void SameChordTwice_LoadsBothAsEquivalentChords()
            {
                ChordSet loaded = Loaded(
                    Saved(Entry("Pressed(Z)", priority: "1"), Entry("pressed(z)", priority: "2")));
                var chords = ChordsOf(loaded);

                CheckEqual(2, chords.Count);
                CheckEqual(1, loaded.PriorityOf(chords[0]));
                CheckEqual(2, loaded.PriorityOf(chords[1]));
            }

            public void MissingChords_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Loaded(SaveNode.NewTable());
            }

            public void EntryWithoutChord_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Loaded(Saved(SaveNode.NewTable()));
            }
        }

        public class TryListChildrenTests : TestFixture
        {
            public void EachChord_IsListedAsAChord()
            {
                SaveNode node = Saved(Entry("Pressed(Z)"), Entry("Pressed(X)"));
                var children = new ChildList();

                CheckTrue(new ChordSetConverter().TryListChildren(node, children));

                CheckEqual(2, children.Count);
                CheckEqual(typeof(Chord), children.TypeAt(0));
                CheckEqual(typeof(Chord), children.TypeAt(1));
            }

            public void NoChordsEntry_ListsNothing()
            {
                var children = new ChildList();

                CheckFalse(new ChordSetConverter().TryListChildren(SaveNode.NewTable(), children));
            }

            public void EntryWithoutChord_ListsNothing()
            {
                var children = new ChildList();

                CheckFalse(new ChordSetConverter().TryListChildren(Saved(SaveNode.NewTable()), children));
            }
        }

        public class RoundTripTests : TestFixture
        {
            public void Chords_KeepPriorityAndEnabledFlag()
            {
                var set = new ChordSetBuilder();
                Chord first = set.Add(Chord.Press(KeyCode.Z), priority: 2);
                Chord second = set.Add(Chord.Press(KeyCode.X).WithAnyHeld(KeyState.Shift), priority: -1);
                set.SetEnabled(second, false);

                ChordSet loaded = SavedThrough.RoundTrip(set.Build());

                var chords = ChordsOf(loaded);

                CheckEqual(2, chords.Count);
                CheckEqual(first.Formula, chords[0].Formula);
                CheckEqual(second.Formula, chords[1].Formula);
                CheckEqual(2, loaded.PriorityOf(chords[0]));
                CheckEqual(-1, loaded.PriorityOf(chords[1]));
                CheckTrue(loaded.IsEnabled(chords[0]));
                CheckFalse(loaded.IsEnabled(chords[1]));
            }

            public void LoadedSet_RanksChordsLikeTheOriginal()
            {
                var set = new ChordSetBuilder();
                Chord plain = set.Add(Chord.Press(KeyCode.Z));
                Chord shifted = set.Add(Chord.Press(KeyCode.Z).WithAnyHeld(KeyState.Shift));

                ChordSet loaded = SavedThrough.RoundTrip(set.Build());

                var tracker = new KeyTracker();
                tracker.KeyDown(KeyCode.ShiftLeft, KeyCode.ShiftLeft, isRepeat: false);
                KeyboardSnapshot shiftedEvent = tracker.KeyDown(KeyCode.Z, KeyCode.Z, isRepeat: false);

                var chords = ChordsOf(loaded);
                ChordSetBuilder rebuilt = loaded.ToBuilder();
                CheckEqual(set.ShouldFire(plain, shiftedEvent), rebuilt.ShouldFire(chords[0], shiftedEvent));
                CheckEqual(set.ShouldFire(shifted, shiftedEvent), rebuilt.ShouldFire(chords[1], shiftedEvent));
            }
        }
    }
}