using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.JSInterop;
using System.Security.Claims;
using WebDoorCreator.Data.DbModels;
using WebDoorCreator.Data.Services;
using WebDoorCreator.Data.User;
using WebDoorCreator.UI.Data;
using NLog;

namespace WebDoorCreator.UI.Pages
{
    [Authorize(Roles = "SuperAdmin, DcaAdmin, CompAdmin")]
    public partial class UserAdmin : ComponentBase, IDisposable
    {
        #region Public Fields

        public const string ADMIN_ROLE = "SuperAdmin";

        public const string STD_CLAIM = "None";

        public const string STD_CLAIM_VAL = "0";

        public const string UNDEF_ROLE = "Undef";

        #endregion Public Fields

        #region Public Methods

        public List<string> ConvertClaim(List<Claim> ClaimList)
        {
            List<string> answ = new List<string>();

            // ciclo sui claims
            foreach (var claim in ClaimList)
            {
                string claimStr = claim.ToString();
                // verifico che in OGNI claim ci siaun valore ammissibile...
                if (claimStr.Contains(":"))
                {
                    // splitto chiave/valore
                    var splitClaim = claimStr.Split(':');
                    switch (splitClaim[0])
                    {
                        case "CompanyId":
                            if (CompanyList != null)
                            {
                                var compRec = CompanyList
                                                .Where(x => $"{x.CompanyId}" == splitClaim[1].Trim())
                                                .FirstOrDefault();
                                if (compRec != null)
                                {
                                    answ.Add($"{splitClaim[0]}: {compRec.CompanyName}");
                                }
                                else
                                {
                                    answ.Add($"{claim}");
                                }
                            }
                            break;

                        case "None":
                        default:
                            break;
                    }
                }
            }

            return answ;
        }

        public void Dispose()
        {
        }

        /// <summary>
        /// Recupera elenco utenti
        /// </summary>
        public async Task GetUsers()
        {
            // clear any error messages
            strError = "";
            UsersAll = await UMService.UserDataGetFilt(searchVal);
            // filtro visualizzazione x RUOLO, SE richeisto
            if (FiltUserRole != "0")
            {
                UsersAll = UsersAll.Where(x => x.Roles.Contains(FiltUserRole)).ToList();
            }
            // filtro visualizzazione x Company, SE richeisto
            if (FiltCompany != "0")
            {
                UsersAll = UsersAll
                            .Where(x => x.Claims.Any(c => c.Type == "CompanyId" && c.Value == $"{FiltCompany}"))
                            .ToList();
            }
            UsersList = UsersAll
                        .Skip(numRecord * (currPage - 1)).Take(numRecord)
                        .ToList();
        }

        public async void OnSeachUpdated()
        {
            await ReloadData();
            StateHasChanged();
        }

        public string ShowClaims(List<Claim> ClaimList)
        {
            string answ = string.Join(",", ConvertClaim(ClaimList));
            return answ;
        }

        public string ShowRoles(List<string> RoleList)
        {
            string answ = string.Join(",", RoleList);
            return answ;
        }

        public async Task ToggleCodeDetails()
        {
            showCodeDetails = !showCodeDetails;
            await Task.Delay(1);
        }

        public string userCss(bool isInactive)
        {
            return isInactive ? "text-secondary text-decoration-line-through" : "text-dark";
        }

        #endregion Public Methods

        #region Protected Properties

        [Inject]
        protected RoleManager<IdentityRole> _RoleManager { get; set; } = null!;

        [Inject]
        protected UserManager<IdentityUser> _UserManager { get; set; } = null!;

        [Inject]
        protected AuthenticationStateProvider AuthenticationStateProvider { get; set; } = null!;

        protected string btnShowDetails
        {
            get => showCodeDetails ? "Hide User Code" : "Show User Code";
        }

        protected List<CompanyModel> CompanyList { get; set; } = new List<CompanyModel>();
        protected IdentityUser currUser { get; set; } = new IdentityUser();

        [Inject]
        protected IJSRuntime JSRuntime { get; set; } = null!;

        protected string searchVal
        {
            get => _searchVal;
            set
            {
                if (value != _searchVal)
                {
                    _searchVal = value;
                    var pUpd = Task.Run(async () =>
                    {
                        await ReloadData();
                    });
                    pUpd.Wait();
                }
            }
        }

        protected bool showCodeDetails { get; set; } = false;

        protected int totalCount
        {
            get
            {
                int answ = 0;
                if (UsersAll != null)
                {
                    answ = UsersAll.Count;
                }
                return answ;
            }
        }

        [Inject]
        protected UserManDataService UMService { get; set; } = null!;

        [Inject]
        protected WebDoorCreatorService WDCService { get; set; } = null!;

