using System.Collections.Specialized;
using DigitalData.Modules.Logging;
using EnvelopeGenerator.CommonServices.Jobs;
using EnvelopeGenerator.Domain.Constants;
using Microsoft.Extensions.Options;
using Quartz;
using Quartz.Logging;

namespace EnvelopeGenerator.Service.Schedulers;

/// <summary>
/// Schedules <see cref="APIEnvelopeJob"/> via Quartz.
/// C# rewrite of the legacy <c>Scheduler_Envelopetask_API.vb</c>.
/// </summary>
public sealed class SchedulerEnvelopeTaskApi
{
    private readonly ILogger<SchedulerEnvelopeTaskApi> _logger;
    private readonly ServiceConfig _config;
    private readonly string _connectionString;

    private IScheduler? _scheduler;

    private const string JobName = "SendInvitationMailsAPI";

    public SchedulerEnvelopeTaskApi(
        ILogger<SchedulerEnvelopeTaskApi> logger,
        IOptions<ServiceConfig> config,
        string connectionString)
    {
        _logger = logger;
        _config = config.Value;
        _connectionString = connectionString;
    }

    public async Task Start(LogConfig logConfig)
    {
        try
        {
            _logger.LogDebug("Starting SchedulerEnvelopeTaskApi...");

            LogProvider.SetCurrentLogProvider(new QuartzLogProvider(_logger));

            _scheduler = await SchedulerBuilder
                .Create(new NameValueCollection())
                .UseDefaultThreadPool(x => x.MaxConcurrency = 5)
                .BuildScheduler();

            var jobKey = new JobKey(JobName);

            var jobData = new JobDataMap
            {
                { Value.LOGCONFIG, logConfig },
                { Value.DATABASE, _connectionString }
            };

            _logger.LogDebug("Initialized Job [{JobName}]", JobName);

            var job = JobBuilder.Create<APIEnvelopeJob>()
                .UsingJobData(jobData)
                .WithIdentity(jobKey)
                .Build();

            var trigger = TriggerBuilder.Create()
                .ForJob(jobKey)
                .WithIdentity($"{JobName}-trigger")
                .WithSimpleSchedule(s => s
                    .RepeatForever()
                    .WithIntervalInMinutes(_config.IntervalInMin))
                .StartNow()
                .Build();

            _logger.LogDebug("{JobName}-trigger initialized", JobName);

            await _scheduler.ScheduleJob(job, trigger);
            _logger.LogDebug("{JobName} scheduled", JobName);

            await _scheduler.Start();
            _logger.LogInformation("{JobName} started", JobName);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "SchedulerEnvelopeTaskApi failed to start");
            throw;
        }
    }

    public async Task Stop()
    {
        if (_scheduler is null) return;
        _logger.LogInformation("Stopping SchedulerEnvelopeTaskApi...");
        await _scheduler.Shutdown();
        _logger.LogInformation("SchedulerEnvelopeTaskApi stopped!");
    }
}