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.AspNetCore.Identity;
using Microsoft.Extensions.Logging;
using NSubstitute.ReturnsExtensions;
using System.Diagnostics;

namespace Diligent.WebAPI.Tests.Services
{
    public class SelectionProcessServiceTests
    {
        private readonly IMapper _mapper;
        private readonly List<SelectionProcess> _processes;
        private readonly SelectionProcess _selectionProcess;
        private readonly StatusChangeDTO _statusChangeDTO;
        private readonly InterviewerUpdateDTO _interviewerUpdateDTO;
        private readonly User _user;
        private readonly User _userId2;
        private readonly SelectionProcessUpdateStatusDto _selectionProcessUpdateStatusDto;
        private ILogger<SelectionProcessService> _logger = Substitute.For<ILogger<SelectionProcessService>>();
        private readonly SelectionProcessCreateDto _selectionProcessCreateDto;
        private readonly IUserStore<User> _mockStore = Substitute.For<IUserStore<User>>();
        private readonly UserManager<User> _userManager;
        
        public SelectionProcessServiceTests()
        {
            _userManager = Substitute.For<UserManager<User>>(_mockStore, null, null, null, null, null, null, null, null);
            _selectionProcessCreateDto = new SelectionProcessCreateDto
            {
                Id = 1,
                ApplicantId = 1,
                Date = DateTime.Now,
                Link = "link",
                Name = "custom name",
                SchedulerId = 1,
                SelectionLevelId = 4,
                Status = "Obrađen"
            };
            _selectionProcessUpdateStatusDto = new SelectionProcessUpdateStatusDto
            {
                Status = "Ceka na zakazivanje"
            };
            _selectionProcess = new SelectionProcess
            {
                Id = 1,
                ApplicantId = 1,
                Date = DateTime.Now,
                Link = "link",
                Name = "custom name",
                SchedulerId = 1,
                SelectionLevelId = 4,
                Status = "Obrađen"
            };
            _statusChangeDTO = new StatusChangeDTO
            {
                ProcessId = 1,
                Appointment = DateTime.Today,
                NewStatus = "Zakazan",
                SchedulerId = 1
            };

            _user = new User
            {
                Id = 1,
                PasswordHash = "AQAAAAEAACcQAAAAEJnWVhD/qftzqJq5XOUD0BxEBEwhd7vS46HeDD+9cwEsqO9ev9xEORJVjmFMASUGJg==",
                FirstName = "Dzenis",
                LastName = "Dzenis",
                UserName = "dzenis",
                NormalizedUserName = "DZENIS",
                Email = "dzenis@dilig.net",
                NormalizedEmail = "DZENIS@DILIG.NET",
                EmailConfirmed = false,
                IsEnabled = true,
                AccessFailedCount = 0,
                SecurityStamp = "2D3XPK2P5MAKO377AWFU3T4ZFFYTSOJX",
                ConcurrencyStamp = "2D3XPK2P5MAKO377AWFU3T4ZFFYTSOJX",
            };

            _userId2 = new User
            {
                Id = 2,
                PasswordHash = "AQAAAAEAACcQAAAAEJnWVhD/qftzqJq5XOUD0BxEBEwhd7vS46HeDD+9cwEsqO9ev9xEORJVjmFMASUGJg==",
                FirstName = "Meris",
                LastName = "Ahmatovic",
                UserName = "merisa",
                NormalizedUserName = "MERIS",
                Email = "meris@dilig.net",
                NormalizedEmail = "MERIS@DILIG.NET",
                EmailConfirmed = false,
                IsEnabled = true,
                AccessFailedCount = 0,
                SecurityStamp = "2D3XPK2P5MAKO377AWFU3T4ZFFYTSOJX",
                ConcurrencyStamp = "2D3XPK2P5MAKO377AWFU3T4ZFFYTSOJX",
            };
            _interviewerUpdateDTO = new InterviewerUpdateDTO
            {
                ProcessId = 1,
                SchedulerId = 2
            };
            _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(_userManager, databaseContext, _mapper, _logger);

            var result = await service.GetAllAsync();

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

        [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(_userManager, 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(_userManager, 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(_userManager, databaseContext, _mapper, _logger);

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

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

            await service.UpdateSelectionProcessStatusAsync(1, _selectionProcessUpdateStatusDto);

            _selectionProcess.Status.Should().Be("Ceka na zakazivanje");
        }

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

            await Assert.ThrowsAsync<EntityNotFoundException>(async () => await service.UpdateSelectionProcessStatusAsync(1000,_selectionProcessUpdateStatusDto));
        }

        [Fact]
        public async Task StatusUpdate_ShouldUpdateStatusOfProcess_WhenProcessExists()
        {
            _userManager.FindByIdAsync(Arg.Any<string>()).Returns(_user);
            var databaseContext = await Helpers<SelectionProcess>.GetDatabaseContext(_processes);
            SelectionProcessService service = new(_userManager, databaseContext, _mapper, _logger);

            await service.StatusUpdate(_statusChangeDTO);

            _selectionProcess.Status.Should().Be("Zakazan");
            _selectionProcess.Date.Should().Be(DateTime.Today);
            _selectionProcess.SchedulerId.Should().Be(1);
        }

        [Fact]
        public async Task StatusUpdate_ShouldThrowEntityNotFooundException_WhenUserDoesNotExist()
        {
            _userManager.FindByIdAsync(Arg.Any<string>()).ReturnsNull();
            var databaseContext = await Helpers<SelectionProcess>.GetDatabaseContext(_processes);
            SelectionProcessService service = new(_userManager, databaseContext, _mapper, _logger);

            await Assert.ThrowsAsync<EntityNotFoundException>(async () => await service.StatusUpdate(_statusChangeDTO));

        }

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

            await Assert.ThrowsAsync<EntityNotFoundException>(async () => await service.StatusUpdate(new StatusChangeDTO { ProcessId = 1000 }));
        }

        [Fact]
        public async Task InterviewerUpdate_ShouldUpdateStatusOfProcess_WhenProcessExists()
        {
            _userManager.FindByIdAsync(Arg.Any<string>()).Returns(_userId2);
            var databaseContext = await Helpers<SelectionProcess>.GetDatabaseContext(_processes);
            SelectionProcessService service = new(_userManager, databaseContext, _mapper, _logger);

            await service.InterviewerUpdate(_interviewerUpdateDTO);

            _selectionProcess.SchedulerId.Should().Be(2);
        }

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

            await Assert.ThrowsAsync<EntityNotFoundException>(async () => await service.InterviewerUpdate(new InterviewerUpdateDTO { ProcessId = 1000, SchedulerId = 2 }));
        }

        [Fact]
        public async Task InterviewerUpdate_ShouldThrowEntityNotFooundException_WhenUserDoesnotExist()
        {
            _userManager.FindByIdAsync(Arg.Any<string>()).ReturnsNull();
            var databaseContext = await Helpers<SelectionProcess>.GetDatabaseContext(_processes);
            SelectionProcessService service = new(_userManager,databaseContext, _mapper, _logger);

            await Assert.ThrowsAsync<EntityNotFoundException>(async () => await service.InterviewerUpdate(_interviewerUpdateDTO));
        }
    }
}