UniVerse/backend/UniVerse.Infrastructure/Notifications/QuartzNotificationScheduler.cs

using System.Text.Json;
using Microsoft.Extensions.Logging;
using Quartz;
using UniVerse.Application.DTOs.Notifications;
using UniVerse.Application.Interfaces;

namespace UniVerse.Infrastructure.Notifications;

public class QuartzNotificationScheduler : INotificationScheduler
{
    private const string NotificationGroup = "notifications";

    private readonly ISchedulerFactory _schedulerFactory;
    private readonly ILogger<QuartzNotificationScheduler> _logger;

    public QuartzNotificationScheduler(ISchedulerFactory schedulerFactory, ILogger<QuartzNotificationScheduler> logger)
    {
        _schedulerFactory = schedulerFactory;
        _logger = logger;
    }

    public async Task<ScheduledNotificationResponse> ScheduleAsync(NotificationMessage message, DateTimeOffset sendAt, CancellationToken cancellationToken = default)
    {
        if (sendAt <= DateTimeOffset.UtcNow)
            throw new ArgumentException("Scheduled notification time must be in the future.", nameof(sendAt));

        var scheduler = await _schedulerFactory.GetScheduler(cancellationToken);
        var jobId = Guid.NewGuid().ToString("N");
        var jobKey = new JobKey(jobId, NotificationGroup);
        var payload = JsonSerializer.Serialize(message);

        var job = JobBuilder.Create<NotificationJob>()
            .WithIdentity(jobKey)
            .UsingJobData(NotificationJob.MessageDataKey, payload)
            .Build();

        var trigger = TriggerBuilder.Create()
            .WithIdentity($"{jobId}.trigger", NotificationGroup)
            .ForJob(job)
            .StartAt(sendAt)
            .Build();

        await scheduler.ScheduleJob(job, trigger, cancellationToken);
        _logger.LogInformation("Scheduled notification job {JobId} for {SendAt}", jobId, sendAt);

        return new ScheduledNotificationResponse(jobId, sendAt);
    }
}