using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Identity.UI.Services;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Localization;
using DemoApp.Models;
using DemoApp.ViewModels;
using System;
using System.Threading.Tasks;

namespace DemoApp.Controllers
{
    public class AccountController : Controller
    {
        private readonly UserManager<User> _userManager;
        private readonly SignInManager<User> _signInManager;
        private readonly IEmailSender _emailSender;
        private readonly IStringLocalizer<AccountController> _localizer;

        public AccountController(
            UserManager<User> userManager,
            SignInManager<User> signInManager,
            IEmailSender emailSender,
            IStringLocalizer<AccountController> localizer)
        {
            _userManager = userManager;
            _signInManager = signInManager;
            _emailSender = emailSender;
            _localizer = localizer;
        }

        [HttpGet]
        [AllowAnonymous]
        public IActionResult Login()
        {
            if (!User.Identity.IsAuthenticated)
            {
                ViewBag.Title = _localizer["AccessPage"];
                return View();
            }

            return RedirectToAction("Home", "Dashboard");
        }

        [HttpPost]
        [AllowAnonymous]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> Login(LoginViewModel vm)
        {
            if (ModelState.IsValid)
            {
                var user = await _userManager.FindByEmailAsync(vm.Email);

                if (user != null)
                {
                    if (!user.EmailConfirmed)
                    {
                        ModelState.AddModelError(string.Empty, _localizer["EmailNotConfirmed"]);
                        return View(vm);
                    }

                    var result = await _signInManager
                        .PasswordSignInAsync(user, vm.Password, isPersistent: vm.RememberMe, lockoutOnFailure: true);

                    await _userManager.UpdateSecurityStampAsync(user);

                    if (result.Succeeded)
                    {
                        return RedirectToAction("Home", "Dashboard");
                    }
                    else if (result.IsLockedOut)
                    {
                        return View("Lockout");
                    }
                    else
                    {
                        ModelState.AddModelError(string.Empty, _localizer["InvalidCredentials"]);
                    }
                }
            }

            return View(vm);
        }

        [HttpGet]
        public IActionResult Register()
        {
            return View();
        }

        [HttpPost]
        public async Task<IActionResult> Register(RegisterViewModel vm)
        {
            if (ModelState.IsValid)
            {
                if (await CheckUserExist(vm))
                    return View(vm);

                var user = new User
                {
                    FirstName = vm.FirstName,
                    LastName = vm.LastName,
                    UserName = vm.UserName,
                    Email = vm.Email
                };

                var result = await _userManager.CreateAsync(user, vm.Password);

                if (result.Succeeded)
                {
                    await _userManager.AddToRoleAsync(user, "Customer");

                    var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);

                    var callbackUrl = Url.Action("ConfirmEmail", "Account", new
                    {
                        userId = user.Id,
                        token = code
                    }, protocol: Request.Scheme);

                    await _emailSender.SendEmailAsync(user.Email, _localizer["ConfirmYourEmail"], _localizer["ConfirmAccountTemplate", callbackUrl]);

                    return View("RegisterConfirmation", user);
                }
                else
                {
                    foreach (var error in result.Errors)
                    {
                        ModelState.AddModelError("", error.Description);
                    }
                }
            }

            return View(vm);
        }

        [AllowAnonymous]
        [HttpGet]
        public async Task<IActionResult> ConfirmEmail(string userId, string token)
        {
            if (userId == null || token == null)
            {
                return RedirectToAction("Index", "Error");
            }

            var user = await _userManager.FindByIdAsync(userId);

            if (user != null)
            {
                if (user.EmailConfirmed)
                {
                    ModelState.AddModelError(string.Empty, _localizer["EmailAlreadyConfirmed"]);
                    return View(user);
                }

                IdentityResult result;

                try
                {
                    result = await _userManager.ConfirmEmailAsync(user, token);
                }
                catch (InvalidOperationException ex)
                {
                    return RedirectToAction("Index", "Error", new { errorMessage = ex.Message });
                }

                if (result.Succeeded)
                {
                    await _emailSender.SendEmailAsync(user.Email, _localizer["EmailConfirmed"], _localizer["EmailConfirmedTemplate"]);
                    return View("ConfirmEmail", user);
                }
            }

            ModelState.AddModelError(string.Empty, _localizer["UserNotFound"]);
            return View();
        }

        private async Task<bool> CheckUserExist(RegisterViewModel vm)
        {
            var user = await _userManager.FindByNameAsync(vm.UserName);

            if (user != null)
            {
                ModelState.AddModelError("username", _localizer["UsernameAlreadyTaken"]);
                return true;
            }

            await _userManager.FindByEmailAsync(vm.Email);

            if (user != null)
            {
                ModelState.AddModelError("email", _localizer["EmailAlreadyTaken"]);
                return true;
            }

            return false;
        }

        [HttpGet]
        public async Task<IActionResult> Logout()
        {
            if (User.Identity.IsAuthenticated)
            {
                await _signInManager.SignOutAsync();
                return RedirectToAction("Logout");
            }
            else
            {
                return View();
            }
        }

        [HttpGet]
        [AllowAnonymous]
        public IActionResult ForgotPassword()
        {
            return View();
        }

        [HttpPost]
        [AllowAnonymous]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> ForgotPassword(ForgotPasswordViewModel vm)
        {
            if (ModelState.IsValid)
            {
                var user = await _userManager.FindByEmailAsync(vm.Email);

                if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
                {
                    return View("ForgotPasswordConfirmation");
                }

                var code = await _userManager.GeneratePasswordResetTokenAsync(user);
                var callbackUrl = Url.Action("ResetPassword", "Account", new
                {
                    userEmail = user.Email,
                    token = code
                }, protocol: Request.Scheme);

                await _emailSender.SendEmailAsync(vm.Email, _localizer["PasswordReset"], _localizer["PasswordResetTemplate", callbackUrl]);

                ViewBag.ResetPassword = true;
                return View("ForgotPasswordConfirmation");
            }

            return View(vm);
        }

        [HttpGet]
        [AllowAnonymous]
        public async Task<IActionResult> ResetPassword(string userEmail, string token)
        {
            if (userEmail == null || token == null)
            {
                return RedirectToAction("Index", "Error");
            }

            var user = await _userManager.FindByEmailAsync(userEmail);

            if (user != null)
            {
                return View(new ResetPasswordViewModel { Email = userEmail, Token = token });
            }

            return RedirectToAction("Index", "Error");
        }

        [HttpPost]
        [AllowAnonymous]
        public async Task<IActionResult> ResetPassword(ResetPasswordViewModel vm)
        {
            if (ModelState.IsValid)
            {
                var user = await _userManager.FindByEmailAsync(vm.Email);

                if (user != null)
                {
                    var result = await _userManager.ResetPasswordAsync(user, vm.Token, vm.Password);

                    if (result.Succeeded)
                    {
                        return View("ResetPasswordConfirmation");
                    }
                    else
                    {
                        ModelState.AddModelError(string.Empty, _localizer["ResetNotSuccess"]);
                    }
                }
            }

            return View(vm);
        }
    }
}