using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Linq;
using Moq;
using NUnit.Framework;
using LCU.Library.Internal.DocumentIngestorModels.Entities;
using LCU.Library.Internal.Exceptions;
using LCU.API.Internal.DocumentIngestor.Services;
using LCU.API.Internal.DocumentIngestorLib.Repositories;
namespace LCU.API.Internal.DocumentIngestorTests.Services;

public class ProcessingLogServiceTest
{
	private ProcessingLogService _processingLogService;
	private Mock<IUnitOfWork> _unitOfWork;
	private Mock<IProcessingLogRepository> _mockProcessingLogRepository;

	[SetUp]
	public void Setup()
	{
		_unitOfWork = new Mock<IUnitOfWork>();
		_mockProcessingLogRepository = new Mock<IProcessingLogRepository>();
		_processingLogService = new ProcessingLogService(_unitOfWork.Object, _mockProcessingLogRepository.Object);
	}

	[Test]
	public async Task GetAsync_ProcessingLogs_Returned()
	{
		var documentProcessingInfoId = 1;
		var processingLogId = 2;
		var processingLogs = new List<ProcessingLog>()
		{
			new ProcessingLog()
			{
				ProcessingLogId = processingLogId,
				DocumentProcessingInfoId = documentProcessingInfoId
			}
		};
		_mockProcessingLogRepository.Setup(x => x.FindAsync()).ReturnsAsync(processingLogs);
		var result = await _processingLogService.GetAsync();
		Assert.IsNotNull(result);
		Assert.AreEqual(1, result.Count());
		_mockProcessingLogRepository.Verify(x => x.FindAsync(), Times.Once);
	}

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

	[Test]
	public async Task GetByIdAsync_ProcessingLog_Returned()
	{
		var documentProcessingInfoId = 1;
		var processingLogId = 2;
		var processingLog = new ProcessingLog()
		{
			ProcessingLogId = processingLogId,
			DocumentProcessingInfoId = documentProcessingInfoId
		};
		_mockProcessingLogRepository.Setup(x => x.FindByIdAsync(processingLogId)).ReturnsAsync(processingLog);
		var result = await _processingLogService.GetByIdAsync(processingLogId);
		Assert.IsNotNull(result);
		Assert.AreEqual(documentProcessingInfoId, result.DocumentProcessingInfoId);
		Assert.AreEqual(processingLogId, result.ProcessingLogId);
		_mockProcessingLogRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
	}

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

	[Test]
	public async Task GetByDocumentProcessingInfoIdAsync_ProcessingLogs_Returned()
	{
		var documentProcessingInfoId = 1;
		var processingLogId = 2;
		var processingLogs = new List<ProcessingLog>()
		{
			new ProcessingLog()
			{
				ProcessingLogId = processingLogId,
				DocumentProcessingInfoId = documentProcessingInfoId
			}
		};
		_mockProcessingLogRepository.Setup(x => x.FindByDocumentProcessingInfoIdAsync(documentProcessingInfoId)).ReturnsAsync(processingLogs);
		var result = await _processingLogService.GetByDocumentProcessingInfoIdAsync(documentProcessingInfoId);
		Assert.IsNotNull(result);
		Assert.AreEqual(1, result.Count());
		_mockProcessingLogRepository.Verify(x => x.FindByDocumentProcessingInfoIdAsync(It.IsAny<int>()), Times.Once);
	}

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

	[Test]
	public async Task SaveAsync_ProcessingLog_Returned()
	{
		var documentProcessingInfoId = 1;
		var processingLogId = 2;
		var processingLog = new ProcessingLog()
		{
			ProcessingLogId = processingLogId,
			DocumentProcessingInfoId = documentProcessingInfoId
		};
		_mockProcessingLogRepository.Setup(x => x.AddAsync(processingLog)).ReturnsAsync(processingLog);
		var result = await _processingLogService.SaveAsync(processingLog);
		Assert.IsNotNull(result);
		Assert.AreEqual(documentProcessingInfoId, result.DocumentProcessingInfoId);
		Assert.AreEqual(processingLogId, result.ProcessingLogId);
		_mockProcessingLogRepository.Verify(x => x.AddAsync(It.IsAny<ProcessingLog>()), Times.Once);
	}

