using AutoMapper;
using Diligent.WebAPI.Business.MappingProfiles;
using Diligent.WebAPI.Business.Services;
using Diligent.WebAPI.Contracts.DTOs.SelectionLevel;
using Diligent.WebAPI.Contracts.DTOs.SelectionProcess;
using Diligent.WebAPI.Contracts.Exceptions;
using Diligent.WebAPI.Data.Entities;
using Microsoft.Extensions.Logging;

namespace Diligent.WebAPI.Tests.Services
{
    public class SelectionProcessServiceTests
    {
        private readonly IMapper _mapper;
        private readonly List<SelectionProcess> _processes;
        private readonly SelectionProcess _selectionProcess;
        private ILogger<SelectionProcessService> _logger = Substitute.For<ILogger<SelectionProcessService>>();
        private readonly SelectionProcessCreateDto _selectionProcessCreateDto;
        public SelectionProcessServiceTests()
        {
            _selectionProcessCreateDto = new SelectionProcessCreateDto
            {
                Id = 1,
                ApplicantId = 1,
                Date = DateTime.Now,
                Link = "link",
                Name = "custom name",
                SchedulerId = 1,
                SelectionLevelId = 4,
                Status = "Obrađen"
            };
            _selectionProcess = new SelectionProcess
            {
                Id = 1,
                ApplicantId = 1,
                Date = DateTime.Now,
                Link = "link",
                Name = "custom name",
                SchedulerId = 1,
                SelectionLevelId = 4,
                Status = "Obrađen"
            };

            _processes = new List<SelectionProcess>
            {
                _selectionProcess
            };

            // configure mapper
            var configuration = new MapperConfiguration(cfg => cfg.AddProfiles(
                new List<Profile>
            {
                new SelectionProcessMappingProfile(),
            }));
            _mapper = new Mapper(configuration);
        }

        [Fact]
        public async Task GetAll_ShouldReturnListOfProcesses_Always()
        {
            var databaseContext = await Helpers<SelectionProcess>.GetDatabaseContext(_processes);
            SelectionProcessService service = new(databaseContext, _mapper, _logger);

            var result = await service.GetAllAsync();

            result.Should().HaveCount(1);
        }

        //[Fact]
        //public async Task GetById_ShouldReturnProcess_WhenProcessExist()
        //{
        //    var databaseContext = await Helpers<SelectionProcess>.GetDatabaseContext(_processes);
        //    SelectionProcessService service = new(databaseContext, _mapper, _logger);

        //    var result = await service.GetByIdAsync(1);

        //    result.Should().BeEquivalentTo(_mapper.Map<SelectionProcessResposneDto>(_selectionProcess));
        //}

        //[Fact]
        //public async Task GetById_ShouldThrowEntityNotFooundException_WhenProcessDoesnotExist()
        //{
        //    var databaseContext = await Helpers<SelectionProcess>.GetDatabaseContext(_processes);
        //    SelectionProcessService service = new(databaseContext, _mapper, _logger);

        //    await Assert.ThrowsAsync<EntityNotFoundException>(async () => await service.GetByIdAsync(1000));
        //}

        [Fact]
        public async Task FinishSelectionProcess_ShouldReturnTrueAndAddNewSelectionProcess_WhenProcessExists()
        {
            var process = new SelectionProcess
            {
                Id = 1,
                ApplicantId = 1,
                Date = DateTime.Now,
                Link = "link",
                Name = "custom name",
                SchedulerId = 1,
                SelectionLevelId = 1,
                Status = "Zakazan"
            };

            var processes = new List<SelectionProcess>
            {
                process
            };

            var databaseContext = await Helpers<SelectionProcess>.GetDatabaseContext(processes);
            SelectionProcessService service = new(databaseContext, _mapper, _logger);
            var result = await service.FinishSelectionProcess(_selectionProcessCreateDto);
            var newProcesses = await service.GetAllAsync();
            
            result.Should().BeTrue();
            newProcesses.Should().HaveCount(processes.Count() + 1);
        }

        [Fact]
        public async Task FinishSelectionProcess_ShouldThrowEntityNotFooundException_WhenProcessDoesnotExist()
        {
            var databaseContext = await Helpers<SelectionProcess>.GetDatabaseContext(_processes);
            SelectionProcessService service = new(databaseContext, _mapper, _logger);

            await Assert.ThrowsAsync<EntityNotFoundException>(async () => await service.FinishSelectionProcess(new SelectionProcessCreateDto { Id = 1000 }));
        }

        [Fact]
        public async Task FinishSelectionProcess_ShouldThrowEntityNotFooundException_WhenProcessIsInLastLevel()
        {
            var databaseContext = await Helpers<SelectionProcess>.GetDatabaseContext(_processes);
            SelectionProcessService service = new(databaseContext, _mapper, _logger);

            await Assert.ThrowsAsync<InvalidOperationException>(async () => await service.FinishSelectionProcess(new SelectionProcessCreateDto { Id = 1, SelectionLevelId = 4 }));
        }
    }
}