using System;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using NUnit.Framework;
using Quartz;

namespace QuartzTests
{
    public class Tests
    {
        [Test]
        public async Task Test1()
        {
            var services = new ServiceCollection();
            services.AddLogging();
            services.AddQuartz(cfg =>
            {
                cfg.UseMicrosoftDependencyInjectionScopedJobFactory();
                cfg.ScheduleJob<MyJob>(t => { });
            });
            var sp = services.BuildServiceProvider();
            var schedulerFactory = sp.GetRequiredService<ISchedulerFactory>();
            var scheduler = await schedulerFactory.GetScheduler();

            await scheduler.Start();
            await scheduler.Shutdown(waitForJobsToComplete: true);

            Assert.AreEqual(1, MyJob.ExecuteCount);
            // FAILS, ACTUAL = 2
            Assert.AreEqual(1, MyJob.DisposeCount);
        }

        class MyJob : IJob, IDisposable
        {
            static int _executeCount;
            static int _disposeCount;

            public Task Execute(IJobExecutionContext context)
            {
                Interlocked.Increment(ref _executeCount);
                return Task.CompletedTask;
            }

            public void Dispose()
            {
                Interlocked.Increment(ref _disposeCount);
            }

            public static int ExecuteCount => _executeCount;

            public static int DisposeCount => _disposeCount;
        }
    }
}