// Copyright (c) Umbraco.
// See LICENSE for more details.

using System;
using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;
using Umbraco.Cms.Core.Cache;
using Umbraco.Cms.Core.Sync;

namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Cache.DistributedCache
{
    /// <summary>
    /// Ensures that calls to DistributedCache methods carry through to the IServerMessenger correctly
    /// </summary>
    [TestFixture]
    public class DistributedCacheTests
    {
        private global::Umbraco.Cms.Core.Cache.DistributedCache _distributedCache;

        private IServerRoleAccessor ServerRegistrar { get; set; }

        private TestServerMessenger ServerMessenger { get; set; }

        [SetUp]
        public void Setup()
        {
            ServerRegistrar = new TestServerRegistrar();
            ServerMessenger = new TestServerMessenger();

            var cacheRefresherCollection = new CacheRefresherCollection(new[]
            {
                new TestCacheRefresher()
            });

            _distributedCache = new global::Umbraco.Cms.Core.Cache.DistributedCache(ServerMessenger, cacheRefresherCollection);
        }

        [Test]
        public void RefreshIntId()
        {
            for (var i = 1; i < 11; i++)
            {
                _distributedCache.Refresh(Guid.Parse("E0F452CB-DCB2-4E84-B5A5-4F01744C5C73"), i);
            }

            Assert.AreEqual(10, ServerMessenger.IntIdsRefreshed.Count);
        }

        [Test]
        public void RefreshIntIdFromObject()
        {
            for (var i = 0; i < 10; i++)
            {
                _distributedCache.Refresh(
                    Guid.Parse("E0F452CB-DCB2-4E84-B5A5-4F01744C5C73"),
                    x => x.Id,
                    new TestObjectWithId { Id = i });
            }

            Assert.AreEqual(10, ServerMessenger.IntIdsRefreshed.Count);
        }

        [Test]
        public void RefreshGuidId()
        {
            for (var i = 0; i < 11; i++)
            {
                _distributedCache.Refresh(Guid.Parse("E0F452CB-DCB2-4E84-B5A5-4F01744C5C73"), Guid.NewGuid());
            }

            Assert.AreEqual(11, ServerMessenger.GuidIdsRefreshed.Count);
        }

        [Test]
        public void RemoveIds()
        {
            for (var i = 1; i < 13; i++)
            {
                _distributedCache.Remove(Guid.Parse("E0F452CB-DCB2-4E84-B5A5-4F01744C5C73"), i);
            }

            Assert.AreEqual(12, ServerMessenger.IntIdsRemoved.Count);
        }

        [Test]
        public void FullRefreshes()
        {
            for (var i = 0; i < 13; i++)
            {
                _distributedCache.RefreshAll(Guid.Parse("E0F452CB-DCB2-4E84-B5A5-4F01744C5C73"));
            }

            Assert.AreEqual(13, ServerMessenger.CountOfFullRefreshes);
        }

        internal class TestObjectWithId
        {
            public int Id { get; set; }
        }

        internal class TestCacheRefresher : ICacheRefresher
        {
            public static readonly Guid UniqueId = Guid.Parse("E0F452CB-DCB2-4E84-B5A5-4F01744C5C73");

            public Guid RefresherUniqueId => UniqueId;

            public string Name => "Test Cache Refresher";

            public void RefreshAll()
            {
            }

            public void Refresh(int id)
            {
            }

            public void Remove(int id)
            {
            }

            public void Refresh(Guid id)
            {
            }
        }

        internal class TestServerMessenger : IServerMessenger
        {
            // Used for tests
            public List<int> IntIdsRefreshed { get; } = new List<int>();
            public List<Guid> GuidIdsRefreshed { get; } = new List<Guid>();
            public List<int> IntIdsRemoved { get; } = new List<int>();
            public List<string> PayloadsRemoved { get; } = new List<string>();
            public List<string> PayloadsRefreshed { get; } = new List<string>();
            public int CountOfFullRefreshes { get; private set; } = 0;

            public void QueueRefresh<TPayload>(ICacheRefresher refresher, TPayload[] payload)
            {
                // doing nothing
            }

            public void PerformRefresh(ICacheRefresher refresher, string jsonPayload) => PayloadsRefreshed.Add(jsonPayload);

            public void QueueRefresh<T>(ICacheRefresher refresher, Func<T, int> getNumericId, params T[] instances) => IntIdsRefreshed.AddRange(instances.Select(getNumericId));

            public void QueueRefresh<T>(ICacheRefresher refresher, Func<T, Guid> getGuidId, params T[] instances) => GuidIdsRefreshed.AddRange(instances.Select(getGuidId));

            public void PerformRemove(ICacheRefresher refresher, string jsonPayload) => PayloadsRemoved.Add(jsonPayload);

            public void QueueRemove<T>(ICacheRefresher refresher, Func<T, int> getNumericId, params T[] instances) => IntIdsRemoved.AddRange(instances.Select(getNumericId));

            public void QueueRemove(ICacheRefresher refresher, params int[] numericIds) => IntIdsRemoved.AddRange(numericIds);

            public void QueueRefresh(ICacheRefresher refresher, params int[] numericIds) => IntIdsRefreshed.AddRange(numericIds);

            public void QueueRefresh(ICacheRefresher refresher, params Guid[] guidIds) => GuidIdsRefreshed.AddRange(guidIds);

            public void QueueRefreshAll(ICacheRefresher refresher) => CountOfFullRefreshes++;

            public void Sync() { }

            public void SendMessages() { }
        }

        internal class TestServerRegistrar : IServerRoleAccessor
        {
            public IEnumerable<IServerAddress> Registrations => new List<IServerAddress>
            {
                new TestServerAddress("localhost")
            };

            public ServerRole CurrentServerRole => throw new NotImplementedException();
        }

        public class TestServerAddress : IServerAddress
        {
            public TestServerAddress(string address) => ServerAddress = address;

            public string ServerAddress { get; private set; }
        }
    }
}