AcaMate_Web/Program/Services/UserStateService.cs

using System.Text.Json;
using Front.Program.Services;
using Front.Program.Models;
using Microsoft.JSInterop;
using System.ComponentModel; // INotifyPropertyChanged를 위해 추가
using System.Runtime.CompilerServices; // CallerMemberName을 위해 추가

namespace Front.Program.ViewModels;

public class UserStateService(StorageService _storageService, SecureService _secureService, APIService _APIService,
    IJSRuntime _js) : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler? PropertyChanged;

    protected virtual void OnPropertyChanged([CallerMemberName] string? propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    private Models.SimpleAcademy? _currentAcademy;
    public Models.SimpleAcademy? CurrentAcademy
    {
        get => _currentAcademy;
        set
        {
            if (_currentAcademy != value)
            {
                _currentAcademy = value;
                OnPropertyChanged();
            }
        }
    }

    public UserData UserData { get; set; } = new UserData();
    
    public bool isFirstCheck { get; set; } = false;
    public bool isLogin { get; set; } = false;
    
    public Models.SimpleAcademy[] academyItems = Array.Empty<Models.SimpleAcademy>();
    
    
    public async Task<(bool success,UserData? userData)> GetUserDataFromStorageAsync()
    {
        try
        {
            var encUserData = await _storageService.GetItemAsync("UsDt");
            
            if (!string.IsNullOrEmpty(encUserData))
            {
                
                var decUserData = await _secureService.DecryptAsync(encUserData);

                var userData = JsonSerializer.Deserialize<UserData>(decUserData,
                    new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
                
                LoggerService.Write($"UserData: {userData.Name}, {userData.Type}");
                
                
                return (true, userData);
            }
            else
            {
                return (false, null);
            }
        }
        catch (Exception ex)
        {
            LoggerService.Write($"Error [GetUserDataFormAsync] : {ex.Message}");
            return (false, null);
        }
    }


    public async Task<bool> GetUserDataAsync()
    {
        try
        {
            LoggerService.Write("GetUserDataAsync 호출됨");
            var isLoginFromStorage = await _storageService.GetItemAsync("IsLogin");
            LoggerService.Write($"Storage에서 읽은 IsLogin 값: {isLoginFromStorage ?? "null"}");

        // 로그인 상태가 아니라면 애초에 할 필요 없음
            if (isLoginFromStorage != "true")
            {
                isLogin = false;
                return false;
            }
            
            isLogin = true;

            var userDataForm = await GetUserDataFromStorageAsync();

            if (userDataForm.success && userDataForm.userData != null)
            {
                // 사용자 데이터가 성공적으로 로드되었을 때의 로직
                UserData = userDataForm.userData;
                return true;
            }
            else
            {
                var userDataFromServer = await GetUserDataFromServerAsync();
                if (userDataFromServer.success && userDataFromServer.userData != null)
                {
                    // 서버에서 사용자 데이터를 성공적으로 로드했을 때의 로직
                    UserData = userDataFromServer.userData;
                    return true;
                }
                else
                {
                    // 사용자 데이터를 로드하지 못했을 때의 로직
                    LoggerService.Write("사용자 데이터를 로드하지 못했습니다.");
                    isLogin = false;
                    return false;
                }
            }
        }
        finally
        {
            if (!isFirstCheck) isFirstCheck = true;
        }
    }
    
    public async Task ClearUserStateAsnyc()
    {
        try
        {
            string[] keys = { "UsDt", "IsLogin", "UsAcDt" };
            foreach (var key in keys)
            {
                var remove = await _storageService.RemoveItemAsync(key);
                LoggerService.Write("사용자 데이터 삭제" + (remove ? "성공 :" : "실패 :") + key);
            }
            ClearStateData();
        }
        catch (Exception ex)
        {
            LoggerService.Write($"사용자 데이터 삭제 중 오류: {ex.Message}");
        }
    }

    private void ClearStateData()
    {
        isLogin = false;
        UserData = new UserData();
        academyItems = Array.Empty<Models.SimpleAcademy>();
    }

    public async Task<(bool success, UserData? userData)> GetUserDataFromServerAsync()
    {
        var data = await _APIService.GetConnectServerAsnyc<UserData>("/api/v1/in/user");
        if (data is { success: true, json: not null })
            await _storageService.SetItemAsync("UsDt", data.json); 
        return (data.success, data.data);
    } 
    
    public async Task<(bool success, List<SimpleAcademy>? simpleAcademy)> GetAcademy()
    {
        var data = await _APIService.GetConnectServerAsnyc<List<SimpleAcademy>>("/api/v1/in/user/academy");
        if (data is { success: true, json: not null })
        {
            await _storageService.SetItemAsync("UsAcDt", data.json); 
            if (data.data != null && data.data.Any())
            {
                academyItems = data.data.ToArray();
                CurrentAcademy = data.data.First(); // 첫 번째 학원을 현재 학원으로 설정
            }
        }
        return (data.success, data.data);
    }
}