using Microsoft.AspNetCore.Components;
using System.IdentityModel.Tokens.Jwt;
using System.Text.Json;
using AyCode.Core.Extensions;
using AyCode.Core.Helpers;
using TIAMWebApp.Shared.Application.Models.ClientSide;
using TIAMWebApp.Shared.Application.Models;
using TIAMWebApp.Shared.Application.Interfaces;
using Microsoft.JSInterop;
using AyCode.Interfaces.StorageHandlers;
using TIAMSharedUI.Resources;
using Microsoft.Extensions.Localization;
using AyCode.Services.Loggers;
using Microsoft.AspNetCore.Components.Authorization;
using TIAM.Core.Consts;
using TIAM.Entities.Users;
using TIAM.Models;
using TIAM.Services;
using TIAMWebApp.Shared.Application.Services;
using TIAMSharedUI.Shared.Components.BaseComponents;

namespace TIAMSharedUI.Pages
{
    public partial class Login : BasePageComponent
    {
        [Inject] private AdminSignalRClient _adminSignalRClient { get; set; }
        
        [Inject]
        public NavigationManager navManager { get; set; }
        [Inject]
        public IUserDataService userDataService { get; set; }
        [Inject]
        public IAcLogWriterClientBase BrowserConsoleLogWriter { get; set; } //TODO: Logger... J.
        [Inject]
        public IJSRuntime jsRuntime { get; set; }
        [Inject]
        public ISecureStorageHandler secureStorageHandler { get; set; }               

        [Inject]
        public AuthenticationStateProvider AuthStateProvider { get; set; }
        [Inject] public IComponentUpdateService componentUpdateService { get; set; }
        [Inject] public ISessionService sessionService { get; set; }
        //fill loginmodel with fake but valid data

        //LoginModel loginModel = new();

        //[Display(Name = "LoginTitleText", ResourceType = typeof(MyResources))]
        public string TitleText { get; set; } = "dda,mnd,amn,a";
        private int _currentStep = 1;
        bool _loggedIn = false;
        private string messageClass = "";
        private string resultMessage = "";

        private void GoToNextStep()
        {
            _currentStep++;
        }

        private void GoToPreviousStep()
        {
            _currentStep--;
        }

        private async void SubmitLogin()
        {
            _currentStep = 1;
            BrowserConsoleLogWriter.Info("Login started: " + "Email: " + _loginModel.Email + ", Password: " + _loginModel.Password);

            var mainResponse = await userDataService.AuthenticateUser(_loginModel);

            //var response = await UserDataservice.TestUserApi(30);
            BrowserConsoleLogWriter.Info("Login started");
            //BrowserConsoleLogWriter.Info(response);

            //if (!string.IsNullOrEmpty(response))
            if (mainResponse != null)
            {
                //get token and save to local storage
                //parse to Mainresponse from json string


                //var Mainresponse = JsonSerializer.Deserialize<MainResponse>(response);
                //var mainResponse = JsonSerializer.Deserialize<MainResponse>(response, new JsonSerializerOptions { PropertyNameCaseInsensitive = true });

                if (!mainResponse.IsSuccess)
                {
                    //await App.Current.MainPage.DisplayAlert("Error", "Invalid credentials", "Ok");
                    //display error message via jsinterop
                    BrowserConsoleLogWriter.Info("Invalid credentials");
                    messageClass = "text-danger";
                    resultMessage = "Invalid credentials";
                    await InvokeAsync(StateHasChanged);
                    //navManager.NavigateTo("login");
                }
                else
                {
                    //var authResponseJson = mainResponse.Content.ToJson(); //JsonSerializer.Serialize(mainResponse.Content);
                    var authResponse = mainResponse.Content.ToJson().JsonTo<AuthenticationTokens>(); //JsonSerializer.Deserialize<AuthenticationResponse>(authResponseJson, new JsonSerializerOptions { PropertyNameCaseInsensitive = true });

                    var accessToken = authResponse.AccessToken;

                    var token = ProcessToken(accessToken);

                    var userId = token.Claims.First(claim => claim.Type == JwtRegisteredClaimNames.NameId).Value;
                    var email = token.Claims.First(claim => claim.Type == JwtRegisteredClaimNames.Email).Value;

                    var myId = Guid.Parse(userId);
                    //userDataService.User.Email = _email;

                    var userBasicDetails = new UserBasicDetails(userId, email, authResponse.AccessToken, authResponse.RefreshToken);

                    var userBasicDetailsJson = JsonSerializer.Serialize(userBasicDetails);


                    //save to local storage
                    await secureStorageHandler.SaveToSecureStorageAsync(nameof(Setting.UserBasicDetails), userBasicDetailsJson);

                    await AuthStateProvider.GetAuthenticationStateAsync();


                    //await App.Current.MainPage.DisplayAlert("Success", "Successful login", "Ok");
                    //display success message via jsinterop
                    BrowserConsoleLogWriter.Info("Successful login");
                    var user = await userDataService.IsLoggedInAsync(myId);

                    _adminSignalRClient.GetByIdAsync<SiteViewModel>(SignalRTags.GetSiteViewModelByUserId, signalResponseMessage =>
                    {
                        sessionService.SiteViewModel.Initialize(signalResponseMessage.ResponseData!);
                        BrowserConsoleLogWriter.Debug($"UnreadMessages: {sessionService.SiteViewModel.UnreadMessages.Count}");

                        componentUpdateService.CallRequestRefreshAll();
                        return Task.CompletedTask;
                    }, user.UserId).Forget();

                    messageClass = "text-success";
                    resultMessage = "Successful login";

                    SaveToSessionInfo(user).Forget();
                    navManager.NavigateTo("/");
                }
            }
            else
            {
                //api error
                //await App.Current.MainPage.DisplayAlert("Error", "An error occured while trying to login", "Ok");
                //display error message via jsinterop
                BrowserConsoleLogWriter.Warning("An error occured while trying to login");
                navManager.NavigateTo("login");
            }
        }

