AcaMate_Web/Program/Services/UserService.cs

using System.Text.Json;
using Microsoft.JSInterop;

namespace Front.Program.Services;

public class UserService
{
    private readonly StorageService _storageService;
    private readonly SecureService _secureService;
    private readonly IJSRuntime _js;
    private readonly ILogger<UserService> _logger;

    public UserService(
        StorageService storageService,
        SecureService secureService,
        IJSRuntime js,
        ILogger<UserService> logger)
    {
        _storageService = storageService;
        _secureService = secureService;
        _js = js;
        _logger = logger;
    }

    public class UserData
    {
        public string Uid { get; set; } = string.Empty;
        public string Name { get; set; } = string.Empty;
        public DateTime? Birth { get; set; }
        public string Type { get; set; } = string.Empty;
        public string? DeviceId { get; set; }
        public bool AutoLoginYn { get; set; }
        public DateTime LoginDate { get; set; }
        public string? PushToken { get; set; }
    }

    public async Task<(bool success, UserData? userData)> GetUserData()
    {
        try
        {
            // 1. 먼저 저장된 데이터 확인
            var encryptedUserData = await _storageService.GetItemAsync("USER_DATA");
            if (!string.IsNullOrEmpty(encryptedUserData))
            {
                try
                {
                    var decryptedUserData = await _secureService.DecryptAsync(encryptedUserData);
                    var userData = JsonSerializer.Deserialize<UserData>(decryptedUserData);
                    if (userData != null && !string.IsNullOrEmpty(userData.Name))
                    {
                        _logger.LogInformation("저장된 사용자 데이터 로드 성공");
                        return (true, userData);
                    }
                }
                catch (Exception ex)
                {
                    _logger.LogWarning($"저장된 사용자 데이터 복호화 실패: {ex.Message}");
                    await _storageService.RemoveItemAsync("USER_DATA");
                }
            }

            // 2. API 호출
            var headerValue = await _storageService.GetItemAsync("Web_AM_Connect_Key");
            if (string.IsNullOrEmpty(headerValue))
            {
                _logger.LogWarning("연결 키가 없습니다");
                return (false, null);
            }

            _logger.LogInformation("세션 API 호출 시작");
            var response = await _js.InvokeAsync<JsonElement>("fetchWithHeaderAndReturnUrl", 
                "/api/v1/in/user/auth/session", 
                "GET", 
                "Web_AM_Connect_Key", 
                headerValue);

            if (response.TryGetProperty("data", out var dataElement))
            {
                try
                {
                    // 전체 데이터 암호화 저장
                    var userDataJson = dataElement.ToString();
                    var userData = JsonSerializer.Deserialize<UserData>(userDataJson);
                    
                    if (userData != null && !string.IsNullOrEmpty(userData.Name))
                    {
                        var encryptedData = await _secureService.EncryptAsync(userDataJson);
                        await _storageService.SetItemAsync("USER_DATA", encryptedData);
                        await _storageService.SetItemAsync("Web_AM_Connect_Key", headerValue);
                        
                        _logger.LogInformation($"사용자 데이터 저장 성공: {userData.Name}");
                        return (true, userData);
                    }
                    else
                    {
                        _logger.LogWarning("사용자 데이터에 필수 정보가 없습니다");
                        return (false, null);
                    }
                }
                catch (Exception ex)
                {
                    _logger.LogError($"사용자 데이터 처리 중 오류: {ex.Message}");
                    return (false, null);
                }
            }

            _logger.LogWarning("사용자 데이터를 찾을 수 없습니다");
            return (false, null);
        }
        catch (Exception ex)
        {
            _logger.LogError($"사용자 데이터 조회 중 오류: {ex.Message}");
            return (false, null);
        }
    }

    public async Task<bool> ClearUserData()
    {
        try
        {
            await _storageService.RemoveItemAsync("USER_DATA");
            await _storageService.RemoveItemAsync("USER");
            await _storageService.RemoveItemAsync("Web_AM_Connect_Key");
            _logger.LogInformation("사용자 데이터 삭제 성공");
            return true;
        }
        catch (Exception ex)
        {
            _logger.LogError($"사용자 데이터 삭제 중 오류: {ex.Message}");
            return false;
        }
    }
}