        [Inject]
        protected WDCUserService WDCUsrServ { get; set; } = null!;

        #endregion Protected Properties

        #region Protected Methods

        protected void ForceReload(int newNum)
        {
            numRecord = newNum;
        }

        protected void ForceReloadPage(int newNum)
        {
            currPage = newNum;
        }

        protected override async Task OnInitializedAsync()
        {
            searchVal = "";
            CurrentUserClaimType = WDCUsrServ.userCurrComp.ToString();
            // lettura dati
            await ReloadData();
        }

        protected void resetSearch()
        {
            searchVal = "";
        }

        #endregion Protected Methods

        #region Private Fields

        /// <summary>
        /// Elenco CLAIMS da mostrare durante editing
        /// </summary>
        private List<string> ClaimsList = new List<string>() { STD_CLAIM, "CompanyId" };

        private Dictionary<string, string> ClaimValList = new Dictionary<string, string>();

        /// <summary>
        /// User corrente
        /// </summary>
        private IdentityUser objUser = new IdentityUser();

        private string qrCodeVal = "";

        /// <summary>
        /// Elenco ROLES da mostrare in dropdown durante editing (1 solo? usare DB?!?)
        /// </summary>
        private List<string> RolesList = new List<string>() { "Undef", "User", "CompUser", "CompAdmin" };

        // To enable showing the Popup
        private bool ShowPopup = false;

        // To hold any possible errors
        private string strError = "";

        /// <summary>
        /// Collezione utenti (totale)
        /// </summary>
        private List<UserData> UsersAll = new List<UserData>();

        /// <summary>
        /// Collezione utenti
        /// </summary>
        /// filtrati/mostrati
        private List<UserData> UsersList = new List<UserData>();

        #endregion Private Fields

        #region Private Properties

        private string _CurrClaimType { get; set; } = "None";

        private int _currPage { get; set; } = 1;

        private string _filtCompanyId { get; set; } = "0";

        private string _filtUserRole { get; set; } = "0";

        private int _numRecord { get; set; } = 10;

        private string _searchVal { get; set; } = "";

        [CascadingParameter]
        private Task<AuthenticationState> authenticationStateTask { get; set; } = null!;

        [Inject]
        private IConfiguration Configuration { get; set; } = null!;

        private Claim CurrentUserClaim
        {
            get => new Claim(CurrentUserClaimType, CurrentUserClaimVal);
        }

        /// <summary>
        /// Claim di default (Tipo)
        /// </summary>
        private string CurrentUserClaimType
        {
            get
            {
                return _CurrClaimType;
            }
            set
            {
                _CurrClaimType = value;
                var pUpd = Task.Run(async () => await refreshClaimVal(value));
                pUpd.Wait();
            }
        }

        /// <summary>
        /// Claim di default (valore)
        /// </summary>
        private string CurrentUserClaimVal { get; set; } = "0";

        /// <summary>
        /// Ruolo di default (User!!!)
        /// </summary>
        private string CurrentUserRole { get; set; } = "User";

        private int currPage
        {
            get => _currPage;
            set
            {
                if (_currPage != value)
                {
                    _currPage = value;
                    var pUpd = Task.Run(async () => await ReloadData());
                    pUpd.Wait();
                }
            }
        }

        private string currUserRole
        {
            get => WDCUsrServ.userRole;
        }

        /// <summary>
        /// Gestione filtraggio COMPANY
        /// </summary>
        private string FiltCompany
        {
            get
            {
                return _filtCompanyId;
            }
            set
            {
                if (_filtCompanyId != value)
                {
                    _filtCompanyId = value;
                    var pUpd = Task.Run(async () => await ReloadData());
                    pUpd.Wait();
                }
            }
        }

        /// <summary>
        /// Gestione filtraggio RUOLI utente
        /// </summary>
        private string FiltUserRole
        {
            get
            {
                return _filtUserRole;
            }
            set
            {
                if (_filtUserRole != value)
                {
                    _filtUserRole = value;
                    var pUpd = Task.Run(async () => await ReloadData());
                    pUpd.Wait();
                }
            }
        }

        private bool isLoading { get; set; } = false;

        private int numRecord
        {
            get => _numRecord;
            set
            {
                if (_numRecord != value)
                {
                    _numRecord = value;
                    var pUpd = Task.Run(async () => await ReloadData());
                    pUpd.Wait();
                }
            }
        }

        #endregion Private Properties

        #region Private Methods

        private void AddNewUser()
        {
            // Make new user
            objUser = new IdentityUser();
            objUser.PasswordHash = "*****";
            // set confermato
            objUser.EmailConfirmed = true;
            // Set Id to blank so we know it is a new record
            objUser.Id = "";
            // hide dettaglio qrcode/clipboard...
            showCodeDetails = false;
            // Apro popup
            ShowPopup = true;
        }

