namespace PvS.Common.UnitTests
{
    using System.Collections.Generic;
    using System.Linq;

    using FluentAssertions;
    
    using Xunit;

    public class NCrunchDemo
    {
        public enum Value
        {
            First,
            Second,
            Other
        }

        public enum Parameters
        {
            Inputs1,
            Inputs2,
            Inputs1And2
        }

        public static IEnumerable<object[]> BaseData()
        {
            return new[]
            {
                // Data:       input1                               input2
                new object[] { new List<Value>() { Value.First },   Value.First },
                new object[] { new List<Value>() { Value.Second },  Value.Second },
            };
        }

        public static IEnumerable<object[]> Data(Parameters parameters)
        {
            var skipCount = parameters == Parameters.Inputs2 ? 1 : 0;
            var parameterCount = parameters == Parameters.Inputs1And2 ? 2 : 1;
            return BaseData()
                .Select(f => f.Skip(skipCount)
                              .Take(parameterCount)
                              .ToArray())
                .ToList();
        }

        // FailAll
        [Theory]
        [MemberData("Data", Parameters.Inputs1)]
        public void DoFailAll_Input1(IEnumerable<Value> input1)
        {
            input1.Single().Should().Be(Value.Other);
        }

        [Theory]
        [MemberData("Data", Parameters.Inputs2)]
        public void DoFailAll_Input2(Value input2)
        {
            input2.Should().Be(Value.Other);
        }

        [Theory]
        [MemberData("Data", Parameters.Inputs1And2)]
        public void DoFailAll_Input1And2(IEnumerable<Value> input1, Value input2)
        {
            input2.Should().Be(Value.Other);
        }

        // FailFirst
        [Theory]
        [MemberData("Data", Parameters.Inputs1)]
        public void DoFailFirst_Input1(IEnumerable<Value> input1)
        {
            input1.Single().Should().Be(Value.Second);
        }

        [Theory]
        [MemberData("Data", Parameters.Inputs2)]
        public void DoFailFirst_Input2(Value input2)
        {
            input2.Should().Be(Value.Second);
        }

        [Theory]
        [MemberData("Data", Parameters.Inputs1And2)]
        public void DoFailFirst_Input1And2(IEnumerable<Value> input1, Value input2)
        {
            input1.Single().Should().Be(Value.Second);
        }

        // FailSecond
        [Theory]
        [MemberData("Data", Parameters.Inputs1)]
        public void DoFailSecond_Input1(IEnumerable<Value> input1)
        {
            input1.Single().Should().Be(Value.First);
        }

        [Theory]
        [MemberData("Data", Parameters.Inputs2)]
        public void DoFailSecond_Input2(Value input2)
        {
            input2.Should().Be(Value.First);
        }

        [Theory]
        [MemberData("Data", Parameters.Inputs1And2)]
        public void DoFailSecond_Input1And2(IEnumerable<Value> input1, Value input2)
        {
            input1.Single().Should().Be(Value.First);
        }
    }
}