using System;
using System.Linq;
using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
using LCU.Library.Internal.MemberPreferencesApiModels.Enums;
using NUnit.Framework;

namespace LCU.Library.Internal.MemberPreferencesApiModels.UnitTests.Entities
{
    public class MemberOptInSettingsTests
    {
        private MemberOptInSettings _settings;

        [SetUp]
        public void SetUp()
        {
            _settings = new MemberOptInSettings();
        }

        [Test]
        public void Apply_UnifiedOptIn_SetsUniversalOptInAndLegalVersionAndLegalDate()
        {
            _settings.UniversalOptIn = Guid.NewGuid().ToString();
            _settings.LegalVersion = Guid.NewGuid().ToString();
            _settings.LegalDate = DateTime.MinValue;
            var preference = new MemberPreference
            {
                Preference = PreferenceType.UnifiedOptIn,
                Value = Guid.NewGuid().ToString(),
                LegalReference = Guid.NewGuid().ToString()
            };
            var actionStart = DateTime.Now;

            _settings.Apply(preference);

            var elapsedActionTime = DateTime.Now - actionStart;
            Assert.AreEqual(preference.Value, _settings.UniversalOptIn);
            Assert.AreEqual(preference.LegalReference, _settings.LegalVersion);
            Assert.That(actionStart, Is.EqualTo(_settings.LegalDate).Within(elapsedActionTime));
        }

        [Test]
        public void Apply_UnifiedOptInUnchanged_DoesNotClearEmailTracking()
        {
            var originalStatus = _settings.UnifiedOptInEmailStatus = RandomEnumValueFactory<EmailStatus>();
            var originalFirstSent = _settings.UnifiedOptInEmailFirstSent = DateTime.Now.AddHours(-1);
            var originalLastSent = _settings.UnifiedOptInEmailLastSent = DateTime.Now;
            var originalCount = _settings.UnifiedOptInEmailStatusCount = DateTime.Now.Millisecond;
            var preference = new MemberPreference
            {
                Preference = PreferenceType.UnifiedOptIn,
                Value = _settings.UniversalOptIn = Guid.NewGuid().ToString(),
            };

            _settings.Apply(preference);

            Assert.AreEqual(originalStatus, _settings.UnifiedOptInEmailStatus);
            Assert.AreEqual(originalFirstSent, _settings.UnifiedOptInEmailFirstSent);
            Assert.AreEqual(originalLastSent, _settings.UnifiedOptInEmailLastSent);
            Assert.AreEqual(originalCount, _settings.UnifiedOptInEmailStatusCount);
        }

        [Test]
        public void Apply_UnifiedOptInChanged_ClearsEmailTracking()
        {
            _settings.UniversalOptIn = Guid.NewGuid().ToString();
            _settings.UnifiedOptInEmailStatus = RandomEnumValueFactory<EmailStatus>();
            _settings.UnifiedOptInEmailFirstSent = DateTime.Now.AddHours(-1);
            _settings.UnifiedOptInEmailLastSent = DateTime.Now;
            _settings.UnifiedOptInEmailStatusCount = DateTime.Now.Millisecond;
            var preference = new MemberPreference
            {
                Preference = PreferenceType.UnifiedOptIn,
                Value = Guid.NewGuid().ToString(),
            };

            _settings.Apply(preference);

            Assert.IsNull(_settings.UnifiedOptInEmailStatus);
            Assert.IsNull(_settings.UnifiedOptInEmailFirstSent);
            Assert.IsNull(_settings.UnifiedOptInEmailLastSent);
            Assert.AreEqual(0, _settings.UnifiedOptInEmailStatusCount);
        }

        [Test]
        public void Apply_UnifiedOptInEmail_SetsUnifiedOptInEmail()
        {
            _settings.UnifiedOptInEmail = Guid.NewGuid().ToString();
            var preference = new MemberPreference
            {
                Preference = PreferenceType.UnifiedOptInEmail,
                Value = Guid.NewGuid().ToString(),
            };

            _settings.Apply(preference);

            Assert.AreEqual(preference.Value, _settings.UnifiedOptInEmail);
        }

