using Microsoft.AspNetCore.Mvc;
using Moq;
using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
using Microsoft.Azure.KeyVault.Models;
using Xunit;

namespace TDD2.Tests
{
    public class UnitTest1
    {

        [Fact]
        public void ShouldLoginWithSuccess()
        {
            var user = new User { Username = "login", Email = "mail@mail.com", Password = GetHash("asd") };

            var loginModel = new LoginModel
            {
                Username = "login",
                Password = "asd"
            };
            var userRepository = new Mock<IRepository<User>>();
            userRepository.Setup(x => x.Exist(It.IsAny<Func<User, bool>>())).Returns(true);
            userRepository.Setup(x => x.GetBy(It.IsAny<Func<User, bool>>())).Returns(user);

            var userService = new UserService(userRepository.Object);

            var accountController = new AccountController(userService);


            var result = accountController.Login(loginModel);
            var okResult = Assert.IsType<OkObjectResult>(result);
            var email = Assert.IsAssignableFrom<ResultDto<LoginResultDto>>(okResult.Value);

            Assert.Equal(user.Email, email.SuccessResult.Email);
        }
        private string GetHash(string text)
        {
            // SHA512 is disposable by inheritance.
            using (var sha256 = SHA256.Create())
            {
                // Send a sample text to hash.
                var hashedBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(text));
                // Get the hashed string.
                return BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
            }
        }

        [Fact]
        public void ShouldReturnErrorOnInvalidUser()
        {
            var error = "Hasło lub Użytkownik są błędne";
            //user w bazie
            var user = new User { Username = "login", Email = "mail@mail.com", Password = GetHash("asd") };

            var loginModel = new LoginModel
            {
                Username = "login",
                Password = "asd"
            };
            var userRepository = new Mock<IRepository<User>>();

            var userService = new UserService(userRepository.Object);

            var accountController = new AccountController(userService);

            var result = accountController.Login(loginModel);
            var badRequest = Assert.IsType<BadRequestObjectResult>(result);
            var errorResult = Assert.IsAssignableFrom<ResultDto<LoginResultDto>>(badRequest.Value);

            Assert.Contains(error, errorResult.Errors);
        }

        [Fact]
        public void ShouldReturnErrorOnInvalidPassword()
        {
            var error = "Hasło lub Użytkownik są błędne";
            //user w bazie
            var user = new User { Username = "login", Email = "mail@mail.com", Password = GetHash("asd55") };

            var loginModel = new LoginModel
            {
                Username = "login",
                Password = "asd"
            };
            var userRepository = new Mock<IRepository<User>>();
            userRepository.Setup(x => x.Exist(It.IsAny<Func<User, bool>>())).Returns(true);
            userRepository.Setup(x => x.GetBy(It.IsAny<Func<User, bool>>())).Returns(user);

            var userService = new UserService(userRepository.Object);

            var accountController = new AccountController(userService);

            var result = accountController.Login(loginModel);
            var badRequest = Assert.IsType<BadRequestObjectResult>(result);
            var errorResult = Assert.IsAssignableFrom<ResultDto<LoginResultDto>>(badRequest.Value);

            Assert.Contains(error, errorResult.Errors);
        }

        [Fact]
        public void ShouldRegisterWithSuccess()
        {
            var newUser = new RegisterModel()
            {
                Email = "damian@gmail.com",
                Username = "Damian",
                Password = "verystrongpass",
                ConfirmPassword = "verystrongpass"
            };

            var userRepository = new Mock<IRepository<User>>();
            userRepository.Setup(x => x.Exist(It.IsAny<Func<User, bool>>())).Returns(false);
            userRepository.Setup(x => x.Add(It.IsAny<User>())).Returns(true);

            var userService = new UserService(userRepository.Object);
            var accountController = new AccountController(userService);

            var result = accountController.Register(newUser);
            var createdResult = Assert.IsType<ObjectResult>(result);
            var emailResult = Assert.IsAssignableFrom<ResultDto<RegisterResultDto>>(createdResult.Value);

            Assert.Equal(newUser.Email, emailResult.SuccessResult.Email);
        }

        [Fact]
        public void ShouldReturnErrorOnExistingUser()
        {
            var newUser = new RegisterModel()
            {
                Email = "damian@gmail.com",
                Username = "Damian",
                Password = "verystrongpass",
                ConfirmPassword = "verystrongpass"
            };

            var errorMessage = $"An user with username {newUser.Username} already exists";

            var userRepository = new Mock<IRepository<User>>();

            userRepository.Setup(x => x.Exist(It.IsAny<Func<User, bool>>())).Returns(true);

            var userService = new UserService(userRepository.Object);
            var accountController = new AccountController(userService);

            var result = accountController.Register(newUser);
            var badRequest = Assert.IsType<BadRequestObjectResult>(result);
            var errorResult = Assert.IsType<ResultDto<RegisterResultDto>>(badRequest.Value);

            Assert.Contains(errorMessage, errorResult.Errors);
        }

