using dy.net.extension;
using Microsoft.Extensions.DependencyInjection;
using Quartz;

namespace dy.net.Tests;

public class QuartzPersistentStoreTests
{
    [Fact]
    public async Task ManualTrigger_WithStringTaskContext_IsPersistedWithoutBinaryFormatter()
    {
        var dataRoot = Path.Combine(Path.GetTempPath(), $"dysync-quartz-{Guid.NewGuid():N}");
        Directory.CreateDirectory(dataRoot);

        try
        {
            var schemaServices = new ServiceCollection();
            schemaServices.AddSqlsugar(dataRoot);

            var legacyJobKey = new JobKey($"legacy-{Guid.NewGuid():N}", "tests");
            var legacyServices = new ServiceCollection();
            legacyServices.AddLogging();
            legacyServices.AddQuartz(q =>
            {
                q.SchedulerId = "DouyinQuartzScheduler";
                q.SchedulerName = "DouyinSyncScheduler";
                q.UsePersistentStore(store =>
                {
                    store.UseMicrosoftSQLite(sqlite =>
                    {
                        sqlite.ConnectionString = $"DataSource={Path.Combine(dataRoot, "db", "dy.sqlite")}";
                        sqlite.TablePrefix = "QRTZ_";
                    });
                    store.UseProperties = false;
                    store.UseBinarySerializer();
                });
            });

            await using var legacyProvider = legacyServices.BuildServiceProvider();
            var legacyScheduler = await legacyProvider.GetRequiredService<ISchedulerFactory>().GetScheduler();
            var legacyJob = JobBuilder.Create<NoOpJob>()
                .WithIdentity(legacyJobKey)
                .StoreDurably()
                .Build();
            await legacyScheduler.AddJob(legacyJob, replace: false);
            await legacyScheduler.Shutdown(waitForJobsToComplete: false);

            var services = new ServiceCollection();
            services.AddLogging();
            services.AddQuartzService(dataRoot);

            await using var provider = services.BuildServiceProvider();
            var scheduler = await provider.GetRequiredService<ISchedulerFactory>().GetScheduler();
            Assert.True(await scheduler.CheckExists(legacyJobKey));
            Assert.True(await scheduler.DeleteJob(legacyJobKey));

            var jobKey = new JobKey($"manual-{Guid.NewGuid():N}", "tests");
            var job = JobBuilder.Create<NoOpJob>()
                .WithIdentity(jobKey)
                .StoreDurably()
                .Build();
            await scheduler.AddJob(job, replace: false);

            var exception = await Record.ExceptionAsync(() => scheduler.TriggerJob(jobKey, new JobDataMap
            {
                ["video-task-id"] = "task-id",
                ["video-task-trigger"] = "manual"
            }));

            Assert.Null(exception);
            await scheduler.DeleteJob(jobKey);
            await scheduler.Shutdown(waitForJobsToComplete: false);
        }
        finally
        {
            if (Directory.Exists(dataRoot)) Directory.Delete(dataRoot, recursive: true);
        }
    }

    private sealed class NoOpJob : IJob
    {
        public Task Execute(IJobExecutionContext context) => Task.CompletedTask;
    }
}