        [Test]
        public void Apply_UnifiedOptInEmailUnchanged_ClearsEmailTracking()
        {
            var originalStatus = _settings.UnifiedOptInEmailStatus = RandomEnumValueFactory<EmailStatus>();
            var originalFirstSent = _settings.UnifiedOptInEmailFirstSent = DateTime.Now.AddHours(-1);
            var originalLastSent = _settings.UnifiedOptInEmailLastSent = DateTime.Now;
            var originalCount = _settings.UnifiedOptInEmailStatusCount = DateTime.Now.Millisecond;
            var preference = new MemberPreference
            {
                Preference = PreferenceType.UnifiedOptInEmail,
                Value = _settings.UnifiedOptInEmail = Guid.NewGuid().ToString(),
            };

            _settings.Apply(preference);

            Assert.IsNull(_settings.UnifiedOptInEmailStatus);
            Assert.IsNull(_settings.UnifiedOptInEmailFirstSent);
            Assert.IsNull(_settings.UnifiedOptInEmailLastSent);
            Assert.AreEqual(0, _settings.UnifiedOptInEmailStatusCount);
        }

        [Test]
        public void Apply_UnifiedOptInEmailChanged_ClearsEmailTracking()
        {
            _settings.UnifiedOptInEmail = Guid.NewGuid().ToString();
            _settings.UnifiedOptInEmailStatus = RandomEnumValueFactory<EmailStatus>();
            _settings.UnifiedOptInEmailFirstSent = DateTime.Now.AddHours(-1);
            _settings.UnifiedOptInEmailLastSent = DateTime.Now;
            _settings.UnifiedOptInEmailStatusCount = DateTime.Now.Millisecond;
            var preference = new MemberPreference
            {
                Preference = PreferenceType.UnifiedOptInEmail,
                Value = Guid.NewGuid().ToString(),
            };

            _settings.Apply(preference);

            Assert.IsNull(_settings.UnifiedOptInEmailStatus);
            Assert.IsNull(_settings.UnifiedOptInEmailFirstSent);
            Assert.IsNull(_settings.UnifiedOptInEmailLastSent);
            Assert.AreEqual(0, _settings.UnifiedOptInEmailStatusCount);
        }

        [Test]
        public void Apply_ENotification_SetsENotifications()
        {
            _settings.ENotifications = Guid.NewGuid().ToString();
            var preference = new MemberPreference
            {
                Preference = PreferenceType.ENotification,
                Value = Guid.NewGuid().ToString()
            };

            _settings.Apply(preference);

            Assert.AreEqual(preference.Value, _settings.ENotifications);
        }

        [Test]
        public void Apply_ENotificationsUnchanged_DoesNotClearEmailTracking()
        {
            var originalStatus = _settings.ENotificationsEmailStatus = RandomEnumValueFactory<EmailStatus>();
            var originalFirstSent = _settings.ENotificationsEmailFirstSent = DateTime.Now.AddHours(-1);
            var originalLastSent = _settings.ENotificationsEmailLastSent = DateTime.Now;
            var originalCount = _settings.ENotificationsEmailStatusCount = DateTime.Now.Millisecond;
            var preference = new MemberPreference
            {
                Preference = PreferenceType.ENotification,
                Value = _settings.ENotifications = Guid.NewGuid().ToString(),
            };

            _settings.Apply(preference);

            Assert.AreEqual(originalStatus, _settings.ENotificationsEmailStatus);
            Assert.AreEqual(originalFirstSent, _settings.ENotificationsEmailFirstSent);
            Assert.AreEqual(originalLastSent, _settings.ENotificationsEmailLastSent);
            Assert.AreEqual(originalCount, _settings.ENotificationsEmailStatusCount);
        }

        [Test]
        public void Apply_ENotificationsChanged_ClearsEmailTracking()
        {
            _settings.ENotifications = Guid.NewGuid().ToString();
            _settings.ENotificationsEmailStatus = RandomEnumValueFactory<EmailStatus>();
            _settings.ENotificationsEmailFirstSent = DateTime.Now.AddHours(-1);
            _settings.ENotificationsEmailLastSent = DateTime.Now;
            _settings.ENotificationsEmailStatusCount = DateTime.Now.Millisecond;
            var preference = new MemberPreference
            {
                Preference = PreferenceType.ENotification,
                Value = Guid.NewGuid().ToString(),
            };

            _settings.Apply(preference);

            Assert.IsNull(_settings.ENotificationsEmailStatus);
            Assert.IsNull(_settings.ENotificationsEmailFirstSent);
            Assert.IsNull(_settings.ENotificationsEmailLastSent);
            Assert.AreEqual(0, _settings.ENotificationsEmailStatusCount);
        }

