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

namespace Clave.Vellum.UnitTests
{
    public class SavedChordsTests : TestFixture
    {
        public static SaveNode Written(params SavedChord[] chords)
        {
            return SavedChords.Write(chords, SavedThrough.Session());
        }

        public static IReadOnlyList<SaveNode> EntriesOf(SaveNode written)
        {
            return written.RequireEntry(ChordSetConverter.ChordsKey).Items;
        }

        public static string TextOf(ChordSetBuilder builder)
        {
            SaveSession session = SavedThrough.Session();
            SaveNode save = SaveNode.NewTable();
            save.Entries["value"] = session.ToNode(builder.Build(), typeof(ChordSet));
            return LuaSaveFormat.Format(save);
        }

        public class WriteTests : TestFixture
        {
            public void HigherPriorityComesFirst()
            {
                IReadOnlyList<SaveNode> entries = EntriesOf(Written(
                    new SavedChord(Chord.Press(KeyCode.A), priority: 1, enabled: true),
                    new SavedChord(Chord.Press(KeyCode.B), priority: 3, enabled: true),
                    new SavedChord(Chord.Press(KeyCode.C), priority: 2, enabled: true)));

                CheckEqual("3", entries[0].RequireEntry(ChordSetConverter.PriorityKey).Text);
                CheckEqual("2", entries[1].RequireEntry(ChordSetConverter.PriorityKey).Text);
                CheckEqual("1", entries[2].RequireEntry(ChordSetConverter.PriorityKey).Text);
            }

            public void EqualPriorities_AreOrderedByFormulaText()
            {
                IReadOnlyList<SaveNode> entries = EntriesOf(Written(
                    new SavedChord(Chord.Press(KeyCode.C), priority: 0, enabled: true),
                    new SavedChord(Chord.Press(KeyCode.A), priority: 0, enabled: true),
                    new SavedChord(Chord.Press(KeyCode.B), priority: 0, enabled: true)));

                CheckEqual("Pressed(A)", entries[0].RequireEntry(ChordSetConverter.ChordKey).Items[0].Text);
                CheckEqual("Pressed(B)", entries[1].RequireEntry(ChordSetConverter.ChordKey).Items[0].Text);
                CheckEqual("Pressed(C)", entries[2].RequireEntry(ChordSetConverter.ChordKey).Items[0].Text);
            }

            public void ChordWithAnotherTerm_ComesAfterThePlainChordItExtends()
            {
                IReadOnlyList<SaveNode> entries = EntriesOf(Written(
                    new SavedChord(Chord.Press(KeyCode.Z).WithAnyHeld(KeyState.Shift), priority: 0, enabled: true),
                    new SavedChord(Chord.Press(KeyCode.Z), priority: 0, enabled: true)));

                CheckEqual(1, entries[0].RequireEntry(ChordSetConverter.ChordKey).Items.Count);
                CheckEqual(2, entries[1].RequireEntry(ChordSetConverter.ChordKey).Items.Count);
            }

            public void SameFormulaAndPriority_PutsTheEnabledChordFirst()
            {
                IReadOnlyList<SaveNode> entries = EntriesOf(Written(
                    new SavedChord(Chord.Press(KeyCode.A), priority: 0, enabled: false),
                    new SavedChord(Chord.Press(KeyCode.A), priority: 0, enabled: true)));

                CheckEqual("true", entries[0].RequireEntry(ChordSetConverter.EnabledKey).Text);
                CheckEqual("false", entries[1].RequireEntry(ChordSetConverter.EnabledKey).Text);
            }

            public void ADisabledChord_KeepsItsPlaceByPriority()
            {
                IReadOnlyList<SaveNode> entries = EntriesOf(Written(
                    new SavedChord(Chord.Press(KeyCode.A), priority: 1, enabled: true),
                    new SavedChord(Chord.Press(KeyCode.B), priority: 2, enabled: false)));

                CheckEqual("false", entries[0].RequireEntry(ChordSetConverter.EnabledKey).Text);
            }

            public void NoChords_IsAnEmptyList()
            {
                CheckEqual(0, EntriesOf(Written()).Count);
            }
        }

        public class SetOrderTests : TestFixture
        {
            public void ChordsAddedInADifferentOrder_SaveTheSame()
            {
                var forwards = new ChordSetBuilder();
                forwards.Add(Chord.Press(KeyCode.A));
                forwards.Add(Chord.Press(KeyCode.B));
                forwards.Add(Chord.Press(KeyCode.C));
                var backwards = new ChordSetBuilder();
                backwards.Add(Chord.Press(KeyCode.C));
                backwards.Add(Chord.Press(KeyCode.B));
                backwards.Add(Chord.Press(KeyCode.A));

                CheckEqual(TextOf(forwards), TextOf(backwards));
            }

            public void AChordRemovedAndAnotherAdded_SavesLikeASetBuiltFromScratch()
            {
                var edited = new ChordSetBuilder();
                Chord removed = edited.Add(Chord.Press(KeyCode.A));
                edited.Add(Chord.Press(KeyCode.B));
                edited.Add(Chord.Press(KeyCode.C));
                edited.Remove(removed);
                edited.Add(Chord.Press(KeyCode.D));
                var fresh = new ChordSetBuilder();
                fresh.Add(Chord.Press(KeyCode.B));
                fresh.Add(Chord.Press(KeyCode.C));
                fresh.Add(Chord.Press(KeyCode.D));

                CheckEqual(TextOf(fresh), TextOf(edited));
            }

            public void ADisabledChord_SavesTheSameWhenAddedFirstOrLast()
            {
                var first = new ChordSetBuilder();
                first.SetEnabled(first.Add(Chord.Press(KeyCode.A)), false);
                first.Add(Chord.Press(KeyCode.B));
                var last = new ChordSetBuilder();
                last.Add(Chord.Press(KeyCode.B));
                last.SetEnabled(last.Add(Chord.Press(KeyCode.A)), false);

                CheckEqual(TextOf(first), TextOf(last));
            }
        }
    }
}