        [Fact]
        public void ShouldReturnErrorCausedDifferentPasswords()
        {
            var newUser = new RegisterModel()
            {
                Email = "damian@gmail.com",
                Username = "Damian",
                Password = "verystrongpass",
                ConfirmPassword = "verystrongpass22"
            };

            var errorMessage = "Passwords should match";

            var userRepository = new Mock<IRepository<User>>();


            var userService = new UserService(userRepository.Object);
            var accountController = new AccountController(userService);

            var result = accountController.Register(newUser);
            var badRequest = Assert.IsType<BadRequestObjectResult>(result);
            var errorResult = Assert.IsType<ResultDto<RegisterResultDto>>(badRequest.Value);

            Assert.Contains(errorMessage, errorResult.Errors);

        }


        public class User : Entity
        {
            public string Username { get; set; }
            public string Email { get; set; }
            public string Password { get; set; }
        }

        public class LoginModel
        {
            public string Username { get; set; }
            public string Password { get; set; }
        }

        public class RegisterModel
        {
            public string Email { get; set; }
            public string Username { get; set; }
            public string Password { get; set; }
            public string ConfirmPassword { get; set; }
        }

        public interface IRepository<T> where T : Entity
        {
            bool Exist(Func<User, bool> function);
            T GetBy(Func<User, bool> function);
            bool Add(User user);
        }

        public interface IUserService
        {
            ResultDto<LoginResultDto> Login(LoginModel loginModel);
            ResultDto<RegisterResultDto> Register(RegisterModel registerModel);
        }

        public class UserService : IUserService
        {
            private readonly IRepository<User> _userRepository;
            public UserService(IRepository<User> userRepository)
            {
                _userRepository = userRepository;
            }
            public ResultDto<LoginResultDto> Login(LoginModel loginModel)
            {
                var result = new ResultDto<LoginResultDto>();
                var user = _userRepository.GetBy(x => x.Username == loginModel.Username);

                if (user?.Password != GetHash(loginModel.Password))
                {
                    result.Errors.Add("Hasło lub Użytkownik są błędne");
                    return result;
                }

                result.SuccessResult = new LoginResultDto { Email = user.Email };
                return result;
            }

            public ResultDto<RegisterResultDto> Register(RegisterModel registerModel)
            {
                var result = new ResultDto<RegisterResultDto>();

                if (_userRepository.Exist(u => u.Username == registerModel.Username))
                {
                    result.Errors.Add($"An user with username {registerModel.Username} already exists");
                    return result;
                }

                if (registerModel.Password != registerModel.ConfirmPassword)
                {
                    result.Errors.Add("Passwords should match");
                    return result;
                }

                var user = new User
                {
                    Email = registerModel.Email,
                    Username = registerModel.Username,
                    Password = GetHash(registerModel.Password)
                };


                if (!_userRepository.Add(user))
                {
                    result.Errors.Add("An error occured while adding user.");
                    return result;
                }
                result.SuccessResult = new RegisterResultDto()
                {
                    Email = registerModel.Email
                };

                return result;
            }

            private string GetHash(string text)
            {
                // SHA512 is disposable by inheritance.
                using (var sha256 = SHA256.Create())
                {
                    // Send a sample text to hash.
                    var hashedBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(text));
                    // Get the hashed string.
                    return BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
                }
            }
        }
        public class RegisterResultDto : BaseDto
        {
            public string Email { get; set; }
            //Token
            //ExpirationDate
            //UserName  ->optional
            //FirstName ->optional
            //LastName  ->optional
        }

        public class LoginResultDto : BaseDto
        {
            public string Email { get; set; }
        }

        public class ResultDto<T> where T : BaseDto
        {
            public T SuccessResult { get; set; }
            public List<string> Errors { get; set; }
            public bool IsError { get { return Errors?.Count > 0; } }
            public ResultDto()
            {
                Errors = new List<string>();
            }
        }

        public class BaseDto
        {

        }

        public class Entity
        {
            public long Id { get; set; }
        }

        public class AccountController : Controller
        {
            private readonly IUserService _userService;

            public AccountController(IUserService userService)
            {
                _userService = userService;
            }

            public IActionResult Login(LoginModel loginModel)
            {
                var result = _userService.Login(loginModel);

                if (result.IsError)
                {
                    return BadRequest(result);
                }

                return Ok(result);
            }
            public IActionResult Register(RegisterModel registerModel)
            {
                var result = _userService.Register(registerModel);

                if (result.IsError)
                {
                    return BadRequest(result);
                }

                return StatusCode(201, result);
            }

        }

    }
}