Quartz.NET CRON trigger with Past dates

using Quartz;

namespace Data.Export.Api.Services;

public class SchedulingService : ISchedulingService
{
    private readonly ILogger<SchedulingService> logger;
    private readonly ISchedulerFactory schedulerFactory;

    public SchedulingService(
        ILogger<SchedulingService> logger,
        ISchedulerFactory schedulerFactory
    )
    {
        this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
        this.schedulerFactory = schedulerFactory ?? throw new ArgumentNullException(nameof(schedulerFactory));
    }

    public async Task ScheduleJobAsync(DataExportTask dataExportTask)
    {
        if (!CronExpression.IsValidExpression(dataExportTask.CronExpression))
        {
            throw new ArgumentException("Cron expression is not valid");
        }

        IScheduler scheduler = await schedulerFactory.GetScheduler();
        TriggerKey triggerKey = new(dataExportTask.Id.ToString());
        JobKey jobKey = new(dataExportTask.Id.ToString());
        ITrigger? existingTrigger = await GetExistingTriggerAsync(scheduler, triggerKey);
        IJobDetail? existingJob = await GetExistingJobAsync(scheduler, jobKey);

        if (dataExportTask.IsEnabled)
        {
            IJobDetail job = CreateJobDetail(dataExportTask);
            ITrigger trigger = CreateTrigger(dataExportTask);
            if (existingTrigger != null && existingJob != null)
            {
                await RescheduleJobAsync(scheduler, triggerKey, trigger);
            }
            else
            {
                await ScheduleJobAsync(scheduler, job, trigger);
            }
        }
        else
        {
            if (existingTrigger != null)
            {
                await UnscheduleJobAsync(scheduler, triggerKey);
            }

            if (existingJob != null)
            {
                await DeleteJobAsync(scheduler, jobKey);
            }
        }
    }

    private static IJobDetail CreateJobDetail(DataExportTask dataExportTask) => JobBuilder.Create<DataExportJob>()
                .WithIdentity(CreateJobKey(dataExportTask))
                .UsingJobData("TaskId", dataExportTask.Id.ToString())
                .UsingJobData("TaskName", dataExportTask.Name)
                .Build();

    private static JobKey CreateJobKey(DataExportTask dataExportTask) => new(dataExportTask.Id.ToString());

    private static ITrigger CreateTrigger(DataExportTask dataExportTask) =>
        TriggerBuilder.Create()
            .WithIdentity(CreateTriggerKey(dataExportTask))
            .WithCronSchedule(dataExportTask.CronExpression, e => e.WithMisfireHandlingInstructionIgnoreMisfires())
            .Build();

    private static TriggerKey CreateTriggerKey(DataExportTask dataExportTask) => new(dataExportTask.Id.ToString());

    private async Task DeleteJobAsync(IScheduler scheduler, JobKey jobKey)
    {
        try
        {
            await scheduler.DeleteJob(jobKey);
        }
        catch (Exception e)
        {
            logger.LogError("Exception {Message}", e.Message);
            logger.LogError("StackTrace {StackTrace}", e.StackTrace);
            throw new Exception("Failed to delete job", e);
        }
    }

    private static async Task<IJobDetail?> GetExistingJobAsync(IScheduler scheduler, JobKey jobKey) => await scheduler.GetJobDetail(jobKey);

    private static async Task<ITrigger?> GetExistingTriggerAsync(IScheduler scheduler, TriggerKey triggerKey) => await scheduler.GetTrigger(triggerKey);

    private async Task RescheduleJobAsync(IScheduler scheduler, TriggerKey triggerKey, ITrigger trigger)
    {
        try
        {
            await scheduler.RescheduleJob(triggerKey, trigger);
        }
        catch (Exception e)
        {
            logger.LogError("Exception {Message}", e.Message);
            logger.LogError("StackTrace {StackTrace}", e.StackTrace);
            throw new Exception("Failed to reschedule job", e);
        }
    }

    private async Task ScheduleJobAsync(IScheduler scheduler, IJobDetail job, ITrigger trigger)
    {
        try
        {
            await scheduler.ScheduleJob(job, trigger);
        }
        catch (Exception e)
        {
            logger.LogError("Exception {Message}", e.Message);
            logger.LogError("StackTrace {StackTrace}", e.StackTrace);
            throw new Exception("Failed to schedule job", e);
        }
    }

    private async Task UnscheduleJobAsync(IScheduler scheduler, TriggerKey triggerKey)
    {
        try
        {
            await scheduler.UnscheduleJob(triggerKey);
        }
        catch (Exception e)
        {
            logger.LogError("Exception {Message}", e.Message);
            logger.LogError("StackTrace {StackTrace}", e.StackTrace);
            throw new Exception("Failed to unschedule job", e);
        }
    }
}