using GameModel.UnitTests.Helper;
using GameModel;
using GameModel.Exceptions;
using NuGet.Frameworks;
using NUnit.Framework.Legacy;
using System.Collections;
using System.Numerics;

namespace GameModel.UnitTests
{
    [TestFixture]
    internal class PinPictureTests
    {
        [Test]
        [TestCase(1,PinState.Down)]
        [TestCase(2, PinState.Down)]
        [TestCase(3, PinState.Down)]
        [TestCase(4, PinState.Down)]
        [TestCase(5, PinState.Down)]
        [TestCase(6, PinState.Down)]
        [TestCase(7, PinState.Down)]
        [TestCase(8, PinState.Down)]
        [TestCase(9, PinState.Down)]
        public void PinPicture_IndexTest(int pinNumber, PinState pinState)
        {
            var p = PinPicture.Create(pinNumber, pinState);
            Assert.That(p[pinNumber],Is.EqualTo(PinState.Down));
        }

        [Test]
        [TestCase(0)]
        [TestCase(-1)]
        [TestCase(10)]
        [TestCase(11)]
        public void Get_Invalid_PinNumber_ThrowsException(int pinNumber)
        {
            var p = PinPicture.Create();
            Assert.That(() => p[pinNumber],Throws.TypeOf<InvalidPinIndexException>());
        }

        //[Test]
        //[TestCase(0)]
        //[TestCase(-1)]
        //[TestCase(10)]
        //[TestCase(11)]
        //public void Set_Invalid_PinNumber_ThrowsException(int pinNumber)
        //{
        //    var p = PinPicture.Create();
        //    Assert.That(() => p[pinNumber] = PinState.Down, Throws.TypeOf<InvalidPinIndexException>());
        //}

        [Test]
        public void Access_PinStates()
        {
            var p = new PinPicture(PinState.Down, PinState.Up, PinState.Down, PinState.Up, PinState.Down, PinState.Up, PinState.Down, PinState.Up, PinState.Down);
            Assert.That(p.PinState1, Is.EqualTo(PinState.Down));
            Assert.That(p.PinState2, Is.EqualTo(PinState.Up));
            Assert.That(p.PinState3, Is.EqualTo(PinState.Down));
            Assert.That(p.PinState4, Is.EqualTo(PinState.Up));
            Assert.That(p.PinState5, Is.EqualTo(PinState.Down));
            Assert.That(p.PinState6, Is.EqualTo(PinState.Up));
            Assert.That(p.PinState7, Is.EqualTo(PinState.Down));
            Assert.That(p.PinState8, Is.EqualTo(PinState.Up));
            Assert.That(p.PinState9, Is.EqualTo(PinState.Down));
            Assert.That(p.UpCount, Is.EqualTo(4));
            Assert.That(p.DownCount, Is.EqualTo(5));
            Assert.That(p.AllUp, Is.False);
        }

        [Test]
        public void DefaultPinPicature_IsAllUp_True()
        {
            var p = PinPicture.Create();
            Assert.That(p.AllUp,Is.True);
        }

        [Test]
        public void LoopOverPinStates()
        {
            var p = PinPicture.Create();
            var i = 0;
            foreach (var item in p)
            {
                i++;
                Assert.That(item, Is.EqualTo(p[i]));
            }
            
        }

        [Test]
        public void UseLinqOnPinPictore()
        {
            var p = new PinPicture(PinState.Down, PinState.Up, PinState.Down, PinState.Up, PinState.Down, PinState.Up, PinState.Down, PinState.Up, PinState.Down);
            Assert.That(p.First, Is.EqualTo(PinState.Down));
            Assert.That(p.Skip(1).First, Is.EqualTo(PinState.Up));
            Assert.That(p.Last, Is.EqualTo(PinState.Down));

            var items = p.Take(9).ToArray();
            CollectionAssert.AreEqual(items, new[] { PinState.Down, PinState.Up, PinState.Down, PinState.Up, PinState.Down, PinState.Up, PinState.Down, PinState.Up, PinState.Down });

            var enumerator = p.GetEnumerator();
            enumerator.MoveNext();
            enumerator.MoveNext();
            Assert.That(enumerator.Current, Is.EqualTo(PinState.Up));

            // cover GetEnumerator method https://stackoverflow.com/questions/1510031/how-do-you-test-the-ienumerable-getenumerator-method
            IEnumerable weak = p.AsWeakEnumerable();
            var sequence = weak.Cast<PinState>().Take(9).ToArray();
            CollectionAssert.AreEqual(sequence, new[] { PinState.Down, PinState.Up, PinState.Down, PinState.Up, PinState.Down, PinState.Up, PinState.Down, PinState.Up, PinState.Down });
        }

