using MongoDB.Entities;

using PrivaPub.Infrastructure.Jobs;
using PrivaPub.Models.Jobs;
using PrivaPub.Tests.Support;

namespace PrivaPub.Tests.Infrastructure
{
	public class BackoffTests
	{
		[Fact]
		public void Grows_like_mastodons()
		{
			Assert.InRange(Backoff.After(1).TotalSeconds, 16, 16 + 9 * 2);
			Assert.InRange(Backoff.After(10).TotalSeconds, 10015, 10015 + 9 * 11);
		}

		[Fact]
		public void Quarantines_a_host_only_past_the_threshold()
		{
			Assert.Equal(TimeSpan.Zero, Backoff.HostQuarantine(9, 10));
			Assert.Equal(TimeSpan.FromHours(1), Backoff.HostQuarantine(10, 10));
			Assert.Equal(TimeSpan.FromHours(4), Backoff.HostQuarantine(12, 10));
			Assert.Equal(TimeSpan.FromDays(7), Backoff.HostQuarantine(40, 10));
		}
	}

	[Trait("Category", "Integration")]
	public sealed class JobQueueTests : IAsyncLifetime
	{
		public ValueTask InitializeAsync()
		{
			Assert.SkipUnless(MongoFixture.Enabled, MongoFixture.Skip);
			return ValueTask.CompletedTask;
		}

		public ValueTask DisposeAsync() => ValueTask.CompletedTask;

		static Job NewJob(string host = default, string dedupe = default) => new()
		{
			Kind = (JobKind)99,
			Host = host,
			DedupeKey = dedupe,
			Payload = "{}"
		};

		[Fact]
		public async Task A_dedupe_key_is_queued_once()
		{
			var queue = new JobQueue();
			var key = Guid.NewGuid().ToString("N");

			var inserted = await queue.EnqueueMany(new[] { NewJob(dedupe: key), NewJob(dedupe: key) }, TestContext.Current.CancellationToken);

			Assert.Equal(1, inserted);
		}

		[Fact]
		public async Task A_busy_host_is_skipped_and_a_failed_job_backs_off()
		{
			var token = TestContext.Current.CancellationToken;
			var queue = new JobQueue();
			var kind = (JobKind)(100 + Random.Shared.Next(1000));
			var busy = $"busy{Guid.NewGuid():N}.example";
			var free = $"free{Guid.NewGuid():N}.example";
			await queue.EnqueueMany(new[] { new Job { Kind = kind, Host = busy }, new Job { Kind = kind, Host = free } }, token);

			var leased = await queue.Lease(kind, new[] { busy }, token);
			Assert.Equal(free, leased.Host);
			Assert.Equal(1, leased.Attempts);

			await queue.Finish(leased, JobOutcome.Retry("boom"), maxAttempts: 3, token);
			var after = await DB.Default.Find<Job>().OneAsync(leased.ID, token);
			Assert.Equal(JobState.Pending, after.State);
			Assert.True(after.RunAt > DateTime.UtcNow.AddSeconds(10));

			leased.Attempts = 3;
			await queue.Finish(leased, JobOutcome.Retry("boom"), maxAttempts: 3, token);
			Assert.Equal(JobState.Dead, (await DB.Default.Find<Job>().OneAsync(leased.ID, token)).State);
		}

		[Fact]
		public async Task An_expired_lease_returns_to_the_queue()
		{
			var token = TestContext.Current.CancellationToken;
			var job = new Job { Kind = (JobKind)98, State = JobState.Running, LeasedUntil = DateTime.UtcNow.AddMinutes(-1) };
			await DB.Default.SaveAsync(job, token);

			await new JobQueue(j => j.ID == job.ID).Reap(token);

			Assert.Equal(JobState.Pending, (await DB.Default.Find<Job>().OneAsync(job.ID, token)).State);
		}
	}
}