        protected override void OnInitialized()
        {
                        
            base.OnInitialized();
            if(_sessionService.IsAuthenticated)
            {
                navManager.NavigateTo("index");
            }
            
        }

        public JwtSecurityToken ProcessToken(string accessToken)
        {
            var handler = new JwtSecurityTokenHandler();
            var token = handler.ReadJwtToken(accessToken) as JwtSecurityToken;
            return token;
        }
        /// <summary>
        /// This method stores the user data in the session service so we know during navigation that the user is logged in.
        /// </summary>
        /// <param name="user"></param>
        protected async Task SaveToSessionInfo(UserSessionModel user)
        {
            _sessionService.User = user;
            _sessionService.IsAuthenticated = true;
            _sessionService.HasCompany = user.UserModelDto.UserProductMappings.Count > 0;
            _sessionService.IsDriver = await CheckIfDriver(user.UserModelDto.UserProductMappings);
            if (user.UserModelDto.Id == TiamConstClient.DevAdminIds[0] || user.UserModelDto.Id == TiamConstClient.DevAdminIds[1])
            {
                _sessionService.IsDevAdmin = true;
            }
            foreach (var guid in TiamConstClient.SysAdmins)
            {
                if (user.UserModelDto.Id == guid)
                {
                    _sessionService.IsSysAdmin = true;
                }
            }            
            BrowserConsoleLogWriter.Debug($"Saved to session: IsAuthenticated: {_sessionService.IsAuthenticated}, HasCompany: {_sessionService.HasCompany}, IsDriver: {_sessionService.IsDriver}, IsDevAdmin: {_sessionService.IsDevAdmin}, IsSysAdmin: {_sessionService.IsSysAdmin}");
        }

        public async Task<bool> CheckIfDriver(List<UserProductMapping> Permissions)
        {
            var _isDriver = false;

            foreach (var Permission in Permissions)
            {
                //var permissionToCheck = await ServiceProviderDataService.GetUserProductMappingByIdAsync(Permission.Id);
                BrowserConsoleLogWriter.Debug($"calling IsPowerOf with values: {Permission.Id}, {Permission.Permissions}, {1}");
                var driverPermissionResult = IsBitSet(Permission.Permissions, 1);
                if (driverPermissionResult)
                {
                    _isDriver = true;
                    _sessionService.DriverPersmissionId = Permission.Id;
                }
            }
            return _isDriver;
        }

        public bool IsBitSet(int number, int power)
        {
            BrowserConsoleLogWriter.Debug($"called IsBitSet with values: {number}, {power}");

            var powerOfTwo = 1 << power; // Calculate 2^power

            BrowserConsoleLogWriter.Debug($"powerOfTwo: {powerOfTwo}, {power}");

            var result = (number & powerOfTwo) != 0; // Check if the bit at position `power` is set
            return result;
        }
    }
}