using BuddyFinance.Admin.Extensions;
using BuddyFinance.Admin.Models;
using BuddyFinance.Common.Encryption;
using BuddyFinance.Common.Integration;
using BuddyFinance.Integration.Models;
using BuddyFinance.Integration.Models.Account;
using BuddyFinance.Integration.Models.Enums;
using BuddyFinance.Integration.Models.Registration;
using BuddyFinance.Model;
using FluentValidation;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;

namespace BuddyFinance.Admin.Controllers
{
    [AllowAnonymous]
    public class AccountController : BaseController
    {
        private readonly BuddyFinanceDbContext dbContext;
        private readonly IHttpContextAccessor httpContextAccessor;

        public AccountController(IConfiguration configuration, BuddyFinanceDbContext dbContext,
            IHttpContextAccessor httpContextAccessor) : base(configuration, dbContext)
        {
            this.dbContext = dbContext;
            this.httpContextAccessor = httpContextAccessor;
        }

        public IActionResult Login(bool? loanRequest, string returnUrl)
        {
            ViewData["resetPassworUrl"] = Url.AbsoluteAction("ResetPassword", "Account", new { token = "_token" }); //Url.RouteUrl("ResetPassword", new { token = "_token" });
            return View(new AccountLoginModel { ReturnUrl = returnUrl });
        }

        [HttpPost]
        public async Task<IActionResult> ApiLogin([FromBody] LoginResult loginResult)
        {
            var user = new SystemUser
            {
                EmailAddress = loginResult.Contact.Decrypt(),
                ProfileId = loginResult.ProfileId.ToDecryptedInt(),
                _ProfileId = loginResult.ProfileId,
                UserType = loginResult.UserType.Decrypt(),
                AccessToken = loginResult.OauthToken,
                UserId = loginResult.UserId.ToDecryptedInt(),
                _UserId = loginResult.UserId,
                RoleId = loginResult.RoleId.ToDecryptedInt(),
                _RoleId = loginResult.RoleId,
                ProfileStatus = loginResult.Status,
                Name = loginResult.Name.Decrypt(),
                Surname = loginResult.Surname.Decrypt(),
                ProfileNumber = loginResult.ProfileNumber.Decrypt()
            };

            SessionManager.StartSession(httpContextAccessor, user);

            var identity = new ClaimsIdentity(CookieAuthenticationDefaults.AuthenticationScheme);
            identity.AddClaim(new Claim(ClaimTypes.Name, user.EmailAddress));

            await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme,
                new ClaimsPrincipal(identity));

            if (loginResult.ErrorCode == 0)
            {
                var ip = Request.HttpContext.Connection.RemoteIpAddress.ToString();
                var userAgent = Request.HttpContext.Request.Headers.ContainsKey("User-Agent")
                        ? Request.HttpContext.Request.Headers["User-Agent"].ToString() : "";

                dbContext.ActivityLog.Add(new Models.ActivityLog
                {
                    Type = LogTypeEnum.Information.ToString(),
                    Description = $"Successfully logged-in user ({user.EmailAddress})",
                    UserId = SessionManager.Current?.CurrentUser?.UserId == 0 ? null : SessionManager.Current?.CurrentUser.UserId,
                    IpAddress = ip,
                    UserAgent = userAgent,
                    TimeStamp = DateTime.Now
                });
            }

            if (user.RoleId == (int)UserRoleEnum.Admin
                || user.RoleId == (int)UserRoleEnum.SuperAdmin)
                return Json(new { returnUrl = Url.Action("Index", "Home", new { area = "Admin" }) });

            return Ok();
        }

        public async Task<IActionResult> Logout()
        {
            SessionManager.ClearSession();
            await HttpContext.SignOutAsync();
            return RedirectToAction("Index", "Home");
        }

        public IActionResult Confirm(string token)
        {
            var model = new AccountVerificationModel
            {
                Token = token
            };
            return View(model);
        }

        //[ActionName("confirm-email")]
        [Route("/account/confirm/{email}")]
        public IActionResult ConfirmEmail(string email, string token)
        {
            var model = new ResetPasswordModel
            {
                Token = token,
                Username = email
            };

            return View(model);
        }

        public IActionResult ResetPassword(string token)
        {
            return View(new ResetPasswordModel
            {
                Token = token
            });
        }

        public IActionResult Register()
        {
            return View();
        }

        [HttpPost]
        [Route("/api/account/register/validate1")]
        public IActionResult ApiRegisterValidate1([FromBody] NewProfileModel model)
        {
            if (model == null)
                return Ok(new { success = false, errors = new List<string> { "Please provide registration info" } });


            var validator = new NewProfileModelValidator();
            var validationResult = validator.Validate(model, ruleSet: "userAccountInfo");

            var success = validationResult.IsValid;
            var errors = GetValidationErrors(validationResult);

            if (success)
            {
                if (IsAccountInUse(model.EmailAddress))
                {
                    success = false;
                    errors.Add("Email already in use");
                }
            }

            return Ok(new { success, errors });
        }

        [HttpPost]
        [Route("/api/account/register/validate2")]
        public IActionResult ApiRegisterValidate2([FromBody] NewProfileModel model)
        {
            var success = true;
            var errors = new List<string>();


            //try
            //{

            //    if (dbContext.Profiles.Any(m => m.IdentificationNumber.Equals(model.IdentificationNumber)))
            //    {
            //        errors.Add("Identification Number is already registered");
            //    }
            //    else
            //    {
            //        if (model == null)
            //        {
            //            //errors.Add("Please provide registration info");
            //            return BadRequest();
            //        }
            //        else
            //        {
            //            var validator = new NewProfileModelValidator();
            //            var validationResult = validator.Validate(model, ruleSet: "personalDetails");

            //            success = validationResult.IsValid;
            //            errors.AddRange(GetValidationErrors(validationResult));
            //        }
            //    }


            //}
            //catch (Exception ex)
            //{
            //    success = false;
            //    errors.Add(ex.Message);
            //}

            return Ok(new { success, errors });

        }

        [HttpPost]
        [Route("/api/account/register/validate3")]
        public IActionResult ApiRegisterValidate3([FromBody] NewProfileModel model)
        {
            //var validator = new NewProfileModelValidator();
            //var validationResult = validator.Validate(model, ruleSet: "addressAndDocs");

            //var success = validationResult.IsValid;
            //var errors = GetValidationErrors(validationResult);

            //// var confirmUrl = Url.AbsoluteAction("Confirm", "Account", new { token = "_token" });
            //return Ok(new { success, errors });

            return Ok(new { success = true, errors = new List<string>() });

        }

        private bool IsAccountInUse(string emailAddress)
        {
            var exists = false;
            var apiResponse = WebApiHelper.Post<BaseResult<bool>>(API_BASE, $"account/exists?email={emailAddress}", "");
            if (apiResponse.ErrorCode == 0)
            {
                var result = apiResponse.Result;
                if (result.ErrorCode == 0)
                {
                    exists = result.Result;
                }
            }
            else
            {
                exists = false;
            }

            return exists;
        }
    }



}