using AutoMapper;
using Diligent.WebAPI.Business.MappingProfiles;
using Diligent.WebAPI.Business.Services;
using Diligent.WebAPI.Business.Settings;
using Diligent.WebAPI.Contracts.DTOs;
using Diligent.WebAPI.Contracts.DTOs.User;
using Diligent.WebAPI.Data;
using Diligent.WebAPI.Data.Entities;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using NSubstitute;

namespace Diligent.WebAPI.Tests.Services
{
    public class UserServiceTests
    {

        private readonly List<User> _users;
        private readonly User _user;
        private readonly IMapper _mapper;
        private readonly IUserStore<User> _mockStore;
        private readonly UserManager<User> _mockUserManager;
        private readonly ILogger<UserService> _logger;


        public UserServiceTests()
        {
            _mockStore = Substitute.For<IUserStore<User>>();
            _mockUserManager = Substitute.For<UserManager<User>>(_mockStore, null, null, null, null, null, null, null, null);
            _logger = Substitute.For<ILogger<UserService>>();

            _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",
            };

            _users = new List<User>
            {
                _user
            };

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

            _mapper = new Mapper(configuration);
        }

        [Fact]
        public async Task GetById_ShouldReturnUser()
        {
            _mockUserManager.FindByIdAsync(Arg.Any<string>()).Returns(_user);
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users);

            var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();
            var mailer = Substitute.For<IEmailer>();

            var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer, _logger);
            var result = await service.GetById(1);
            result.Should().Be(_user);
        }

        [Fact]
        public async Task GetByEmail_ShouldReturnUser()
        {
            _mockUserManager.FindByEmailAsync(Arg.Any<string>()).Returns(_user);
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users);

            var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();
            var mailer = Substitute.For<IEmailer>();

            var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer, _logger);
            var result = await service.GetByEmail("mail");
            result.Should().Be(_user);
        }

        [Fact]
        public async Task RemoveUser_ShouldDeleteUser()
        {
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users);

            var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();
            var mailer = Substitute.For<IEmailer>();

            var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer, _logger);
            await service.RemoveUser(_user);

            var result = await service.GetById(2);
            result.Should().Be(null);
        }

        [Fact]
        public async Task ToggleEnable_ShouldDisableUser()
        {
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users);
            var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();
            var mailer = Substitute.For<IEmailer>();
            var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer, _logger);

            var result = await service.ToggleEnable(_user);
            Assert.Equal(false, result);
        }

        [Fact]
        public async Task Invite_ShouldFailIfUserExists()
        {
            _mockUserManager.FindByEmailAsync(Arg.Any<string>()).Returns(_user);
            var databaseContext = await Helpers<User>.GetDatabaseContext(_users);
            var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();
            var mailer = Substitute.For<IEmailer>();
            var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer, _logger);

            var result = await service.SendRegistrationLink(new Contracts.DTOs.User.InviteDTO
            {
                Email = "string",
                FirstName = "string",
                LastName = "string",
            });

            Assert.Equal(true, result.IsError);
        }

        //[Fact] To be debuged later
        //public async Task Invite_ShouldPassIfUserDoesNotExist()
        //{
        //    _mockUserManager.FindByEmailAsync(Arg.Any<string>()).Returns<User>(x => null);
        //    var databaseContext = await Helpers<User>.GetDatabaseContext(_users);
        //    var frontSettings = Substitute.For<IOptions<FrontEndSettings>>();

        //    var mailer = Substitute.For<IEmailer>();
        //    mailer.When(x => x.SendEmailAndWriteToDbAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<bool>())).Do(x => { });

        //    var service = new UserService(frontSettings, _mockUserManager, _mapper, databaseContext, mailer);

        //    var result = await service.SendRegistrationLink(new InviteDTO
        //    {
        //        Email = "string@dilig.net",
        //        FirstName = "string",
        //        LastName = "string",
        //    });

        //    result.Data.Should().BeEquivalentTo(new
        //    {
        //        Message = "Link has been sent!"
        //    });
        //}
    }
}