        [Test]
        public void Apply_ENotificationsEmail_SetsENotificationsEmail()
        {
            _settings.ENotificationsEmail = Guid.NewGuid().ToString();
            var preference = new MemberPreference
            {
                Preference = PreferenceType.ENotificationsEmail,
                Value = Guid.NewGuid().ToString(),
            };

            _settings.Apply(preference);

            Assert.AreEqual(preference.Value, _settings.ENotificationsEmail);
        }

        [Test]
        public void Apply_ENotificationsEmailUnchanged_ClearsEmailTracking()
        {
            var originalStatus = _settings.ENotificationsEmailStatus = RandomEnumValueFactory<EmailStatus>();
            var originalFirstSent = _settings.ENotificationsEmailFirstSent = DateTime.Now.AddHours(-1);
            var originalLastSent = _settings.ENotificationsEmailLastSent = DateTime.Now;
            var originalCount = _settings.ENotificationsEmailStatusCount = DateTime.Now.Millisecond;
            var preference = new MemberPreference
            {
                Preference = PreferenceType.ENotificationsEmail,
                Value = _settings.ENotificationsEmail = Guid.NewGuid().ToString(),
            };

            _settings.Apply(preference);

            Assert.IsNull(_settings.ENotificationsEmailStatus);
            Assert.IsNull(_settings.ENotificationsEmailFirstSent);
            Assert.IsNull(_settings.ENotificationsEmailLastSent);
            Assert.AreEqual(0, _settings.ENotificationsEmailStatusCount);
        }

        [Test]
        public void Apply_ENotificationsEmailChanged_ClearsEmailTracking()
        {
            _settings.ENotificationsEmail = Guid.NewGuid().ToString();
            _settings.ENotificationsEmailStatus = RandomEnumValueFactory<EmailStatus>();
            _settings.ENotificationsEmailFirstSent = DateTime.Now.AddHours(-1);
            _settings.ENotificationsEmailLastSent = DateTime.Now;
            _settings.ENotificationsEmailStatusCount = DateTime.Now.Millisecond;
            var preference = new MemberPreference
            {
                Preference = PreferenceType.ENotificationsEmail,
                Value = Guid.NewGuid().ToString(),
            };

            _settings.Apply(preference);

            Assert.IsNull(_settings.ENotificationsEmailStatus);
            Assert.IsNull(_settings.ENotificationsEmailFirstSent);
            Assert.IsNull(_settings.ENotificationsEmailLastSent);
            Assert.AreEqual(0, _settings.ENotificationsEmailStatusCount);
        }

        [Test]
        public void Apply_EStatements_SetsEStatements()
        {
            _settings.EStatements = Guid.NewGuid().ToString();
            var preference = new MemberPreference
            {
                Preference = PreferenceType.EStatements,
                Value = Guid.NewGuid().ToString()
            };

            _settings.Apply(preference);

            Assert.AreEqual(preference.Value, _settings.EStatements);
        }

        [Test]
        public void Apply_EStatementsUnchanged_DoesNotClearEmailTracking()
        {
            var originalStatus = _settings.EStatementsEmailStatus = RandomEnumValueFactory<EmailStatus>();
            var originalFirstSent = _settings.EStatementsEmailFirstSent = DateTime.Now.AddHours(-1);
            var originalLastSent = _settings.EStatementsEmailLastSent = DateTime.Now;
            var originalCount = _settings.EStatementsEmailStatusCount = DateTime.Now.Millisecond;
            var preference = new MemberPreference
            {
                Preference = PreferenceType.EStatements,
                Value = _settings.EStatements = Guid.NewGuid().ToString(),
            };

            _settings.Apply(preference);

            Assert.AreEqual(originalStatus, _settings.EStatementsEmailStatus);
            Assert.AreEqual(originalFirstSent, _settings.EStatementsEmailFirstSent);
            Assert.AreEqual(originalLastSent, _settings.EStatementsEmailLastSent);
            Assert.AreEqual(originalCount, _settings.EStatementsEmailStatusCount);
        }

