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

namespace Clave.Vellum.UnitTests
{
    public class ChordSetBuilderConverterTests : TestFixture
    {
        public static List<Chord> ChordsOf(ChordSetBuilder builder)
        {
            var returnMe = new List<Chord>();
            foreach (Chord chord in builder)
            {
                returnMe.Add(chord);
            }

            return returnMe;
        }

        public class WriteTests : TestFixture
        {
            public void EmptyBuilder_IsNoChords()
            {
                SaveNode node = SavedThrough.Session().ToNode(new ChordSetBuilder(), typeof(ChordSetBuilder));

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

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

                SaveNode entry = SavedThrough.Session().ToNode(builder, typeof(ChordSetBuilder))
                    .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 ASavedChordSet_LoadsAsABuilder()
            {
                var set = new ChordSetBuilder();
                Chord chord = set.Add(Chord.Press(KeyCode.Z), priority: 3);
                set.SetEnabled(chord, false);
                SaveSession session = SavedThrough.Session();
                SaveNode node = session.ToNode(set.Build(), typeof(ChordSet));

                var loaded = (ChordSetBuilder)SavedThrough.Session().FromNode(node, typeof(ChordSetBuilder));
                Chord loadedChord = ChordsOf(loaded)[0];

                CheckEqual(1, loaded.Count);
                CheckEqual(3, loaded.PriorityOf(loadedChord));
                CheckFalse(loaded.IsEnabled(loadedChord));
            }

            public void MissingChords_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                SavedThrough.Session().FromNode(SaveNode.NewTable(), typeof(ChordSetBuilder));
            }
        }

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

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

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

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

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

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

                ChordSetBuilder loaded = SavedThrough.RoundTrip(builder);

                var chords = ChordsOf(loaded);
                CheckEqual(2, chords.Count);
                CheckEqual(2, loaded.PriorityOf(chords[0]));
                CheckEqual(-1, loaded.PriorityOf(chords[1]));
                CheckTrue(loaded.IsEnabled(chords[0]));
                CheckFalse(loaded.IsEnabled(chords[1]));
            }

            public void LoadedBuilder_RanksChordsLikeTheOriginal()
            {
                var builder = new ChordSetBuilder();
                Chord plain = builder.Add(Chord.Press(KeyCode.Z), priority: 2);
                Chord shifted = builder.Add(Chord.Press(KeyCode.Z).WithAnyHeld(KeyState.Shift), priority: 1);

                ChordSetBuilder loaded = SavedThrough.RoundTrip(builder);

                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);
                CheckEqual(builder.ShouldFire(plain, shiftedEvent), loaded.ShouldFire(chords[0], shiftedEvent));
                CheckEqual(builder.ShouldFire(shifted, shiftedEvent), loaded.ShouldFire(chords[1], shiftedEvent));
            }

            public void LoadedBuilder_CanBeChangedWithoutTouchingTheOriginal()
            {
                var builder = new ChordSetBuilder();
                builder.Add(Chord.Press(KeyCode.Z));

                ChordSetBuilder loaded = SavedThrough.RoundTrip(builder);
                loaded.Add(Chord.Press(KeyCode.X));

                CheckEqual(1, builder.Count);
                CheckEqual(2, loaded.Count);
            }
        }
    }
}