using NUnit.Framework;
using DTS.Common.Interface.DASFactory;
using DTS.DASLib.Service;
using DTS.DASLib.Service.StateMachine;
using NSubstitute;
using System.Collections.Generic;

namespace StateMachine.Tests.StatusAndParameters
{
    [TestFixture]
    class GlobalStatusInformationShould
    {
        GlobalStatusInformation sut;

        [SetUp]
        public void SetUp()
        {
            //Arrange
            sut = new GlobalStatusInformation();
        }

        [TearDown]
        public void TearDown()
        {
            sut = null;
        }

        [Test]
        public void GetUnitsInRealtime_Should_ReturnNoUnites()
        {
            //Act
            var result = sut.GetUnitsInRealtime();

            //Assert
            Assert.That(result, Is.EqualTo(new List<IDASCommunication>()));
            Assert.That(result.Length, Is.EqualTo(0));
        }

        [Test]
        public void AddUnitInRealtime_Should_AddUnitCorrectly()
        {
            //Arrange
            var device = Substitute.For<IDASCommunication>();
            var sn = "SL60159";
            device.SerialNumber.Returns(sn);

            //Act
            sut.AddUnitInRealtime(device);

            //Assert
            Assert.That(sut.GetUnitsInRealtime().Length, Is.EqualTo(1));
            Assert.That(sut.GetUnitsInRealtime()[0].SerialNumber, Is.EqualTo(sn));
        }

        [Test]
        public void AddUnitInRealtime_Should_AddMultipleUnitsCorrectly()
        {
            //Arrange
            var device = Substitute.For<IDASCommunication>();
            var sn = "SL60159";
            device.SerialNumber.Returns(sn);

            var secondDevice = Substitute.For<IDASCommunication>();
            var secondSn = "SL60160";
            secondDevice.SerialNumber.Returns(secondSn);

            //Act
            sut.AddUnitInRealtime(device);
            sut.AddUnitInRealtime(secondDevice);

            //Assert
            Assert.That(sut.GetUnitsInRealtime().Length, Is.EqualTo(2));
            Assert.That(sut.GetUnitsInRealtime()[0].SerialNumber, Is.EqualTo(sn));
            Assert.That(sut.GetUnitsInRealtime()[1].SerialNumber, Is.EqualTo(secondSn));
        }

        [Test]
        public void AddUnitInRealtime_ShouldNot_AddExistingDevice()
        {
            //Arrange
            var device = Substitute.For<IDASCommunication>();
            var sn = "SL60159";
            device.SerialNumber.Returns(sn);

            var secondDevice = Substitute.For<IDASCommunication>();
            var secondSn = "SL60160";
            secondDevice.SerialNumber.Returns(secondSn);

            var thirdDevice = secondDevice;

            //Act
            sut.AddUnitInRealtime(device);
            sut.AddUnitInRealtime(secondDevice);
            sut.AddUnitInRealtime(thirdDevice);

            //Assert
            Assert.That(sut.GetUnitsInRealtime().Length, Is.EqualTo(2));
            Assert.That(sut.GetUnitsInRealtime()[0].SerialNumber, Is.EqualTo(sn));
            Assert.That(sut.GetUnitsInRealtime()[1].SerialNumber, Is.EqualTo(secondSn));
        }


        [Test]
        public void GetUnitsInArm_Should_ReturnNoUnites()
        {
            //Act
            var result = sut.GetUnitsInArm();

            //Assert
            Assert.That(result, Is.EqualTo(new List<IDASCommunication>()));
            Assert.That(result.Length, Is.EqualTo(0));
        }

        [Test]
        public void AddUnitInArm_Should_AddUnitCorrectly()
        {
            //Arrange
            var device = Substitute.For<IDASCommunication>();
            var sn = "SL60159";
            device.SerialNumber.Returns(sn);

            //Act
            sut.AddUnitInArm(device);

            //Assert
            Assert.That(sut.GetUnitsInArm().Length, Is.EqualTo(1));
            Assert.That(sut.GetUnitsInArm()[0].SerialNumber, Is.EqualTo(sn));
        }

        [Test]
        public void AddUnitInArm_Should_AddMultipleUnitsCorrectly()
        {
            //Arrange
            var device = Substitute.For<IDASCommunication>();
            var sn = "SL60159";
            device.SerialNumber.Returns(sn);

            var secondDevice = Substitute.For<IDASCommunication>();
            var secondSn = "SL60160";
            secondDevice.SerialNumber.Returns(secondSn);

            //Act
            sut.AddUnitInArm(device);
            sut.AddUnitInArm(secondDevice);

            //Assert
            Assert.That(sut.GetUnitsInArm().Length, Is.EqualTo(2));
            Assert.That(sut.GetUnitsInArm()[0].SerialNumber, Is.EqualTo(sn));
            Assert.That(sut.GetUnitsInArm()[1].SerialNumber, Is.EqualTo(secondSn));
        }