	[Test]
	public void SaveAsync_Exception()
	{
		var documentProcessingInfoId = 1;
		var processingLogId = 2;
		var processingLog = new ProcessingLog()
		{
			ProcessingLogId = processingLogId,
			DocumentProcessingInfoId = documentProcessingInfoId
		};
		_mockProcessingLogRepository.Setup(x => x.AddAsync(processingLog)).ThrowsAsync(new Exception("Error"));
		Assert.ThrowsAsync<ServiceException>(async () => await _processingLogService.SaveAsync(processingLog));
		_mockProcessingLogRepository.Verify(x => x.AddAsync(It.IsAny<ProcessingLog>()), Times.Once);
	}

	[Test]
	public async Task SaveRangeAsync_ProcessingLog_Returned()
	{
		var processingLogs = new List<ProcessingLog>
		{
			new()
			{
				ProcessingLogId = DateTime.Now.Millisecond,
				DocumentProcessingInfoId = DateTime.Now.Millisecond
			},
			new()
			{
				ProcessingLogId = DateTime.Now.Millisecond + 1,
				DocumentProcessingInfoId = DateTime.Now.Millisecond
			},
			new()
			{
				ProcessingLogId = DateTime.Now.Millisecond + 2,
				DocumentProcessingInfoId = DateTime.Now.Millisecond
			}
		};
		_mockProcessingLogRepository.Setup(x => x.AddRangeAsync(processingLogs));
		await _processingLogService.SaveRangeAsync(processingLogs);
		_mockProcessingLogRepository.Verify(x => x.AddRangeAsync(It.IsAny<IEnumerable<ProcessingLog>>()), Times.Once);
	}

	[Test]
	public void SaveRangeAsync_Exception()
	{
		var processingLogs = new List<ProcessingLog>
		{
			new()
			{
				ProcessingLogId = DateTime.Now.Millisecond,
				DocumentProcessingInfoId = DateTime.Now.Millisecond
			},
			new()
			{
				ProcessingLogId = DateTime.Now.Millisecond + 1,
				DocumentProcessingInfoId = DateTime.Now.Millisecond
			},
			new()
			{
				ProcessingLogId = DateTime.Now.Millisecond + 2,
				DocumentProcessingInfoId = DateTime.Now.Millisecond
			}
		};
		_mockProcessingLogRepository.Setup(x => x.AddRangeAsync(processingLogs)).ThrowsAsync(new Exception("Error"));
		Assert.ThrowsAsync<ServiceException>(async () => await _processingLogService.SaveRangeAsync(processingLogs));
		_mockProcessingLogRepository.Verify(x => x.AddRangeAsync(It.IsAny<IEnumerable<ProcessingLog>>()), Times.Once);
	}

	[Test]
	public async Task Update_ProcessingLog_Returned()
	{
		var documentProcessingInfoId = 1;
		var processingLogId = 2;
		var processingLog = new ProcessingLog()
		{
			ProcessingLogId = processingLogId,
			DocumentProcessingInfoId = documentProcessingInfoId
		};
		_mockProcessingLogRepository.Setup(x => x.FindByIdAsync(processingLogId)).ReturnsAsync(processingLog);
		_mockProcessingLogRepository.Setup(x => x.Update(processingLog));

		var result = await _processingLogService.Update(processingLog);
		Assert.IsNotNull(result);
		Assert.AreEqual(documentProcessingInfoId, result.DocumentProcessingInfoId);
		Assert.AreEqual(processingLogId, result.ProcessingLogId);
		_mockProcessingLogRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
		_mockProcessingLogRepository.Verify(x => x.Update(It.IsAny<ProcessingLog>()), Times.Once);
	}

