using Moq;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using LCU.API.Internal.DocumentIngestor.Services;
using LCU.API.Internal.DocumentIngestor.Configurations;
using LCU.API.Internal.DocumentIngestorLib.Repositories;
using LCU.Library.Internal.DocumentIngestorModels.Entities;
using LCU.Library.Internal.DocumentIngestorModels.Enums;
using LCU.Library.Internal.DocumentIngestorModels.Models;
using LCU.Library.Internal.DocumentIngestorModels.Models.Pagination;
using LCU.Library.Internal.Exceptions;

namespace LCU.API.Internal.DocumentIngestorTests.Services;

public class MemberNotificationInfoServiceTest
{
	private MemberNotificationInfoService _memberNotificationInfoService;

	private Mock<IUnitOfWork> _unitOfWork;
	private ApiConfiguration _apiConfiguration;
	private Mock<IMemberNotificationInfoRepository> _mockMemberNotificationInfoRepository;
	private Mock<IProcessingLogService> _mockProcessingLogService;

	[SetUp]
	public void Setup()
	{
		_unitOfWork = new Mock<IUnitOfWork>();
		_apiConfiguration = new ApiConfiguration { BatchSkipAmount = 10000 };
		_mockMemberNotificationInfoRepository = new Mock<IMemberNotificationInfoRepository>();
		_mockProcessingLogService = new Mock<IProcessingLogService>();

		_memberNotificationInfoService = new MemberNotificationInfoService
		(
			_unitOfWork.Object,
			_apiConfiguration,
			_mockMemberNotificationInfoRepository.Object,
			_mockProcessingLogService.Object
		);
	}