        [Test]
        public void Apply_EStatementsChanged_ClearsEmailTracking()
        {
            _settings.EStatements = Guid.NewGuid().ToString();
            _settings.EStatementsEmailStatus = RandomEnumValueFactory<EmailStatus>();
            _settings.EStatementsEmailFirstSent = DateTime.Now.AddHours(-1);
            _settings.EStatementsEmailLastSent = DateTime.Now;
            _settings.EStatementsEmailStatusCount = DateTime.Now.Millisecond;
            var preference = new MemberPreference
            {
                Preference = PreferenceType.EStatements,
                Value = Guid.NewGuid().ToString(),
            };

            _settings.Apply(preference);

            Assert.IsNull(_settings.EStatementsEmailStatus);
            Assert.IsNull(_settings.EStatementsEmailFirstSent);
            Assert.IsNull(_settings.EStatementsEmailLastSent);
            Assert.AreEqual(0, _settings.EStatementsEmailStatusCount);
        }

        [Test]
        public void Apply_EStatementsEmail_SetsEStatementsEmail()
        {
            _settings.EStatementsEmail = Guid.NewGuid().ToString();
            var preference = new MemberPreference
            {
                Preference = PreferenceType.EStatementsEmail,
                Value = Guid.NewGuid().ToString(),
            };

            _settings.Apply(preference);

            Assert.AreEqual(preference.Value, _settings.EStatementsEmail);
        }

        [Test]
        public void Apply_EStatementsEmailUnchanged_ClearsEmailTracking()
        {
            var originalStatus = _settings.EStatementsEmailStatus = RandomEnumValueFactory<EmailStatus>();
            var originalFirstSent = _settings.EStatementsEmailFirstSent = DateTime.Now.AddHours(-1);
            var originalLastSent = _settings.EStatementsEmailLastSent = DateTime.Now;
            var originalCount = _settings.EStatementsEmailStatusCount = DateTime.Now.Millisecond;
            var preference = new MemberPreference
            {
                Preference = PreferenceType.EStatementsEmail,
                Value = _settings.EStatementsEmail = Guid.NewGuid().ToString(),
            };

            _settings.Apply(preference);

            Assert.IsNull(_settings.EStatementsEmailStatus);
            Assert.IsNull(_settings.EStatementsEmailFirstSent);
            Assert.IsNull(_settings.EStatementsEmailLastSent);
            Assert.AreEqual(0, _settings.EStatementsEmailStatusCount);
        }

        [Test]
        public void Apply_EStatementsEmailChanged_ClearsEmailTracking()
        {
            _settings.EStatementsEmail = Guid.NewGuid().ToString();
            _settings.EStatementsEmailStatus = RandomEnumValueFactory<EmailStatus>();
            _settings.EStatementsEmailFirstSent = DateTime.Now.AddHours(-1);
            _settings.EStatementsEmailLastSent = DateTime.Now;
            _settings.EStatementsEmailStatusCount = DateTime.Now.Millisecond;
            var preference = new MemberPreference
            {
                Preference = PreferenceType.EStatementsEmail,
                Value = Guid.NewGuid().ToString(),
            };

            _settings.Apply(preference);

            Assert.IsNull(_settings.EStatementsEmailStatus);
            Assert.IsNull(_settings.EStatementsEmailFirstSent);
            Assert.IsNull(_settings.EStatementsEmailLastSent);
            Assert.AreEqual(0, _settings.EStatementsEmailStatusCount);
        }

        [Test]
        public void Apply_UnknownPreference_ThrowsException()
        {
            var preference = new MemberPreference
            {
                Preference = (PreferenceType)(Enum.GetValues(typeof(PreferenceType)).Length + 1)
            };

            var thrown = Assert.Throws<InvalidOperationException>(() => _settings.Apply(preference));

            StringAssert.Contains(preference.Preference.ToString(), thrown?.Message);
        }

        private static T RandomEnumValueFactory<T>()
            where T : Enum
        {
            var values = Enum.GetValues(typeof(T)).Cast<T>().ToArray();

            return values[DateTime.Now.Millisecond % values.Length];
        }
    }
}