CardHybridCircuitSession.cs

이 파일의 문서화 페이지로 가기

using System.Diagnostics;
using System.Security.Claims;
using Codemaru.Models;
using Codemaru.States;
using Dreamine.Identity;
using Microsoft.AspNetCore.Components.Authorization;
 
namespace Codemaru.Services;

public sealed class CardHybridCircuitSession : IDisposable
{
    private readonly SemaphoreSlim _saveLock = new(1, 1);
    private readonly List<CardHistoryEntry> _history = new();
    private readonly IQrSvgGenerator _qr;
    private readonly ICardProfileStore _store;
    private readonly AuthenticationStateProvider? _authProvider;

    private CardHybridState _state;
    private CardHybridUser _currentUser = CardHybridUser.Guest;
    private bool _hasGuestChanges;
    private bool _initialized;

    public CardHybridCircuitSession(
        IQrSvgGenerator qr,
        ICardProfileStore store,
        AuthenticationStateProvider? authProvider = null)
    {
        _qr = qr ?? throw new ArgumentNullException(nameof(qr));
        _store = store ?? throw new ArgumentNullException(nameof(store));
        _authProvider = authProvider;
        _state = CardHybridState.CreateDefault(_qr.CreateSvg(CardProfile.Default.LandingUrl));
    }

    public CardHybridState State => _state;
    public CardHybridUser CurrentUser => _currentUser;

    public bool HasGuestChanges => _hasGuestChanges && _currentUser.IsGuest;

    public event EventHandler<CardHybridState>? StateChanged;

    public async Task EnsureInitializedAsync(CancellationToken cancellationToken = default)
    {
        if (_initialized)
        {
            return;
        }
        _initialized = true;
 
        if (_authProvider is null)
        {
            return;
        }
 
        var authState = await _authProvider.GetAuthenticationStateAsync().ConfigureAwait(false);
        var user = MapPrincipalToUser(authState.User);
        await ApplyUserAsync(user, cancellationToken).ConfigureAwait(false);
    }

    private static CardHybridUser MapPrincipalToUser(ClaimsPrincipal principal)
    {
        if (principal?.Identity?.IsAuthenticated != true)
        {
            return CardHybridUser.Guest;
        }
 
        var userIdClaim = principal.FindFirstValue(DreamineIdentityExtensions.UserIdClaimType);
        if (string.IsNullOrEmpty(userIdClaim))
        {
            return CardHybridUser.Guest;
        }
 
        var email = principal.FindFirstValue(ClaimTypes.Email) ?? string.Empty;
        var name = principal.FindFirstValue(ClaimTypes.Name)
                   ?? principal.FindFirstValue(ClaimTypes.GivenName)
                   ?? string.Empty;
 
        return new CardHybridUser(
            Id: $"oauth-{userIdClaim}",
            Email: email,
            DisplayName: string.IsNullOrWhiteSpace(name) ? email : name,
            SignedInAt: DateTime.UtcNow);
    }

    public async Task ApplyUserAsync(CardHybridUser user, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(user);
 
        _currentUser = user;
        var snapshot = await _store.LoadAsync(user.Id, cancellationToken).ConfigureAwait(false);
        LoadSnapshot(snapshot);
        _hasGuestChanges = false;
        NotifyStateChanged();
    }

    public async Task ReplaceUserSnapshotAsync(CardHybridSnapshot snapshot, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(snapshot);
 
        if (_currentUser.IsGuest)
        {
            throw new InvalidOperationException("Cannot replace snapshot for guest user.");
        }
 
        var withUserId = snapshot with { UserId = _currentUser.Id };
        LoadSnapshot(withUserId);
        _hasGuestChanges = false;
 
        await _store.SaveAsync(_currentUser.Id, withUserId, cancellationToken).ConfigureAwait(false);
        NotifyStateChanged();
    }

    public CardHybridSnapshot CaptureCurrentSnapshot() =>
        new(_currentUser.Id, _state.Profile, _history.ToArray(), DateTime.Now);