	[Test]
	public async Task GetAsync_MemberNotificationInfos_Returned()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var documentProcessingInfos = new List<MemberNotificationInfo>()
		{
			new MemberNotificationInfo()
			{
				MemberNotificationInfoId = memberNotificationInfoId,
				DocumentProcessingInfoId = documentProcessingInfoId,
				UploadDate = Convert.ToDateTime("1/1/2022")
			}
		};
		_mockMemberNotificationInfoRepository.Setup(x => x.FindAsync()).ReturnsAsync(documentProcessingInfos);
		var result = await _memberNotificationInfoService.GetAsync();
		Assert.IsNotNull(result);
		Assert.AreEqual(1, result.Count());
		_mockMemberNotificationInfoRepository.Verify(x => x.FindAsync(), Times.Once);
	}

	[Test]
	public void GetAsync_Exception()
	{
		_mockMemberNotificationInfoRepository.Setup(x => x.FindAsync()).ThrowsAsync(new Exception("Error"));
		Assert.ThrowsAsync<ServiceException>(async () => await _memberNotificationInfoService.GetAsync());
		_mockMemberNotificationInfoRepository.Verify(x => x.FindAsync(), Times.Once);
	}

	[Test]
	public async Task GetByIdAsync_MemberNotificationInfo_Returned()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var memberNotificationInfo = new MemberNotificationInfo()
		{
			MemberNotificationInfoId = memberNotificationInfoId,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = Convert.ToDateTime("1/1/2022")
		};
		_mockMemberNotificationInfoRepository.Setup(x => x.FindByIdAsync(memberNotificationInfoId)).ReturnsAsync(memberNotificationInfo);
		var result = await _memberNotificationInfoService.GetByIdAsync(memberNotificationInfoId);
		Assert.IsNotNull(result);
		Assert.AreEqual(documentProcessingInfoId, result.DocumentProcessingInfoId);
		Assert.AreEqual(memberNotificationInfoId, result.MemberNotificationInfoId);
		_mockMemberNotificationInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
	}

	[Test]
	public void GetByIdAsync_Exception()
	{
		var id = 1;
		_mockMemberNotificationInfoRepository.Setup(x => x.FindByIdAsync(id)).ThrowsAsync(new Exception("Error"));
		Assert.ThrowsAsync<ServiceException>(async () => await _memberNotificationInfoService.GetByIdAsync(id));
		_mockMemberNotificationInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
	}

	[Test]
	public async Task GetByDocumentProcessingInfoIdAsync_MemberNotificationInfos_Returned()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var documentProcessingInfos = new List<MemberNotificationInfo>()
		{
			new MemberNotificationInfo()
			{
				MemberNotificationInfoId = memberNotificationInfoId,
				DocumentProcessingInfoId = documentProcessingInfoId,
				UploadDate = Convert.ToDateTime("1/1/2022")
			}
		};
		_mockMemberNotificationInfoRepository.Setup(x => x.FindByDocumentProcessingInfoIdAsync(documentProcessingInfoId)).ReturnsAsync(documentProcessingInfos);
		var result = await _memberNotificationInfoService.GetByDocumentProcessingInfoIdAsync(documentProcessingInfoId);
		Assert.IsNotNull(result);
		Assert.AreEqual(1, result.Count());
		_mockMemberNotificationInfoRepository.Verify(x => x.FindByDocumentProcessingInfoIdAsync(It.IsAny<int>()), Times.Once);
	}

	[Test]
	public void GetByDocumentProcessingInfoIdAsync_Exception()
	{
		var documentProcessingInfoId = 1;
		_mockMemberNotificationInfoRepository.Setup(x => x.FindByDocumentProcessingInfoIdAsync(documentProcessingInfoId)).ThrowsAsync(new Exception("Error"));
		Assert.ThrowsAsync<ServiceException>(async () => await _memberNotificationInfoService.GetByDocumentProcessingInfoIdAsync(documentProcessingInfoId));
		_mockMemberNotificationInfoRepository.Verify(x => x.FindByDocumentProcessingInfoIdAsync(It.IsAny<int>()), Times.Once);
	}

	[Test]
	public async Task SaveAsync_MemberNotificationInfo_Returned()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var memberNotificationInfo = new MemberNotificationInfo()
		{
			MemberNotificationInfoId = memberNotificationInfoId,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = Convert.ToDateTime("1/1/2022")
		};
		_mockMemberNotificationInfoRepository.Setup(x => x.AddAsync(memberNotificationInfo)).ReturnsAsync(memberNotificationInfo);
		var result = await _memberNotificationInfoService.SaveAsync(memberNotificationInfo);
		Assert.IsNotNull(result);
		Assert.AreEqual(documentProcessingInfoId, result.DocumentProcessingInfoId);
		Assert.AreEqual(memberNotificationInfoId, result.MemberNotificationInfoId);
		_mockMemberNotificationInfoRepository.Verify(x => x.AddAsync(It.IsAny<MemberNotificationInfo>()), Times.Once);
	}

	[Test]
	public void SaveAsync_Exception()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var memberNotificationInfo = new MemberNotificationInfo()
		{
			MemberNotificationInfoId = memberNotificationInfoId,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = Convert.ToDateTime("1/1/2022")
		};
		_mockMemberNotificationInfoRepository.Setup(x => x.AddAsync(memberNotificationInfo)).ThrowsAsync(new Exception("Error"));
		Assert.ThrowsAsync<ServiceException>(async () => await _memberNotificationInfoService.SaveAsync(memberNotificationInfo));
		_mockMemberNotificationInfoRepository.Verify(x => x.AddAsync(It.IsAny<MemberNotificationInfo>()), Times.Once);
	}

	[Test]
	public async Task Update_MemberNotificationInfo_Returned()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var memberNotificationInfo = new MemberNotificationInfo()
		{
			MemberNotificationInfoId = memberNotificationInfoId,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = Convert.ToDateTime("1/1/2022")
		};
		_mockMemberNotificationInfoRepository.Setup(x => x.Update(memberNotificationInfo));

		var result = await _memberNotificationInfoService.Update(memberNotificationInfo);
		Assert.IsNotNull(result);
		Assert.AreEqual(documentProcessingInfoId, result.DocumentProcessingInfoId);
		Assert.AreEqual(memberNotificationInfoId, result.MemberNotificationInfoId);
		_mockMemberNotificationInfoRepository.Verify(x => x.Update(It.IsAny<MemberNotificationInfo>()), Times.Once);
	}

	[Test]
	public void Update_FindByIdAsync_ThrowsException()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var memberNotificationInfo = new MemberNotificationInfo()
		{
			MemberNotificationInfoId = memberNotificationInfoId,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = Convert.ToDateTime("1/1/2022")
		};
		_mockMemberNotificationInfoRepository.Setup(x => x.FindByIdAsync(memberNotificationInfoId)).ThrowsAsync(new Exception("Error"));

		Assert.ThrowsAsync<ServiceException>(async () => await _memberNotificationInfoService.GetByIdAsync(memberNotificationInfo.MemberNotificationInfoId));
		_mockMemberNotificationInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
		_mockMemberNotificationInfoRepository.Verify(x => x.Update(It.IsAny<MemberNotificationInfo>()), Times.Never);
	}

	[Test]
	public void Update_Update_ThrowsException()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var memberNotificationInfo = new MemberNotificationInfo()
		{
			MemberNotificationInfoId = memberNotificationInfoId,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = Convert.ToDateTime("1/1/2022")
		};
		_mockMemberNotificationInfoRepository.Setup(x => x.Update(memberNotificationInfo)).Throws(new Exception("Error"));

		Assert.ThrowsAsync<ServiceException>(async () => await _memberNotificationInfoService.Update(memberNotificationInfo));
		_mockMemberNotificationInfoRepository.Verify(x => x.Update(It.IsAny<MemberNotificationInfo>()), Times.Once);
	}

	[Test]
	public async Task UpdateRange_MemberNotificationInfo_Returned()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var memberNotificationInfos = new List<MemberNotificationInfo>()
		{
			new()
			{
				MemberNotificationInfoId = memberNotificationInfoId,
				DocumentProcessingInfoId = documentProcessingInfoId,
				UploadDate = Convert.ToDateTime("1/1/2022")
			}
		};
		_mockMemberNotificationInfoRepository.Setup(x => x.UpdateRange(memberNotificationInfos));

		var result = await _memberNotificationInfoService.UpdateRange(memberNotificationInfos);
		Assert.IsNotNull(result);
		Assert.AreEqual(documentProcessingInfoId, result.FirstOrDefault()?.DocumentProcessingInfoId);
		Assert.AreEqual(memberNotificationInfoId, result.FirstOrDefault()?.MemberNotificationInfoId);
		_mockMemberNotificationInfoRepository.Verify(x => x.UpdateRange(It.IsAny<IEnumerable<MemberNotificationInfo>>()), Times.Once);
	}

	[Test]
	public void UpdateRange_FindByIdAsync_ThrowsException()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var memberNotificationInfos = new List<MemberNotificationInfo>()
		{
			new()
			{
				MemberNotificationInfoId = memberNotificationInfoId,
				DocumentProcessingInfoId = documentProcessingInfoId,
				UploadDate = Convert.ToDateTime("1/1/2022")
			}
		};
		_mockMemberNotificationInfoRepository.Setup(x => x.FindByIdAsync(memberNotificationInfoId)).ThrowsAsync(new Exception("Error"));

		Assert.ThrowsAsync<ServiceException>(async () => await _memberNotificationInfoService.GetByIdAsync(memberNotificationInfoId));
		_mockMemberNotificationInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
	}

	[Test]
	public void UpdateRange_Update_ThrowsException()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var memberNotificationInfos = new List<MemberNotificationInfo>()
		{
			new()
			{
				MemberNotificationInfoId = memberNotificationInfoId,
				DocumentProcessingInfoId = documentProcessingInfoId,
				UploadDate = Convert.ToDateTime("1/1/2022")
			}
		};
		_mockMemberNotificationInfoRepository.Setup(x => x.UpdateRange(memberNotificationInfos)).Throws(new Exception("Error"));

		Assert.ThrowsAsync<ServiceException>(async () => await _memberNotificationInfoService.UpdateRange(memberNotificationInfos));
		_mockMemberNotificationInfoRepository.Verify(x => x.UpdateRange(It.IsAny<IEnumerable<MemberNotificationInfo>>()), Times.Once);
	}

	[Test]
	public async Task Delete_Success()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var memberNotificationInfo = new MemberNotificationInfo()
		{
			MemberNotificationInfoId = memberNotificationInfoId,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = Convert.ToDateTime("1/1/2022")
		};
		_mockMemberNotificationInfoRepository.Setup(x => x.FindByIdAsync(memberNotificationInfoId)).ReturnsAsync(memberNotificationInfo);
		_mockMemberNotificationInfoRepository.Setup(x => x.Remove(memberNotificationInfo));

		await _memberNotificationInfoService.Delete(memberNotificationInfoId);
		_mockMemberNotificationInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
		_mockMemberNotificationInfoRepository.Verify(x => x.Remove(It.IsAny<MemberNotificationInfo>()), Times.Once);
	}

	[Test]
	public void Delete_FindByIdAsync_ThrowsException()
	{
		var id = 1;
		_mockMemberNotificationInfoRepository.Setup(x => x.FindByIdAsync(id)).ThrowsAsync(new Exception("Error"));

		Assert.ThrowsAsync<ServiceException>(async () => await _memberNotificationInfoService.Delete(id));
		_mockMemberNotificationInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
		_mockMemberNotificationInfoRepository.Verify(x => x.Remove(It.IsAny<MemberNotificationInfo>()), Times.Never);
	}

	[Test]
	public void Delete_Remove_ThrowsException()
	{
		var memberNotificationInfoId = 10;
		var documentProcessingInfoId = 1;
		var memberNotificationInfo = new MemberNotificationInfo()
		{
			MemberNotificationInfoId = memberNotificationInfoId,
			DocumentProcessingInfoId = documentProcessingInfoId,
			UploadDate = Convert.ToDateTime("1/1/2022")
		};
		_mockMemberNotificationInfoRepository.Setup(x => x.FindByIdAsync(memberNotificationInfoId)).ReturnsAsync(memberNotificationInfo);
		_mockMemberNotificationInfoRepository.Setup(x => x.Remove(memberNotificationInfo)).Throws(new Exception("Error"));

		Assert.ThrowsAsync<ServiceException>(async () => await _memberNotificationInfoService.Delete(memberNotificationInfoId));
		_mockMemberNotificationInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
		_mockMemberNotificationInfoRepository.Verify(x => x.Remove(It.IsAny<MemberNotificationInfo>()), Times.Once);
	}

	[Test]
	public async Task SetDocumentNotificationStatus_NotificationInfoDoesntExist_ReturnsFalseAndDoesNotUpdateOrLog()
	{
		var memberNotificationInfo = new MemberNotificationInfo
		{ MemberNotificationInfoId = DateTime.Now.Millisecond };
		var notificationStatus = NotificationStatusTypes.CriticalFailure;
		var userName = Guid.NewGuid().ToString();
		var reason = Guid.NewGuid().ToString();
		_mockMemberNotificationInfoRepository
			.Setup(s => s.FindByIdAsync(memberNotificationInfo.MemberNotificationInfoId))
			.ReturnsAsync((MemberNotificationInfo)null);

		var updated = await _memberNotificationInfoService.SetDocumentNotificationStatus
		(
			memberNotificationInfo.MemberNotificationInfoId,
			notificationStatus,
			userName,
			reason
		);

		Assert.IsFalse(updated);
		_mockMemberNotificationInfoRepository.Verify(r => r.Update(memberNotificationInfo), Times.Never);
		_mockProcessingLogService.Verify(s => s.SaveAsync(It.IsAny<ProcessingLog>()), Times.Never);
	}

	[Test]
	public void SetDocumentNotificationStatus_FindingNotificationInfoThrows_ThrowsServiceException()
	{
		var memberNotificationInfo = new MemberNotificationInfo
		{ MemberNotificationInfoId = DateTime.Now.Millisecond };
		var notificationStatus = NotificationStatusTypes.CriticalFailure;
		var userName = Guid.NewGuid().ToString();
		var reason = Guid.NewGuid().ToString();
		_mockMemberNotificationInfoRepository
			.Setup(s => s.FindByIdAsync(memberNotificationInfo.MemberNotificationInfoId))
			.ThrowsAsync(new Exception());

		var thrown = Assert.ThrowsAsync<ServiceException>(() => _memberNotificationInfoService.SetDocumentNotificationStatus(memberNotificationInfo.MemberNotificationInfoId, notificationStatus, userName, reason));

		StringAssert.Contains(memberNotificationInfo.MemberNotificationInfoId.ToString(), thrown.Message);
		StringAssert.Contains(notificationStatus.ToString(), thrown.Message);
	}

	[Test]
	public async Task SetDocumentNotificationStatus_SetStatusThrows_ThrowsServiceExceptionAndDoesNotLog()
	{
		var notificationStatus = NotificationStatusTypes.CriticalFailure;
		var memberNotificationInfo = new MemberNotificationInfo
		{
			MemberNotificationInfoId = DateTime.Now.Millisecond,
			DocumentProcessingInfoId = DateTime.Now.Millisecond + 1,
			NotificationStatusType = notificationStatus + 1
		};
		var userName = Guid.NewGuid().ToString();
		var reason = Guid.NewGuid().ToString();
		var processingLogs = new List<ProcessingLog>();
		_mockMemberNotificationInfoRepository
			.Setup(s => s.FindByIdAsync(memberNotificationInfo.MemberNotificationInfoId))
			.ReturnsAsync(memberNotificationInfo);
		_mockMemberNotificationInfoRepository
			.Setup(r => r.Update(memberNotificationInfo))
			.Throws(new Exception());
		_mockProcessingLogService
			.Setup(s => s.SaveAsync(It.IsAny<ProcessingLog>()))
			.Callback<ProcessingLog>(processingLogs.Add);

		var thrown = Assert.ThrowsAsync<ServiceException>(() => _memberNotificationInfoService.SetDocumentNotificationStatus(memberNotificationInfo.MemberNotificationInfoId, notificationStatus, userName, reason));

		StringAssert.Contains(memberNotificationInfo.MemberNotificationInfoId.ToString(), thrown.Message);
		StringAssert.Contains(notificationStatus.ToString(), thrown.Message);
		CollectionAssert.IsEmpty(processingLogs);
	}

	[Test]
	public async Task SetDocumentNotificationStatus_SetStatusSuccess_LogsChange()
	{
		var notificationStatus = NotificationStatusTypes.CriticalFailure;
		var originalNotificationStatus = notificationStatus + 1;
		var memberNotificationInfo = new MemberNotificationInfo
		{
			MemberNotificationInfoId = DateTime.Now.Millisecond,
			DocumentProcessingInfoId = DateTime.Now.Millisecond + 1,
			NotificationStatusType = originalNotificationStatus
		};
		var userName = Guid.NewGuid().ToString();
		var reason = Guid.NewGuid().ToString();
		var processingLogs = new List<ProcessingLog>();
		_mockMemberNotificationInfoRepository
			.Setup(s => s.FindByIdAsync(memberNotificationInfo.MemberNotificationInfoId))
			.ReturnsAsync(memberNotificationInfo);
		_mockProcessingLogService
			.Setup(s => s.SaveAsync(It.IsAny<ProcessingLog>()))
			.Callback<ProcessingLog>(processingLogs.Add);
		var testStart = DateTime.UtcNow;

		await _memberNotificationInfoService.SetDocumentNotificationStatus
		(
			memberNotificationInfo.MemberNotificationInfoId,
			notificationStatus,
			userName,
			reason
		);

		var testEnd = DateTime.UtcNow;
		Assert.AreEqual(1, processingLogs.Count);
		var log = processingLogs.Single();
		Assert.AreEqual(memberNotificationInfo.DocumentProcessingInfoId, log.DocumentProcessingInfoId);
		Assert.That(log.LogTimeStamp, Is.InRange(testStart, testEnd));
		StringAssert.Contains(originalNotificationStatus.ToString(), log.LogMessage);
		StringAssert.Contains(notificationStatus.ToString(), log.LogMessage);
		StringAssert.Contains(reason, log.LogMessage);
	}

	[Test]
	public async Task SetDocumentNotificationStatus_LoggingChangeThrows_ThrowsServiceException()
	{
		var notificationStatus = NotificationStatusTypes.CriticalFailure;
		var memberNotificationInfo = new MemberNotificationInfo
		{
			MemberNotificationInfoId = DateTime.Now.Millisecond,
			NotificationStatusType = notificationStatus + 1
		};
		var userName = Guid.NewGuid().ToString();
		var reason = Guid.NewGuid().ToString();
		_mockMemberNotificationInfoRepository
			.Setup(s => s.FindByIdAsync(memberNotificationInfo.MemberNotificationInfoId))
			.ReturnsAsync(memberNotificationInfo);
		_mockProcessingLogService
			.Setup(s => s.SaveAsync(It.IsAny<ProcessingLog>()))
			.ThrowsAsync(new Exception());

		var thrown = Assert.ThrowsAsync<ServiceException>(() => _memberNotificationInfoService.SetDocumentNotificationStatus(memberNotificationInfo.MemberNotificationInfoId, notificationStatus, userName, reason));

		StringAssert.Contains(memberNotificationInfo.MemberNotificationInfoId.ToString(), thrown.Message);
		StringAssert.Contains(notificationStatus.ToString(), thrown.Message);
	}

	[Test]
	public async Task SetDocumentNotificationStatus_SetStatusSuccessAndLogSuccess_ReturnsTrue()
	{
		var notificationStatus = NotificationStatusTypes.CriticalFailure;
		var notificationInfo = new MemberNotificationInfo
		{
			MemberNotificationInfoId = DateTime.Now.Millisecond,
			DocumentProcessingInfoId = DateTime.Now.Millisecond + 1,
			NotificationStatusType = notificationStatus
		};
		var newNotificationStatus = notificationStatus + 1;
		var userName = Guid.NewGuid().ToString();
		var reason = Guid.NewGuid().ToString();
		var processingLogs = new List<ProcessingLog>();
		_mockMemberNotificationInfoRepository
			.Setup(s => s.FindByIdAsync(notificationInfo.MemberNotificationInfoId))
			.ReturnsAsync(notificationInfo);
		_mockMemberNotificationInfoRepository
			.Setup(r => r.Update(notificationInfo))
			.Callback<MemberNotificationInfo>(returnedUpdated =>
				returnedUpdated.NotificationStatusType = notificationInfo.NotificationStatusType);
		_mockProcessingLogService
			.Setup(s => s.SaveAsync(It.IsAny<ProcessingLog>()))
			.Callback<ProcessingLog>(processingLogs.Add);

		var updated = await _memberNotificationInfoService.SetDocumentNotificationStatus
		(
			notificationInfo.MemberNotificationInfoId,
			newNotificationStatus,
			userName,
			reason
		);

		Assert.IsTrue(updated);
		Assert.AreEqual(newNotificationStatus, notificationInfo.NotificationStatusType);
		Assert.AreEqual(1, processingLogs.Count);
	}

	[Test]
	public async Task BulkSetDocumentNotificationStatus_Success()
	{
		var notificationInfos = new List<MemberNotificationInfo>
		{
			new()
			{
				DocumentProcessingInfoId = DateTime.Now.Millisecond,
				NotificationStatusType = NotificationStatusTypes.CriticalFailure
			},
			new()
			{
				DocumentProcessingInfoId = DateTime.Now.Millisecond + 1,
				NotificationStatusType = NotificationStatusTypes.CriticalFailure
			},
		};

		var request = new BulkNotificationStatusRequest
		{
			Filter = new()
			{
				NotificationStatusFilters = new List<NotificationStatusTypes>
				{
					NotificationStatusTypes.CriticalFailure
				}
			},
			NotificationStatus = NotificationStatusTypes.Complete,
			ReasonMessage = Guid.NewGuid().ToString()
		};
		var userName = Guid.NewGuid().ToString();

		_mockMemberNotificationInfoRepository
			.Setup(s => s.GetMemberNotificationInfosByFilter(request.Filter))
			.ReturnsAsync(notificationInfos);
		_mockMemberNotificationInfoRepository
			.Setup(r => r.UpdateRange(notificationInfos));
		_mockProcessingLogService
			.Setup(s => s.SaveRangeAsync(It.IsAny<IEnumerable<ProcessingLog>>()));

		var updated = await _memberNotificationInfoService.BulkSetDocumentNotificationStatus(request, userName);

		Assert.IsTrue(updated);
		Assert.AreEqual(request.NotificationStatus, notificationInfos[0].NotificationStatusType);
		Assert.AreEqual(request.NotificationStatus, notificationInfos[1].NotificationStatusType);

		_mockMemberNotificationInfoRepository.Verify(x => x.GetMemberNotificationInfosByFilter(It.IsAny<Filter>()), Times.Once);
		_mockMemberNotificationInfoRepository.Verify(x => x.UpdateRange(It.IsAny<IEnumerable<MemberNotificationInfo>>()), Times.Once);
		_mockProcessingLogService.Verify(x => x.SaveRangeAsync(It.IsAny<IEnumerable<ProcessingLog>>()), Times.Once);
	}

	[Test]
	public async Task BulkSetDocumentNotificationStatus_Bulk_Success()
	{
		var repeatAmount = 15000;
		var randomInt = new Random();
		var notificationInfos = Enumerable.Repeat(1, repeatAmount)
			.Select(_ => new MemberNotificationInfo
			{
				DocumentProcessingInfoId = randomInt.Next(1, repeatAmount),
				NotificationStatusType = NotificationStatusTypes.CriticalFailure
			}).ToList();

		var request = new BulkNotificationStatusRequest
		{
			Filter = new()
			{
				NotificationStatusFilters = new List<NotificationStatusTypes>
				{
					NotificationStatusTypes.CriticalFailure
				}
			},
			NotificationStatus = NotificationStatusTypes.Complete,
			ReasonMessage = Guid.NewGuid().ToString()
		};
		var userName = Guid.NewGuid().ToString();

		_mockMemberNotificationInfoRepository
			.Setup(s => s.GetMemberNotificationInfosByFilter(request.Filter))
			.ReturnsAsync(notificationInfos);
		_mockMemberNotificationInfoRepository.Setup(s =>
			s.UpdateRange(It.IsAny<IEnumerable<MemberNotificationInfo>>()));
		_mockProcessingLogService
			.Setup(s => s.SaveRangeAsync(It.IsAny<IEnumerable<ProcessingLog>>()));

		Assert.IsTrue(await _memberNotificationInfoService.BulkSetDocumentNotificationStatus(request, userName));

		_mockMemberNotificationInfoRepository.Verify(x => x.GetMemberNotificationInfosByFilter(It.IsAny<Filter>()), Times.Once);
		_mockMemberNotificationInfoRepository.Verify(x => x.UpdateRange(It.IsAny<IEnumerable<MemberNotificationInfo>>()), Times.Exactly(2));
		_mockProcessingLogService.Verify(x => x.SaveRangeAsync(It.IsAny<IEnumerable<ProcessingLog>>()), Times.Exactly(2));
	}

	[Test]
	public Task BulkSetDocumentNotificationStatus_Failure_ServiceException()
	{
		var request = new BulkNotificationStatusRequest
		{
			Filter = new()
			{
				NotificationStatusFilters = new List<NotificationStatusTypes>
				{
					NotificationStatusTypes.CriticalFailure
				}
			},
			NotificationStatus = NotificationStatusTypes.Complete,
			ReasonMessage = Guid.NewGuid().ToString()
		};
		var userName = Guid.NewGuid().ToString();

		_mockMemberNotificationInfoRepository
			.Setup(s => s.GetMemberNotificationInfosByFilter(request.Filter))
			.ThrowsAsync(new Exception());

		Assert.ThrowsAsync<ServiceException>(() => _memberNotificationInfoService.BulkSetDocumentNotificationStatus(request, userName));

		_mockMemberNotificationInfoRepository.Verify(x => x.GetMemberNotificationInfosByFilter(It.IsAny<Filter>()), Times.Once);
		_mockMemberNotificationInfoRepository.Verify(x => x.UpdateRange(It.IsAny<IEnumerable<MemberNotificationInfo>>()), Times.Never);
		_mockProcessingLogService.Verify(x => x.SaveRangeAsync(It.IsAny<IEnumerable<ProcessingLog>>()), Times.Never);
		return Task.CompletedTask;
	}
}