auth_service

using Microsoft.AspNetCore.Identity;
using MyDrive.Application.Mappers;
using MyDrive.Common;
using MyDrive.Common.Enums;
using MyDrive.Contracts.Email;
using MyDrive.Contracts.Models.Auth;
using MyDrive.Contracts.Services;
using MyDrive.Model;
using System.Collections.Generic;
using System.Text.Encodings.Web;
using System.Threading.Tasks;

namespace MyDrive.Application.Services
{
    public class AuthService
    {
        private readonly UserManager<User> userManager;
        private readonly UserService userService;
        private readonly IEmailService emailService;
        private readonly TokenProvider tokenProvider;

        public AuthService(UserManager<User> userManager, UserService userService,  IEmailService emailService, TokenProvider tokenProvider)
        {
            this.userManager = userManager;
            this.userService = userService;
            this.emailService = emailService;
            this.tokenProvider = tokenProvider;
        }

        public async Task<Result> RegisterAsync(RegisterModel model)
        {
            var validationErrors = await ValidateRegisterModel(model);

            if (validationErrors.Count > 0)
            {
                return new Result(new Error(ErrorName.NotValid, validationErrors));
            }

            var user = new User
            {
                UserName = model.UserName,
                Email = model.Email,
            };

            // Result from Identity
            var creationResult = await userManager.CreateAsync(user, model.Password);

            if (!creationResult.Succeeded)
            {
                return new Result(new Error(ErrorName.NotSpecified, "Rejestracja nie powiodła się z nieznanych przyczyn."));
            }

            var emailResult = await SendEmailConfirmationTokenAsync(user);

            if (!emailResult.Successful)
            {
                return new Result(new Error(ErrorName.NotSpecified, emailResult.ErrorDescription));
            }

            return Result.SuccessfulResult;
        }

        public async Task<Result<CurrentUserModel>> ConfirmEmailAsync(string userName, string token)
        {
            var user = await userManager.FindByNameAsync(userName);

            if (user == null)
            {
                return new Result<CurrentUserModel>(new Error(ErrorName.NotValid, "Użytkownik o podanej nazwie nie istnieje."));
            }

            // Result from Identity
            var confirmationResult = await userManager.ConfirmEmailAsync(user, token);

            if (!confirmationResult.Succeeded)
            {
                return new Result<CurrentUserModel>(new Error(ErrorName.NotSpecified, "Potwierdzenie adresu email nie powiodło się."));
            }

            return new Result<CurrentUserModel>(UserMapper.CurrentUserModel(user, tokenProvider.GenerateJwtToken(user)));
        }

        public async Task<Result<CurrentUserModel>> LoginAsync(LoginModel model)
        {
            var user = await userManager.FindByNameAsync(model.UserName);

            if (user == null)
            {
                return new Result<CurrentUserModel>(new Error(ErrorName.NotAuthorized, "Użytkownik o podanej nazwie nie istnieje."));
            }

            if (!await userManager.IsEmailConfirmedAsync(user))
            {
                return new Result<CurrentUserModel>(new Error(ErrorName.NotAuthorized, "Adres email nie został potwierdzony."));
            }

            if (!await userManager.CheckPasswordAsync(user, model.Password))
            {
                return new Result<CurrentUserModel>(new Error(ErrorName.NotAuthorized, "Wprowadzone hasło nie jest prawidłowe."));
            }

            return new Result<CurrentUserModel>(UserMapper.CurrentUserModel(user, tokenProvider.GenerateJwtToken(user)));
        }

        public async Task<Result> SendPasswordResetTokenAsync(string email)
        {
            var user = await userManager.FindByEmailAsync(email);

            if (user == null)
            {
                return new Result(new Error(ErrorName.NotValid, "Użytkownik o podanym adresie email nie istnieje."));
            }

            var token = await userManager.GeneratePasswordResetTokenAsync(user);

            var message = new EmailMessage(user.UserName, user.Email)
            {
                Subject = "Resetowanie hasła w MyDrive",
                Content = $"Twój kod pozwalający zresetować hasło to {token}"
            };

            var emailResult = await emailService.SendAsync(message);

            if (!emailResult.Successful)
            {
                return new Result(new Error(ErrorName.NotSpecified, emailResult.ErrorDescription));
            }

            return Result.SuccessfulResult;
        }

        public async Task<Result> ResetPasswordAsync(ResetPasswordModel model)
        {
            var user = await userManager.FindByNameAsync(model.UserName);

            if (user == null)
            {
                return new Result(new Error(ErrorName.NotValid, "Użytkownik o podanej nazwie nie istnieje."));
            }

            // Result from Identity
            var resettingResult = await userManager.ResetPasswordAsync(user, model.Token, model.NewPassword);

            if (!resettingResult.Succeeded)
            {
                return new Result(new Error(ErrorName.NotSpecified, "Nie udało się zresetować hasła."));
            }

            return Result.SuccessfulResult;
        }

        private async Task<IDictionary<string, string>> ValidateRegisterModel(RegisterModel model)
        {
            var isUserNameAvailableTask = userService.IsUserNameAvailableAsync(model.UserName);
            var isEmailAvailableTask = userService.IsEmailAvailableAsync(model.Email);

            var isUserNameAvailable = await isUserNameAvailableTask;
            var isEmailAvailable = await isEmailAvailableTask;

            var errors = new Dictionary<string, string>();

            if (!isEmailAvailable)
            {
                errors[nameof(model.UserName)] = "Użytkownik o podanej nazwie już istnieje.";
            }

            if (!isEmailAvailable)
            {
                errors[nameof(model.Email)] = "Użytkownik o podanym adresie email już istnieje.";
            }

            return errors;
        }

        private async Task<EmailResult> SendEmailConfirmationTokenAsync(User user)
        {
            var token = await userManager.GenerateEmailConfirmationTokenAsync(user);

            var message = new EmailMessage(user.UserName, user.Email)
            {
                Subject = "Potwierdzenie adresu email w MyDrive",
                Content = $"Twój kod potwierdzający to {UrlEncoder.Default.Encode(token)}"
            };

            return await emailService.SendAsync(message);
        }
    }
}