using System.ComponentModel;
using NUnit.Framework;
using NSubstitute;
using Prism.Events;
using Prism.Regions;
using Unity;

namespace YourNamespace.Tests
{
    [TestFixture]
    public class ViewModelShould
    {
        private IEventAggregator _eventAggregator;
        private IRegionManager _regionManager;
        private IUnityContainer _unityContainer;

        [SetUp]
        public void Setup()
        {
            _eventAggregator = Substitute.For<IEventAggregator>();
            _regionManager = Substitute.For<IRegionManager>();
            _unityContainer = Substitute.For<IUnityContainer>();
        }

        [Test]
        public void RaisePropertyChanged_WhenPropertyIsSet()
        {
            var sut = CreateSut();
            var eventArgs = new List<PropertyChangedEventArgs>();
            sut.PropertyChanged += (sender, e) => eventArgs.Add(e);

            sut.SomeProperty = "NewValue";

            Assert.That(eventArgs.Count, Is.EqualTo(1));
            Assert.That(eventArgs[0].PropertyName, Is.EqualTo(nameof(sut.SomeProperty)));
        }

        [Test]
        public void NotRaisePropertyChanged_WhenPropertyIsSetToSameValue()
        {
            var sut = CreateSut();
            sut.SomeProperty = "Value";
            var eventArgs = new List<PropertyChangedEventArgs>();
            sut.PropertyChanged += (sender, e) => eventArgs.Add(e);

            sut.SomeProperty = "Value";

            Assert.That(eventArgs.Count, Is.EqualTo(0));
        }

        [Test]
        public void ExecuteCommand_WhenCommandIsInvoked()
        {
            var sut = CreateSut();

            sut.SomeCommand.Execute(null);

            Assert.That(sut.SomeCommandWasExecuted, Is.True);
        }

        [Test]
        public void PublishEvent_WhenActionIsPerformed()
        {
            var testEvent = Substitute.For<TestEvent>();
            _eventAggregator.GetEvent<TestEvent>().Returns(testEvent);
            var sut = CreateSut();

            sut.PerformAction();

            testEvent.Received(1).Publish(Arg.Any<TestPayload>());
        }

        [Test]
        public void SubscribeToEvents_WhenInitialized()
        {
            var testEvent = Substitute.For<TestEvent>();
            _eventAggregator.GetEvent<TestEvent>().Returns(testEvent);

            var sut = CreateSut();

            testEvent.Received(1).Subscribe(Arg.Any<Action<TestPayload>>());
        }

        private TestViewModel CreateSut()
        {
            return new TestViewModel(_regionManager, _eventAggregator, _unityContainer);
        }

        [TearDown]
        public void TearDown()
        {
        }
    }

    public class TestViewModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
        private string _someProperty;
        public string SomeProperty
        {
            get => _someProperty;
            set
            {
                if (_someProperty != value)
                {
                    _someProperty = value;
                    OnPropertyChanged(nameof(SomeProperty));
                }
            }
        }

        public DelegateCommand SomeCommand { get; }
        public bool SomeCommandWasExecuted { get; private set; }

        public TestViewModel(IRegionManager regionManager, IEventAggregator eventAggregator, IUnityContainer unityContainer)
        {
            SomeCommand = new DelegateCommand(() => SomeCommandWasExecuted = true);
        }

        public void PerformAction() { }
        protected void OnPropertyChanged(string propertyName) =>
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    public class TestEvent : PubSubEvent<TestPayload> { }
    public class TestPayload { }
    public class DelegateCommand
    {
        private readonly Action _execute;
        public DelegateCommand(Action execute) => _execute = execute;
        public void Execute(object parameter) => _execute();
    }
}