@* @page "/"; *@
@using Microsoft.AspNetCore.Components.Authorization
@using TIAM.Core.Consts
@using TIAM.Entities.Users
@using TIAMWebApp.Shared.Application.Interfaces
@using TIAMWebApp.Shared.Application.Models
@using TIAMWebApp.Shared.Application.Utility
@using Newtonsoft.Json
@using System.IdentityModel.Tokens.Jwt
@using TIAMWebApp.Shared.Application.Models.ClientSide
@using AyCode.Interfaces.StorageHandlers;
@using System.Globalization;
@using AyCode.Core.Enums
@using AyCode.Core.Extensions
@using AyCode.Core.Helpers
@using AyCode.Core.Loggers
@using AyCode.Services.Loggers
@using TIAM.Core.Loggers
@using TIAM.Models
@using TIAM.Services
@using TIAMSharedUI.Shared.Components
@using TIAMWebApp.Shared.Application.Services
@inject NavigationManager NavManager
@inject IJSRuntime JSRuntime
@inject IEnumerable<IAcLogWriterClientBase> LogWriters
@inject IUserDataService UserDataService
@inject IServiceProviderDataService ServiceProviderDataService
@inject ISecureStorageHandler SecureStorageHandler
@inject ISessionService sessionService;
@inject HttpClient http;
@inject IComponentUpdateService ComponentUpdateService
@inject AuthenticationStateProvider AuthStateProvider
@inject AdminSignalRClient _adminSignalRClient;

@{
    if (string.IsNullOrWhiteSpace(TrackingId))
    {
        TrackingId = "";
        // <p>Loading...</p>
    }
    else
    {
        <p>Loading with trackingId: @TrackingId</p>
    }
}


@code {

    [Parameter]
    public string TrackingId { get; set; }

    string userDetailsStr;
    string locale;
    ILogger _logger;

    protected override async Task OnInitializedAsync()
    {
        _logger = new LoggerClient<AppLaunchComponent>(LogWriters.ToArray());

        var (_userDetailStr, _locale) = await GetLocalSettings();

        userDetailsStr = _userDetailStr;

        if(_locale != null)
        {            
            locale = _locale;
            Culture = new CultureInfo(locale);
            _logger.Info("Locale from settings: " + locale);
        }
        else
        {
            _logger.Info("Default locale:" + Culture.Name);
        }

        //_logger = new _logger(JSRuntime);
        //wait for 5 seconds
        //await Task.Delay(1000);                      

        if (!string.IsNullOrWhiteSpace(userDetailsStr))
        {
            _logger.Info(userDetailsStr);
            var userBasicDetail = JsonConvert.DeserializeObject<UserBasicDetails>(userDetailsStr);

            var handler = new JwtSecurityTokenHandler();
            var jsontoken = handler.ReadToken(userBasicDetail?.AccessToken) as JwtSecurityToken;

            if(userBasicDetail!= null)
                Setting.UserBasicDetails = userBasicDetail;

            var isSuccess = false;
            if (jsontoken?.ValidTo < DateTime.UtcNow)
            {
                _logger.Info("Token needs to be refreshed");
                bool isTokenRefreshed = await UserDataService.RefreshToken();

                if (isTokenRefreshed)
                {
                    await AuthStateProvider.GetAuthenticationStateAsync();
                    _logger.Info("Token refreshed");

                    isSuccess = true;

                }
                else
                {
                    _logger.Info("Couldn't refresh token");
                    await SignOut();
                    //NavManager.NavigateTo("/");
                    return;
                }

            }
            else
            {
                _logger.Info("Valid token found");
                await AuthStateProvider.GetAuthenticationStateAsync();

                isSuccess = true;
            }

            if (isSuccess)
            {
                var userId = jsontoken.Claims.First(claim => claim.Type == JwtRegisteredClaimNames.NameId).Value;
                //var email = jsontoken.Claims.First(claim => claim.Type == JwtRegisteredClaimNames.Email).Value;
                var user = await UserDataService.IsLoggedInAsync(Guid.Parse(userId));

                SaveToSessionInfo(user);
                _logger.Info($"Saved user in db is: {user.DisplayName}, setting autenthicated state");

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

                    ComponentUpdateService.CallRequestRefresh<Navbar>();
                    return Task.CompletedTask;
                }, user.UserId).Forget();
            }

            //NavManager.NavigateTo("/");
        }
        else
        {
            _logger.Info("No token stored yet");
            //NavManager.NavigateTo("/");
        }

        ComponentUpdateService.CallRequestRefreshAll();
    }

    protected void SaveToSessionInfo(UserSessionModel user)
    {
        sessionService.User = user;
        sessionService.IsAuthenticated = true;
        sessionService.HasCompany = user.UserModelDto.UserProductMappings.Count > 0;

        _logger.Debug($"Checking driver for: {user.UserModelDto.UserProductMappings.Count} mapping");

        sessionService.IsDriver = 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;
            }
        }

        _logger.Debug($"Saved to session: IsAuthenticated: {sessionService.IsAuthenticated}, HasCompany: {sessionService.HasCompany}, IsDriver: {sessionService.IsDriver}, IsDevAdmin: {sessionService.IsDevAdmin}, IsSysAdmin: {sessionService.IsSysAdmin}");
    }

    public bool CheckIfDriver(List<UserProductMapping> permissions)
    {
        bool isDriver = false;

        foreach (UserProductMapping permission in permissions)
        {
            //var permissionToCheck = await ServiceProviderDataService.GetUserProductMappingByIdAsync(Permission.Id);
            _logger.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)
    {
        _logger.Debug($"called IsBitSet with values: {number}, {power}");

        int powerOfTwo = 1 << power; // Calculate 2^power
        
        _logger.Debug($"powerOfTwo: {powerOfTwo}, {power}");

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

    public async Task<(string, string)> GetLocalSettings()
    {
        string userDetailsStr = await SecureStorageHandler.GetFromSecureStorageAsync(nameof(Setting.UserBasicDetails));
        string locale = await SecureStorageHandler.GetFromSecureStorageAsync(nameof(Setting.Locale));
        return (userDetailsStr, locale);
    }

    private async Task SignOut()
    {
        _logger.Info("SignOut called");

        var userBasicDetail = userDetailsStr.JsonTo<UserBasicDetails>();

        await AuthStateProvider.GetAuthenticationStateAsync();
        await SecureStorageHandler.ClearAllSecureStorageAsync();
        
        sessionService.ClearAll();
        ComponentUpdateService.CallRequestRefreshAll();

        UserDataService.Logout(userBasicDetail?.RefreshToken).Forget();
    }

    CultureInfo Culture
    {
        get => CultureInfo.CurrentCulture;
        set
        {
            if (!Equals(CultureInfo.CurrentCulture, value))
            {
                Thread.CurrentThread.CurrentCulture = value;
                Thread.CurrentThread.CurrentUICulture = value;
                CultureInfo.DefaultThreadCurrentCulture = value;
                CultureInfo.DefaultThreadCurrentUICulture = value;                
            }
        }
    }


}