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

namespace StateMachine.Tests
{
    [TestFixture]
    public class StatesShould
    {
        [Test]
        public void Instance_ShouldNotBeNull()
        {
            //Arrange
            var sut = States.Instance;

            //Act && Assert
            Assert.That(sut, Is.Not.Null);
        }

        [Test]
        public void Instance_ShouldBeSame()
        {
            //Arrange
            var sut = States.Instance;

            //Act && Assert
            Assert.That(sut, Is.Not.Null.And.SameAs(States.Instance));
        }

        [Test]
        public void States_ShouldReturnCorrectInstanceOfState()
        {
            //Arrange
            var sut = States.Instance;

            //Act && Assert
            Assert.That(sut.Arm.State, Is.EqualTo(State.Arm));
            Assert.That(sut.Arming.State, Is.EqualTo(State.Arming));
            Assert.That(sut.Configure.State, Is.EqualTo(State.Configure));
            Assert.That(sut.ConfigureStart.State, Is.EqualTo(State.ConfigureStart));
            Assert.That(sut.Diagnose.State, Is.EqualTo(State.Diagnose));
            Assert.That(sut.Download.State, Is.EqualTo(State.Download));
            Assert.That(sut.HardwareDiscovery.State, Is.EqualTo(State.HardwareDiscovery));
            Assert.That(sut.HardwareDiscoveryStart.State, Is.EqualTo(State.HardwareDiscoveryStart));
            Assert.That(sut.Prepare.State, Is.EqualTo(State.Prepare));
            Assert.That(sut.Realtime.State, Is.EqualTo(State.Realtime));
            Assert.That(sut.RealtimeStart.State, Is.EqualTo(State.RealtimeStart));
        }

        [Test]
        public void GetIDASState_ReturnAllKnownStates()
        {
            //Arrange
            var sut = States.Instance;

            //Act & Assert
            var states = Enum.GetValues(typeof(State)).Cast<State>();
            foreach (var state in states)
            {
                var dasState = sut.GetIDASState(state);
                Assert.That(dasState.State, Is.EqualTo(state));
            }
        }

        [Test]
        public void GetIDASState_ShouldThrowException_WithUndefinedState()
        {
            //Arrange
            var sut = States.Instance;
            var enumVal = 45;

            //Act & Assert
            Assert.That(false, Is.EqualTo(Enum.IsDefined(typeof(State), enumVal)));
            Assert.That(
                () => sut.GetIDASState((State)enumVal)
                , Throws.TypeOf<InvalidOperationException>()
           .With
           .Property("Message")
           .EqualTo("Undefined State"));
        }

        [Test]
        public void SetDASFactory_ShouldSetToAnInstanceOfDASFactory()
        {
            //Arrange
            var sut = States.Instance;
            var dasFactory = Substitute.For<IDASFactory>();
            dasFactory.Language.Returns("En");

            //Act
            States.SetDASFactory(dasFactory);

            //Assert
            //Test thal all states have the defined DASFactory instance.
            var states = Enum.GetValues(typeof(State)).Cast<State>();
            foreach (var state in states)
            {
                //Depends on GetIDASState_ReturnAllKnownStates , If this test broken first fix GetIDASState_ReturnAllKnownStates
                //Isolate the dependency to the GetIDASState_ReturnAllKnownStates test if it's possible
                var dasState = sut.GetIDASState(state);
                Assert.That(dasState.DASFactory, Is.Not.Null);
                Assert.That(dasState.DASFactory.Language, Is.EqualTo("En"));
            }


        }
    }
}