        private async Task ClosePopup()
        {
            // Close the Popup
            ShowPopup = false;
            // Refresh page
            await ReloadData();
        }

        private async Task DeleteUser(IdentityUser _IdentityUser)
        {
            // Close the Popup
            ShowPopup = false;

            if (!await JSRuntime.InvokeAsync<bool>("confirm", "Are sure you want to DELETE selected user??"))
                return;

            // Get the user
            var user = await _UserManager.FindByIdAsync(_IdentityUser.Id);
            if (user != null)
            {
                // Delete the user
                await _UserManager.DeleteAsync(user);
                // reset cache!
                await UMService.ResetUserDataCache(true);
            }
            // Refresh Users
            await ReloadData();
        }

        private async Task DisableUser(IdentityUser _IdentityUser)
        {
            // Close the Popup
            ShowPopup = false;

            if (!await JSRuntime.InvokeAsync<bool>("confirm", "Are sure you want to disable selected user?"))
                return;

            // Get the user
            var user = await _UserManager.FindByIdAsync(_IdentityUser.Id);
            if (user != null)
            {
                user.LockoutEnabled = true;
                user.LockoutEnd = DateTime.Today.AddYears(100);
                // Update the user
                await _UserManager.UpdateAsync(user);
                // reset cache!
                await UMService.ResetUserDataCache(true);
            }
            // Refresh Users
            await ReloadData();
        }

        private void EditUser(IdentityUser _IdentityUser)
        {
            // selezione come current user
            objUser = _IdentityUser;
            var pUpd = Task.Run(async () =>
            {
                var user = await UMService.UserDataGetById(objUser.Id);
                if (user != null)
                {
                    // salvo role
                    if (user.Roles != null)
                    {
                        var fRole = user.Roles.FirstOrDefault();
                        CurrentUserRole = fRole != null ? fRole : UNDEF_ROLE;
                    }
                    else
                    {
                        CurrentUserRole = UNDEF_ROLE;
                    }
                    // salvo claim
                    if (user.Claims != null && user.Claims.Count > 0)
                    {
                        var CurrentUserClaim = user.Claims.FirstOrDefault();
                        if (CurrentUserClaim != null)
                        {
                            CurrentUserClaimType = CurrentUserClaim.Type;
                            CurrentUserClaimVal = CurrentUserClaim.Value;
                        }
                    }
                    else
                    {
                        CurrentUserClaimType = STD_CLAIM;
                        CurrentUserClaimVal = "0";
                    }
                    string baseUrl = Configuration["BaseUrl"];
                    string baseAppPath = Configuration["BaseAppPath"];
                    string redirPage = Configuration["QrRedirPage"];
                    if (!string.IsNullOrEmpty(baseAppPath))
                    {
                        if (baseUrl.EndsWith("/"))
                        {
                            baseUrl = baseUrl.Substring(0, baseUrl.Length - 1);
                        }
                        baseUrl = $"{baseUrl}{baseAppPath}";
                    }
                    qrCodeVal = $"{baseUrl}Identity/Account/LogIn?uid={user.Identity.Id}&uem={user.Identity.Email}&pag={redirPage}";
                }
            });
            pUpd.Wait();
            // Open the Popup
            showCodeDetails = false;
            ShowPopup = true;
        }

        private async Task EnableUser(IdentityUser _IdentityUser)
        {
            // Close the Popup
            ShowPopup = false;

            // Get the user
            var user = await _UserManager.FindByIdAsync(_IdentityUser.Id);
            if (user != null)
            {
                user.LockoutEnabled = false;
                user.LockoutEnd = DateTime.Today.AddYears(-10);
                // Update the user
                await _UserManager.UpdateAsync(user);
                // reset cache!
                await UMService.ResetUserDataCache(true);
            }
            // Refresh Users
            await ReloadData();
        }

        private async Task refreshClaimVal(string newType)
        {
            // init vuoto
            ClaimValList = new Dictionary<string, string>();
            // aggiorno elenco ClaimValList
            switch (newType)
            {
                case "CompanyId":
                    // elenco company (tutte, ID==0) --> to dictionary!
                    var compList = await WDCService.CompanyGetByKey(0);
                    if (compList != null)
                    {
                        ClaimValList = compList
                                        .ToDictionary(x => $"{x.CompanyId}", x => x.CompanyName);
                    }
                    break;

                case "None":
                default:
                    break;
            }
        }

