using NUnit.Framework;
using Robust.Shared.Utility;

namespace Robust.Shared.Tests.Utility
{
    [Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
    [TestFixture]
    [TestOf(typeof(CommandParsing))]
    internal sealed class CommandParsing_Test
    {
        [TestCase("foo bar", new[] {"foo", "bar"})]
        [TestCase("foo  bar", new[] {"foo", "bar"})]
        [TestCase("foo  \"bar baz\"", new[] {"foo", "bar baz"})]
        [TestCase("foo  \"bar  baz\"", new[] {"foo", "bar  baz"})]
        [TestCase("foo  bar  baz", new[] {"foo", "bar", "baz"})]
        [TestCase(@"foo  \""bar\""", new[] {"foo", "\"bar\""})]
        [TestCase(@"foo  \""b\ar\""", new[] {"foo", "\"bar\""})]
        [TestCase("", new string[0])]
        public void TestParse(string command, string[] expected)
        {
            var list = new List<string>();
            CommandParsing.ParseArguments(command, list);

            Assert.That(list, Is.EqualTo(expected));
        }

        [TestCase("foo", "foo")]
        [TestCase(@"f\oo", @"f\\oo")]
        [TestCase(@"f""oo", @"f\""oo")]
        public void TestEscape(string source, string expected)
        {
            var escaped = CommandParsing.Escape(source);

            Assert.That(escaped, Is.EqualTo(expected));
        }

        [TestCase("foo;bar")]
        [TestCase("\"foo;bar")]
        [TestCase("f oo;bar")]
        [TestCase("f\\ oo;bar")]
        public void TestEscapeCommand(string source)
        {
            var args = source.Split(';');

            var result = new List<string>();
            var escapedCommand = CommandParsing.EscapeCommand(args);
            TestContext.Out.WriteLine($"Escaped command: {escapedCommand}");

            CommandParsing.ParseArguments(escapedCommand, result);

            Assert.That(result, Is.EquivalentTo(args));
        }
    }
}
