using System;
using System.Threading.Tasks;
using cinema.Entities;
using Cinema.Repositories;
using Cinema.Services;
using FluentAssertions;
using Moq;
using Xunit;

namespace CinemaTests.Services.UserService
{
    public class RegisterAsyncTests
    {
        private readonly User user= new User("test123@o2.pl", "FirstName", "LastName", "Secret123","salt123", "user");
        [Fact]
        public async Task GivenUniqueEmailAndValidPasswordUserShouldBeRegistered()
        {
            var userRepository = new Mock<IUserRepository>();
            var tokenProvider = new Mock<ITokenProvider>();
            var crpytoService = new Mock<ICryptoService>();
            var userService = new Cinema.Services.UserService(userRepository.Object, crpytoService.Object, tokenProvider.Object);

            await userService.RegisterAsync(user.Email, user.FirstName, user.LastName, user.Password, user.Role);

            userRepository.Verify(x=>x.AddAsync(It.IsAny<User>()),Times.Once);
        }
        [Fact]
        public void GivenInvalidEmailExceptionShouldBeThrown()
        {
            var userRepository = new Mock<IUserRepository>();
            var tokenProvider = new Mock<ITokenProvider>();
            var crpytoService = new Mock<ICryptoService>();
            var userService = new Cinema.Services.UserService(userRepository.Object, crpytoService.Object, tokenProvider.Object);
            var invalidEmail = "invalido2.pl";

            Func<Task> fun = async () =>
            {
                await userService.RegisterAsync(invalidEmail, user.FirstName, user.LastName, user.Password, user.Role);
            };

            fun.ShouldThrow<Exception>();
        }
        [Fact]
        public void GivenOccupiedEmailExceptionShouldBeThrown()
        {
            var occupiedEmail = "occupied@o2.pl";
            var userRepository = new Mock<IUserRepository>();
            var user= new User("test@test.pl", "Test", "Test", "Secret1234", "salt", "role");
            userRepository.Setup(x => x.GetByEmailAsync(occupiedEmail)).Returns(Task.FromResult(user));
            var tokenProvider = new Mock<ITokenProvider>();
            var crpytoService = new Mock<ICryptoService>();
            var userService = new Cinema.Services.UserService(userRepository.Object, crpytoService.Object, tokenProvider.Object);


            Func<Task> fun = async () =>
            {
                await userService.RegisterAsync(occupiedEmail, user.FirstName, user.LastName, user.Password, user.Role);
            };

            fun.ShouldThrow<Exception>();
        }
        [Fact]
        public void GivenPasswordShorterThanSixExceptionShouldBeThrown()
        {
            var shortPassword = "123";
            var userRepository = new Mock<IUserRepository>();
            var tokenProvider = new Mock<ITokenProvider>();
            var crpytoService = new Mock<ICryptoService>();
            var userService = new Cinema.Services.UserService(userRepository.Object, crpytoService.Object, tokenProvider.Object);


            Func<Task> fun = async () =>
            {
                await userService.RegisterAsync(user.Email, user.FirstName, user.LastName, shortPassword, user.Role);
            };

            fun.ShouldThrow<Exception>();
        }
        [Fact]
        public void GivenPasswordWithoutAtLeastOneUpperCaseExceptionShouldBeThrown()
        {
            var onlyLowerPassword = "abckkkkkkk";
            var userRepository = new Mock<IUserRepository>();
            var tokenProvider = new Mock<ITokenProvider>();
            var crpytoService = new Mock<ICryptoService>();
            var userService = new Cinema.Services.UserService(userRepository.Object, crpytoService.Object, tokenProvider.Object);


            Func<Task> fun = async () =>
            {
                await userService.RegisterAsync(user.Email, user.FirstName, user.LastName, onlyLowerPassword, user.Role);
            };

            fun.ShouldThrow<Exception>();
        }
        [Fact]
        public void GivenPasswordWithoutAtLeastOneLowerCaseExceptionShouldBeThrown()
        {
            var onlyUpperPassword = "ABCKKKKKKK";
            var userRepository = new Mock<IUserRepository>();
            var tokenProvider = new Mock<ITokenProvider>();
            var crpytoService = new Mock<ICryptoService>();
            var userService = new Cinema.Services.UserService(userRepository.Object, crpytoService.Object, tokenProvider.Object);


            Func<Task> fun = async () =>
            {
                await userService.RegisterAsync(user.Email, user.FirstName, user.LastName, onlyUpperPassword, user.Role);
            };

            fun.ShouldThrow<Exception>();
        }

        [Fact]
        public void GivenInvalidRoleExceptionShouldBeThrown()
        {
            var invalidRole = "BACDEFA";
            var userRepository = new Mock<IUserRepository>();
            var tokenProvider = new Mock<ITokenProvider>();
            var crpytoService = new Mock<ICryptoService>();
            var userService = new Cinema.Services.UserService(userRepository.Object, crpytoService.Object, tokenProvider.Object);


            Func<Task> fun = async () =>
            {
                await userService.RegisterAsync(user.Email, user.FirstName, user.LastName, user.Password, invalidRole);
            };

            fun.ShouldThrow<Exception>();
        }

    }
}