        private async Task refreshLists()
        {
            // effettuo refresh valori cache Company...
            if (CompanyList == null || CompanyList.Count == 0)
            {
                CompanyList = await WDCService.CompanyGetByKey(0);
            }
            // sistemo elenco ruoli dato livello utente...
            RolesList = new List<string>() { "Undef", "User", "CompUser", "CompAdmin" };
            if (currUserRole == "SuperAdmin")
            {
                RolesList.Add("DcaOrdMan");
                RolesList.Add("DcaProj");
                RolesList.Add("DcaAdmin");
                RolesList.Add("SuperAdmin");
            }
            else if (currUserRole == "DcaAdmin")
            {
                RolesList.Add("DcaOrdMan");
                RolesList.Add("DcaProj");
                RolesList.Add("DcaAdmin");
            }
            else
            {
                FiltCompany = $"{WDCUsrServ.userCurrComp}";
                CompanyList = await WDCService.CompanyGetByKey(WDCUsrServ.userCurrComp);
            }
        }

        private async Task ReloadData()
        {
            isLoading = true;
            await refreshLists();
            await GetUsers();
            isLoading = false;
        }

        private async Task SaveUser()
        {
            try
            {
                // Is this an existing user?
                if (objUser.Id != "")
                {
                    // Get the user
                    var user = await _UserManager.FindByIdAsync(objUser.Id);
                    // Update Email + check email
                    user.Email = objUser.Email;
                    user.EmailConfirmed = objUser.EmailConfirmed;
                    // Update the user
                    await _UserManager.UpdateAsync(user);
                    // Only update password if the current value is not the default value
                    if (objUser.PasswordHash != "*****")
                    {
                        var resetToken =
                            await _UserManager.GeneratePasswordResetTokenAsync(user);
                        var passworduser =
                            await _UserManager.ResetPasswordAsync(
                                user,
                                resetToken,
                                objUser.PasswordHash);
                        if (passworduser != null && !passworduser.Succeeded)
                        {
                            var errore = passworduser.Errors.FirstOrDefault();
                            if (errore != null)
                            {
                                strError = errore.Description;
                            }
                            else
                            {
                                strError = "Password error";
                            }
                            // Keep the popup opened
                            return;
                        }
                    }
                    // Gestione salvataggio ruoli... SE VARIATO...
                    var UserRoles = await _UserManager.GetRolesAsync(user);
                    if (UserRoles != null && UserRoles.Count > 0)
                    {
                        var oldRole = UserRoles.FirstOrDefault();
                        if (!CurrentUserRole.Equals(oldRole))
                        {
                            // recupero il ruolo attuale e lo rimuovo
                            await _UserManager.RemoveFromRoleAsync(user, oldRole);
                        }
                        // aggiungo il nuovo ruolo
                        await _UserManager.AddToRoleAsync(user, CurrentUserRole);
                    }
                    else
                    {
                        // aggiungo il nuovo ruolo
                        await _UserManager.AddToRoleAsync(user, CurrentUserRole);
                    }

                    // gestione salvataggio Claims
                    var UserClaims = await _UserManager.GetClaimsAsync(user);
                    if (UserClaims != null && UserClaims.Count > 0)
                    {
                        var oldClaim = UserClaims.FirstOrDefault();
                        if (oldClaim != null && !oldClaim.Equals(CurrentUserClaim))
                        {
                            // recupero il ruolo attuale e lo rimuovo
                            await _UserManager.RemoveClaimAsync(user, oldClaim);
                        }
                        // aggiungo il nuovo ruolo
                        await _UserManager.AddClaimAsync(user, CurrentUserClaim);
                    }
                    else
                    {
                        // aggiungo il nuovo ruolo
                        await _UserManager.AddClaimAsync(user, CurrentUserClaim);
                    }
                }
                else
                {
                    // Insert new user
                    var NewUser =
                        new IdentityUser
                        {
                            UserName = objUser.Email,
                            Email = objUser.Email
                        };
                    var CreateResult = await _UserManager.CreateAsync(NewUser, objUser.PasswordHash);
                    if (!CreateResult.Succeeded)
                    {
                        var currresErr = CreateResult.Errors.FirstOrDefault();
                        if (currresErr != null)
                        {
                            strError = currresErr.Description;
                        }
                        else
                        {
                            strError = "Create error";
                        }
                        // Keep the popup opened
                        return;
                    }
                    else
                    {
                        // aggiungo a ruolo undef
                        await _UserManager.AddToRoleAsync(NewUser, UNDEF_ROLE);
                        // aggiungo claim undef...
                        await _UserManager.AddClaimAsync(NewUser, CurrentUserClaim);
                    }
                }
                // Close the Popup
                ShowPopup = false;
                // reset cache!
                await UMService.ResetUserDataCache(true);
                // Refresh page
                await ReloadData();
            }
            catch (Exception ex)
            {
                strError = ex.GetBaseException().Message;
                Log.Error($"{strError}{Environment.NewLine}");
            }
        }

        private static NLog.Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Methods
    }
}