using System.IdentityModel.Tokens.Jwt;
using System.Text.Json;
using Blazored.LocalStorage;
using HealthcareManagerUiWebAssem.Models;
using HealthcareManagerUiWebAssem.Services.RequestHttp;
using Microsoft.AspNetCore.Components.Authorization;

namespace HealthcareManagerUiWebAssem.Services.Authentication;

public class AuthenticationService(
    IRequestHttpService requestHttpService,
    ILocalStorageService localStorageService,
    AuthenticationStateProvider authenticationStateProvider)
    : IAuthenticationService
{
    public async Task<ApiResponse<string>> Login(UserLoginModel loginModel)
    {
        var response = await requestHttpService.PostAsync("/api/Authorization/login", loginModel);
        var responseContent = await response.Content.ReadAsStringAsync();

        var loginResponse = JsonSerializer.Deserialize<ApiResponse<string>>(responseContent,
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        if (response.IsSuccessStatusCode) await localStorageService.SetItemAsync("authToken", loginResponse.Data);
        return loginResponse;
    }

    public async Task<ApiResponse<string>> Register(UserRegisterModel registerModel)
    {
        var response = await requestHttpService.PostAsync("/api/Authorization/register", registerModel);
        var responseContent = await response.Content.ReadAsStringAsync();

        var registerResponse = JsonSerializer.Deserialize<ApiResponse<string>>(responseContent,
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        return registerResponse;
    }

    public async Task<ApiResponse<string>> ResetJwt(string token)
    {
        var requestBody = new { token };
        var response = await requestHttpService.PostAsync("/api/Authorization/refresh_token", requestBody);
        var responseContent = await response.Content.ReadAsStringAsync();

        var resetJwtResponse = JsonSerializer.Deserialize<ApiResponse<string>>(responseContent,
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        if (response.IsSuccessStatusCode) await localStorageService.SetItemAsync("authToken", resetJwtResponse.Data);
        return resetJwtResponse;
    }

    public async Task<ApiResponse<object>> ResetPassword(ResetPasswordModel resetPasswordModel)
    {
        var requestBody = new { email = resetPasswordModel.Email, password = resetPasswordModel.Password };
        var response = await requestHttpService.PostAsync("/api/Authorization/reset_password", requestBody);
        var responseContent = await response.Content.ReadAsStringAsync();

        var resetPasswordResponse = JsonSerializer.Deserialize<ApiResponse<object>>(responseContent,
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        return resetPasswordResponse;
    }


    public async Task<UserInformation?> GetUserInformation()
    {
        var token = await GetAuthToken();
        if (string.IsNullOrEmpty(token)) return null;

        var handler = new JwtSecurityTokenHandler();
        var jwtToken = handler.ReadJwtToken(token);

        var name = jwtToken.Claims.FirstOrDefault(c => c.Type == "unique_name")?.Value;
        var id = jwtToken.Claims.FirstOrDefault(c => c.Type == "nameid")?.Value;
        var role = jwtToken.Claims.FirstOrDefault(c => c.Type == "role")?.Value;

        return new UserInformation
        {
            Name = name,
            Id = Guid.Parse(id),
            Role = role
        };
    }

    public async Task Logout()
    {
        await localStorageService.RemoveItemAsync("authToken");
        ((CustomAuthenticationStateProvider)authenticationStateProvider).NotifyUserLogout();
    }

    public async Task<string> GetAuthToken()
    {
        return await localStorageService.GetItemAsync<string>("authToken");
    }

    public async Task RemoveAuthToken()
    {
        await localStorageService.RemoveItemAsync("authToken");
    }
}