        [Test]
        public void PicturePlusSinkIsSamePicture()
        {
            var p = PinPicture.Create();
            var p2 = p + PinThrow.Create(1, null, false, true);
            Assert.That(p,Is.EqualTo(p2));
        }

        //[Test]
        //public void PicturePlusSamePinsThrowException()
        //{
        //    var p1 = new PinPicture();
        //    p1.PinState1 = PinState.Down;

        //    var p2 = new PinPicture();
        //    p2.PinState1 = PinState.Down;
        //    var pinThrow = new PinThrow(p2, false, false);

        //    Assert.That(() => p1 + pinThrow, Throws.InstanceOf<InvalidPinCalcExcetion>());
        //}

        [Test]
        public void Addition_CreatesCumulatedPinPicture()
        {
            var p1 = PinPicture.Create();
            var throwPic1 = PinPicture.Create(1, PinState.Down);
            var pinThrow1 = PinThrow.Create(1, throwPic1, false, false);

            var throwPic2 = PinPicture.Create(2, PinState.Down);
            var pinThrow2 = PinThrow.Create(1, throwPic2, false, false);

            var throwPic3 = PinPicture.Create(3, PinState.Down);
            var pinThrow3 = PinThrow.Create(1, throwPic3, false, false);

            var throwPic4 = PinPicture.Create(4, PinState.Down);
            var pinThrow4 = PinThrow.Create(1, throwPic4, false, false);

            var throwPic5 = PinPicture.Create(5, PinState.Down);
            var pinThrow5 = PinThrow.Create(1, throwPic5, false, false);

            var throwPic6 = PinPicture.Create(6, PinState.Down);
            var pinThrow6 = PinThrow.Create(1, throwPic6, false, false);

            var throwPic7 = PinPicture.Create(7, PinState.Down);
            var pinThrow7 = PinThrow.Create(1, throwPic7, false, false);

            var throwPic8 = PinPicture.Create(8, PinState.Down);
            var pinThrow8 = PinThrow.Create(1, throwPic8, false, false);

            var throwPic9 = PinPicture.Create(9, PinState.Down);
            var pinThrow9 = PinThrow.Create(1, throwPic9, false, false);

            var p2 = p1 + pinThrow1;
            var p3 = p2 + pinThrow2;
            var p4 = p3 + pinThrow3;
            var p5 = p4 + pinThrow4;
            var p6 = p5 + pinThrow5;
            var p7 = p6 + pinThrow6;
            var p8 = p7 + pinThrow7;
            var p9 = p8 + pinThrow8;
            var p10 = p9 + pinThrow9;

            Assert.That(p2.DownCount, Is.EqualTo(1));
            Assert.That(p3.DownCount, Is.EqualTo(2));
            Assert.That(p4.DownCount, Is.EqualTo(3));
            Assert.That(p5.DownCount, Is.EqualTo(4));
            Assert.That(p6.DownCount, Is.EqualTo(5));
            Assert.That(p7.DownCount, Is.EqualTo(6));
            Assert.That(p8.DownCount, Is.EqualTo(7));
            Assert.That(p9.DownCount, Is.EqualTo(8));
            Assert.That(p10.DownCount, Is.EqualTo(9));
        }

        [Test]
        public void DownCount_MatchesDownState()
        {
            var p = PinPicture.Create(2,PinState.Down);
            Assert.That(p.DownCount, Is.EqualTo(1));
            Assert.That(p.UpCount, Is.EqualTo(8));
        }
    }
}