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

namespace Clave.Vellum.UnitTests
{
    public class KeyTermTextTests : TestFixture
    {
        public class FormatTests : TestFixture
        {
            public void NoLiterals_IsEmptyText()
            {
                CheckEqual("", KeyTermText.Format(new KeyLiteral[0]));
            }

            public void PhysicalLiteral_LeavesTheSpaceOff()
            {
                var literal = new KeyLiteral(KeyCode.Z, KeyStateKind.Pressed, KeySpace.Physical, false);

                CheckEqual("Pressed(Z)", KeyTermText.Format(new[] { literal }));
            }

            public void LayoutLiteral_NamesTheSpace()
            {
                var literal = new KeyLiteral(KeyCode.ControlLeft, KeyStateKind.Held, KeySpace.Layout, false);

                CheckEqual("Held(Layout:ControlLeft)", KeyTermText.Format(new[] { literal }));
            }

            public void NegatedLiteral_StartsWithATilde()
            {
                var literal = new KeyLiteral(KeyCode.ShiftLeft, KeyStateKind.Held, KeySpace.Physical, true);

                CheckEqual("~Held(ShiftLeft)", KeyTermText.Format(new[] { literal }));
            }

            public void SeveralLiterals_AreJoinedByAmpersands()
            {
                var literals = new[]
                {
                    new KeyLiteral(KeyCode.Z, KeyStateKind.Pressed, KeySpace.Physical, false),
                    new KeyLiteral(KeyCode.ControlLeft, KeyStateKind.Held, KeySpace.Layout, false),
                    new KeyLiteral(KeyCode.ShiftLeft, KeyStateKind.Held, KeySpace.Physical, true),
                };

                CheckEqual("Pressed(Z) & Held(Layout:ControlLeft) & ~Held(ShiftLeft)", KeyTermText.Format(literals));
            }

            public void NullLiterals_Throw()
            {
                CheckThrow(typeof(ArgumentNullException));
                KeyTermText.Format(null);
            }
        }

        public class ParseTests : TestFixture
        {
            public static List<KeyLiteral> Parsed(string text)
            {
                return KeyTermText.Parse(text);
            }

            public void EmptyText_IsNoLiterals()
            {
                CheckEqual(0, Parsed("").Count);
            }

            public void OnlySpaces_IsNoLiterals()
            {
                CheckEqual(0, Parsed("   ").Count);
            }

            public void FormattedTerm_ReadsBackTheSameLiterals()
            {
                var literals = new[]
                {
                    new KeyLiteral(KeyCode.Z, KeyStateKind.Pressed, KeySpace.Physical, false),
                    new KeyLiteral(KeyCode.ControlLeft, KeyStateKind.Held, KeySpace.Layout, false),
                    new KeyLiteral(KeyCode.ShiftLeft, KeyStateKind.Held, KeySpace.Physical, true),
                    new KeyLiteral(KeyCode.A, KeyStateKind.Released, KeySpace.Layout, true),
                    new KeyLiteral(KeyCode.B, KeyStateKind.Repeated, KeySpace.Physical, false),
                };

                List<KeyLiteral> parsed = Parsed(KeyTermText.Format(literals));

                CheckEqual(literals.Length, parsed.Count);
                for (int i = 0; i < literals.Length; ++i)
                {
                    CheckEqual(literals[i], parsed[i]);
                }
            }

            public void AnyCaseAndSpacing_IsAccepted()
            {
                List<KeyLiteral> parsed = Parsed("  pressed ( layout : z )&HELD(controlleft)  ");

                CheckEqual(2, parsed.Count);
                CheckEqual(new KeyLiteral(KeyCode.Z, KeyStateKind.Pressed, KeySpace.Layout, false), parsed[0]);
                CheckEqual(new KeyLiteral(KeyCode.ControlLeft, KeyStateKind.Held, KeySpace.Physical, false), parsed[1]);
            }

            public void BangAndComma_StandInForTildeAndAmpersand()
            {
                List<KeyLiteral> parsed = Parsed("! Held(ShiftLeft), Pressed(Z)");

                CheckEqual(2, parsed.Count);
                CheckEqual(new KeyLiteral(KeyCode.ShiftLeft, KeyStateKind.Held, KeySpace.Physical, true), parsed[0]);
                CheckEqual(new KeyLiteral(KeyCode.Z, KeyStateKind.Pressed, KeySpace.Physical, false), parsed[1]);
            }

            public void UnknownKind_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Parsed("Squeezed(Z)");
            }

            public void KindWithoutBracket_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Parsed("Pressed");
            }

            public void UnknownKey_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Parsed("Pressed(NoSuchKey)");
            }

            public void UnknownSpace_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Parsed("Pressed(Nowhere:Z)");
            }

            public void MissingClosingBracket_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Parsed("Pressed(Z");
            }

            public void TwoLiteralsWithoutSeparator_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Parsed("Pressed(Z) Held(A)");
            }

            public void TrailingSeparator_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Parsed("Pressed(Z) &");
            }

            public void NullText_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                Parsed(null);
            }
        }
    }
}