	[Test]
	public void Update_FindByIdAsync_ThrowsException()
	{
		var documentProcessingInfoId = 1;
		var processingLogId = 2;
		var processingLog = new ProcessingLog()
		{
			ProcessingLogId = processingLogId,
			DocumentProcessingInfoId = documentProcessingInfoId
		};
		_mockProcessingLogRepository.Setup(x => x.FindByIdAsync(processingLogId)).ThrowsAsync(new Exception("Error"));

		Assert.ThrowsAsync<ServiceException>(async () => await _processingLogService.Update(processingLog));
		_mockProcessingLogRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
		_mockProcessingLogRepository.Verify(x => x.Update(It.IsAny<ProcessingLog>()), Times.Never);
	}

	[Test]
	public void Update_Update_ThrowsException()
	{
		var documentProcessingInfoId = 1;
		var processingLogId = 2;
		var processingLog = new ProcessingLog()
		{
			ProcessingLogId = processingLogId,
			DocumentProcessingInfoId = documentProcessingInfoId
		};
		_mockProcessingLogRepository.Setup(x => x.FindByIdAsync(processingLogId)).ReturnsAsync(processingLog);
		_mockProcessingLogRepository.Setup(x => x.Update(processingLog)).Throws(new Exception("Error"));

		Assert.ThrowsAsync<ServiceException>(async () => await _processingLogService.Update(processingLog));
		_mockProcessingLogRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
		_mockProcessingLogRepository.Verify(x => x.Update(It.IsAny<ProcessingLog>()), Times.Once);
	}

	[Test]
	public async Task Delete_Success()
	{
		var documentProcessingInfoId = 1;
		var processingLogId = 2;
		var processingLog = new ProcessingLog()
		{
			ProcessingLogId = processingLogId,
			DocumentProcessingInfoId = documentProcessingInfoId
		};
		_mockProcessingLogRepository.Setup(x => x.FindByIdAsync(processingLogId)).ReturnsAsync(processingLog);
		_mockProcessingLogRepository.Setup(x => x.Remove(processingLog));

		await _processingLogService.Delete(processingLogId);
		_mockProcessingLogRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
		_mockProcessingLogRepository.Verify(x => x.Remove(It.IsAny<ProcessingLog>()), Times.Once);
	}

	[Test]
	public void Delete_FindByIdAsync_ThrowsException()
	{
		var documentProcessingInfoId = 1;
		var processingLogId = 2;
		var processingLog = new ProcessingLog()
		{
			ProcessingLogId = processingLogId,
			DocumentProcessingInfoId = documentProcessingInfoId
		};
		_mockProcessingLogRepository.Setup(x => x.FindByIdAsync(processingLogId)).ThrowsAsync(new Exception("Error"));

		Assert.ThrowsAsync<ServiceException>(async () => await _processingLogService.Delete(processingLogId));
		_mockProcessingLogRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
		_mockProcessingLogRepository.Verify(x => x.Remove(It.IsAny<ProcessingLog>()), Times.Never);
	}

	[Test]
	public void Delete_Remove_ThrowsException()
	{
		var documentProcessingInfoId = 1;
		var processingLogId = 2;
		var processingLog = new ProcessingLog()
		{
			ProcessingLogId = processingLogId,
			DocumentProcessingInfoId = documentProcessingInfoId
		};
		_mockProcessingLogRepository.Setup(x => x.FindByIdAsync(processingLogId)).ReturnsAsync(processingLog);
		_mockProcessingLogRepository.Setup(x => x.Remove(processingLog)).Throws(new Exception("Error"));

		Assert.ThrowsAsync<ServiceException>(async () => await _processingLogService.Delete(processingLogId));
		_mockProcessingLogRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
		_mockProcessingLogRepository.Verify(x => x.Remove(It.IsAny<ProcessingLog>()), Times.Once);
	}
}