        [Test]
        public void AddUnitInArm_ShouldNot_AddExistingDevice()
        {
            //Arrange
            var device = Substitute.For<IDASCommunication>();
            var sn = "SL60159";
            device.SerialNumber.Returns(sn);

            var secondDevice = Substitute.For<IDASCommunication>();
            var secondSn = "SL60160";
            secondDevice.SerialNumber.Returns(secondSn);

            var thirdDevice = secondDevice;

            //Act
            sut.AddUnitInArm(device);
            sut.AddUnitInArm(secondDevice);
            sut.AddUnitInArm(thirdDevice);

            //Assert
            Assert.That(sut.GetUnitsInArm().Length, Is.EqualTo(2));
            Assert.That(sut.GetUnitsInArm()[0].SerialNumber, Is.EqualTo(sn));
            Assert.That(sut.GetUnitsInArm()[1].SerialNumber, Is.EqualTo(secondSn));
        }

        [Test]
        public void GetUnitsAtLowPower_Should_ReturnNoUnites()
        {
            //Act
            var result = sut.GetUnitsAtLowPower();

            //Assert
            Assert.That(result, Is.EqualTo(new List<IDASCommunication>()));
            Assert.That(result.Length, Is.EqualTo(0));
        }

        [Test]
        public void AddUnitAtLowPower_Should_AddUnitCorrectly()
        {
            //Arrange
            var device = Substitute.For<IDASCommunication>();
            var sn = "SL60159";
            device.SerialNumber.Returns(sn);

            //Act
            sut.AddUnitAtLowPower(device);

            //Assert
            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(1));
            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(sn));
        }

        [Test]
        public void AddUnitAtLowPower_Should_AddMultipleUnitsCorrectly()
        {
            //Arrange
            var device = Substitute.For<IDASCommunication>();
            var sn = "SL60159";
            device.SerialNumber.Returns(sn);

            var secondDevice = Substitute.For<IDASCommunication>();
            var secondSn = "SL60160";
            secondDevice.SerialNumber.Returns(secondSn);

            //Act
            sut.AddUnitAtLowPower(device);
            sut.AddUnitAtLowPower(secondDevice);

            //Assert
            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(2));
            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(sn));
            Assert.That(sut.GetUnitsAtLowPower()[1].SerialNumber, Is.EqualTo(secondSn));
        }

        [Test]
        public void AddUnitAtLowPower_ShouldNot_AddExistingDevice()
        {
            //Arrange
            var device = Substitute.For<IDASCommunication>();
            var sn = "SL60159";
            device.SerialNumber.Returns(sn);

            var secondDevice = Substitute.For<IDASCommunication>();
            var secondSn = "SL60160";
            secondDevice.SerialNumber.Returns(secondSn);

            var thirdDevice = secondDevice;

            //Act
            sut.AddUnitAtLowPower(device);
            sut.AddUnitAtLowPower(secondDevice);
            sut.AddUnitAtLowPower(thirdDevice);

            //Assert
            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(2));
            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(sn));
            Assert.That(sut.GetUnitsAtLowPower()[1].SerialNumber, Is.EqualTo(secondSn));
        }

        [Test]
        public void AddUnitAtLowPower_Should_AddToLowPowerRemoveFromHighPower()
        {
            //Arrange
            var device = Substitute.For<IDASCommunication>();
            var sn = "SL60159";
            device.SerialNumber.Returns(sn);

            var secondDevice = Substitute.For<IDASCommunication>();
            var secondSn = "SL60160";
            secondDevice.SerialNumber.Returns(secondSn);

            var thirdDevice = Substitute.For<IDASCommunication>();
            var thirdSn = "SL60161";
            thirdDevice.SerialNumber.Returns(thirdSn);

            //Act & Assert
            sut.AddUnitAtLowPower(device);
            sut.AddUnitAtLowPower(secondDevice);

            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(2));
            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(sn));
            Assert.That(sut.GetUnitsAtLowPower()[1].SerialNumber, Is.EqualTo(secondSn));

            sut.AddUnitAtHighPower(thirdDevice);

            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(1));
            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(thirdSn));

            sut.AddUnitAtLowPower(thirdDevice);

            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(3));
            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(sn));
            Assert.That(sut.GetUnitsAtLowPower()[1].SerialNumber, Is.EqualTo(secondSn));
            Assert.That(sut.GetUnitsAtLowPower()[2].SerialNumber, Is.EqualTo(thirdSn));

            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(0));
        }

        [Test]
        public void GetUnitsAtHighPower_Should_ReturnNoUnites()
        {
            //Act
            var result = sut.GetUnitsAtHighPower();

            //Assert
            Assert.That(result, Is.EqualTo(new List<IDASCommunication>()));
            Assert.That(result.Length, Is.EqualTo(0));
        }

        [Test]
        public void AddUnitAtHighPower_Should_AddUnitCorrectly()
        {
            //Arrange
            var device = Substitute.For<IDASCommunication>();
            var sn = "SL60159";
            device.SerialNumber.Returns(sn);

            //Act
            sut.AddUnitAtHighPower(device);

            //Assert
            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(1));
            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(sn));
        }

        [Test]
        public void AddUnitAtHighPower_Should_AddMultipleUnitsCorrectly()
        {
            //Arrange
            var device = Substitute.For<IDASCommunication>();
            var sn = "SL60159";
            device.SerialNumber.Returns(sn);

            var secondDevice = Substitute.For<IDASCommunication>();
            var secondSn = "SL60160";
            secondDevice.SerialNumber.Returns(secondSn);

            //Act
            sut.AddUnitAtHighPower(device);
            sut.AddUnitAtHighPower(secondDevice);

            //Assert
            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(2));
            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(sn));
            Assert.That(sut.GetUnitsAtHighPower()[1].SerialNumber, Is.EqualTo(secondSn));
        }

        [Test]
        public void AddUnitAtHighPower_ShouldNot_AddExistingDevice()
        {
            //Arrange
            var device = Substitute.For<IDASCommunication>();
            var sn = "SL60159";
            device.SerialNumber.Returns(sn);

            var secondDevice = Substitute.For<IDASCommunication>();
            var secondSn = "SL60160";
            secondDevice.SerialNumber.Returns(secondSn);

            var thirdDevice = secondDevice;

            //Act
            sut.AddUnitAtHighPower(device);
            sut.AddUnitAtHighPower(secondDevice);
            sut.AddUnitAtHighPower(thirdDevice);

            //Assert
            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(2));
            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(sn));
            Assert.That(sut.GetUnitsAtHighPower()[1].SerialNumber, Is.EqualTo(secondSn));
        }


        [Test]
        public void AddUnitAtHighPower_Should_AddToLowPowerRemoveFromLowPower()
        {
            //Arrange
            var device = Substitute.For<IDASCommunication>();
            var sn = "SL60159";
            device.SerialNumber.Returns(sn);

            var secondDevice = Substitute.For<IDASCommunication>();
            var secondSn = "SL60160";
            secondDevice.SerialNumber.Returns(secondSn);

            var thirdDevice = Substitute.For<IDASCommunication>();
            var thirdSn = "SL60161";
            thirdDevice.SerialNumber.Returns(thirdSn);

            //Act & Assert
            sut.AddUnitAtHighPower(device);
            sut.AddUnitAtHighPower(secondDevice);

            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(2));
            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(sn));
            Assert.That(sut.GetUnitsAtHighPower()[1].SerialNumber, Is.EqualTo(secondSn));

            sut.AddUnitAtLowPower(thirdDevice);

            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(1));
            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(thirdSn));

            sut.AddUnitAtHighPower(thirdDevice);

            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(3));
            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(sn));
            Assert.That(sut.GetUnitsAtHighPower()[1].SerialNumber, Is.EqualTo(secondSn));
            Assert.That(sut.GetUnitsAtHighPower()[2].SerialNumber, Is.EqualTo(thirdSn));

            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(0));
        }


        [Test]
        public void Reset_Should_ResetProperties()
        {
            //Arrange
            var device = Substitute.For<IDASCommunication>();
            var sn = "SL60159";
            device.SerialNumber.Returns(sn);

            var device2 = Substitute.For<IDASCommunication>();
            var sn2 = "SL60160";
            device2.SerialNumber.Returns(sn2);

            sut.AddUnitAtLowPower(device);
            sut.AddUnitInArm(device);
            sut.AddUnitInRealtime(device);
            sut.AddUnitAtHighPower(device2);
            sut.ExcitationOn = true;

            //Act & Assert
            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(1));
            Assert.That(sut.GetUnitsInArm().Length, Is.EqualTo(1));
            Assert.That(sut.GetUnitsInRealtime().Length, Is.EqualTo(1));
            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(1));
            Assert.That(sut.ExcitationOn, Is.EqualTo(true));

            sut.Reset();
            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(0));
            Assert.That(sut.GetUnitsInArm().Length, Is.EqualTo(0));
            Assert.That(sut.GetUnitsInRealtime().Length, Is.EqualTo(0));
            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(0));
            Assert.That(sut.ExcitationOn, Is.EqualTo(false));
        }
    }
}