    public void ImportSnapshot(CardHybridSnapshot snapshot)
    {
        ArgumentNullException.ThrowIfNull(snapshot);
        LoadSnapshot(snapshot);
        if (_currentUser.IsGuest)
        {
            _hasGuestChanges = true;
        }
        NotifyStateChanged();
    }

    public void UpdateProfile(CardProfile profile)
    {
        var payload = profile.LandingUrl;
        _state = _state with
        {
            Profile = profile,
            QrPayload = payload,
            QrSvg = _qr.CreateSvg(payload),
            LastUpdated = DateTime.Now
        };
        MarkDirty();
        PersistCurrent();
        NotifyStateChanged();
    }

    public CardHistoryEntry SaveCurrent()
    {
        var entry = new CardHistoryEntry(
            Id: Guid.NewGuid(),
            Profile: _state.Profile,
            LandingUrl: _state.Profile.LandingUrl,
            QrPayload: _state.QrPayload,
            CreatedAt: DateTime.Now);
 
        _history.Insert(0, entry);
        _state = _state with { History = _history.ToArray(), LastUpdated = DateTime.Now };
        MarkDirty();
        PersistCurrent();
        NotifyStateChanged();
        return entry;
    }

    public CardHistoryEntry? UpdateHistory(Guid id, CardProfile profile)
    {
        var index = _history.FindIndex(e => e.Id == id);
        if (index < 0)
            return null;
 
        var payload = profile.LandingUrl;
        var entry = _history[index] with
        {
            Profile = profile,
            LandingUrl = payload,
            QrPayload = payload,
            CreatedAt = DateTime.Now
        };
        _history[index] = entry;
        _state = _state with
        {
            Profile = profile,
            QrPayload = payload,
            QrSvg = _qr.CreateSvg(payload),
            History = _history.ToArray(),
            LastUpdated = DateTime.Now
        };
        MarkDirty();
        PersistCurrent();
        NotifyStateChanged();
        return entry;
    }

    public void LoadHistory(CardHistoryEntry entry) => UpdateProfile(entry.Profile);

    public void ClearHistory()
    {
        _history.Clear();
        _state = _state with { History = Array.Empty<CardHistoryEntry>(), LastUpdated = DateTime.Now };
        MarkDirty();
        PersistCurrent();
        NotifyStateChanged();
    }

    public bool RemoveHistory(Guid id)
    {
        var index = _history.FindIndex(e => e.Id == id);
        if (index < 0)
            return false;
 
        _history.RemoveAt(index);
        _state = _state with { History = _history.ToArray() };
        MarkDirty();
        PersistCurrent();
        NotifyStateChanged();
        return true;
    }

    private void LoadSnapshot(CardHybridSnapshot? snapshot)
    {
        _history.Clear();
        if (snapshot?.History is not null)
            _history.AddRange(snapshot.History);
 
        var profile = snapshot?.Profile ?? CardProfile.Default;
        _state = CardHybridState.Create(profile, _qr.CreateSvg(profile.LandingUrl), _history.ToArray());
    }

    private void MarkDirty()
    {
        if (_currentUser.IsGuest)
        {
            _hasGuestChanges = true;
        }
    }

    private void PersistCurrent()
    {
        if (_currentUser.IsGuest)
        {
            return;
        }
 
        var snapshot = new CardHybridSnapshot(
            _currentUser.Id, _state.Profile, _history.ToArray(), DateTime.Now);
        var userId = _currentUser.Id;
 
        _ = Task.Run(async () =>
        {
            await _saveLock.WaitAsync().ConfigureAwait(false);
            try
            {
                await _store.SaveAsync(userId, snapshot).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"CardHybridCircuitSession save failed: {ex}");
            }
            finally
            {
                _saveLock.Release();
            }
        });
    }

    private void NotifyStateChanged()
    {
        var handlers = StateChanged?.GetInvocationList();
        if (handlers is null)
            return;
 
        foreach (var handler in handlers)
        {
            try { ((EventHandler<CardHybridState>)handler).Invoke(this, _state); }
            catch (Exception ex) { Debug.WriteLine($"CardHybridCircuitSession handler failed: {ex}"); }
        }
    }

    public void Dispose() => _saveLock.Dispose();
}