using DigitalData.Core.Exceptions;
using DigitalData.EmailProfilerDispatcher.Abstraction.Entities;
using EnvelopeGenerator.Application.Envelopes.Commands;
using EnvelopeGenerator.Domain.Constants;
using EnvelopeGenerator.Domain.Entities;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;

namespace EnvelopeGenerator.Tests.Application;

[TestFixture]
public class DeleteEnvelopeCommandTests : TestBase
{
    protected override void ConfigureServices(IServiceCollection services)
    {
    }

    [Test]
    public async Task DeleteEnvelope_DraftEnvelope_ShouldSetDeleted_CreateHistory_AndQueueDeletionEmail()
    {
        CancellationToken cancel = default;
        var reason = "Invalid receiver data";

        var envelope = this.CreateEnvelope(User.Id);
        envelope.Status = EnvelopeStatus.EnvelopeCreated;
        envelope = await GetRepository<Envelope>().CreateAsync(envelope, cancel);

        var createReceiverCmd = this.CreateReceiverCommand();
        (var receiver, _) = await Mediator.Send(createReceiverCmd, cancel);

        var envReceiver = this.CreateEnvelopeReceiver(envelope.Id, receiver.Id);
        await GetRepository<EnvelopeReceiver>().CreateAsync(envReceiver, cancel);

        var result = await Mediator.Send(new DeleteEnvelopeCommand
        {
            EnvelopeId = envelope.Id,
            Reason = reason
        }.WithAuth(User.Id), cancel);

        Assert.That(result.EnvelopeId, Is.EqualTo(envelope.Id));
        Assert.That(result.AppliedStatus, Is.EqualTo(EnvelopeStatus.EnvelopeDeleted));
        Assert.That(result.IsNoOp, Is.False);

        var histories = await GetRepository<History>().Query
            .Where(h => h.EnvelopeId == envelope.Id && h.Status == EnvelopeStatus.EnvelopeDeleted)
            .ToListAsync(cancel);
        Assert.That(histories, Has.Count.EqualTo(1));
        Assert.That(histories[0].Comment, Is.EqualTo(reason));

        var emails = await GetRepository<EmailOut>().Query
            .Where(e => e.WfId == (int)EnvelopeStatus.MessageDeletionSent && e.ReferenceId == receiver.Id)
            .ToListAsync(cancel);
        Assert.That(emails, Has.Count.EqualTo(1));
        Assert.That(emails[0].EmailAddress, Is.EqualTo(receiver.EmailAddress));
    }

    [Test]
    public async Task DeleteEnvelope_SentEnvelope_ShouldSetWithdrawn()
    {
        CancellationToken cancel = default;

        var envelope = this.CreateEnvelope(User.Id);
        envelope.Status = EnvelopeStatus.EnvelopeQueued;
        envelope = await GetRepository<Envelope>().CreateAsync(envelope, cancel);

        var result = await Mediator.Send(new DeleteEnvelopeCommand
        {
            EnvelopeId = envelope.Id,
            Reason = "Sender requested cancellation"
        }.WithAuth(User.Id), cancel);

        Assert.That(result.AppliedStatus, Is.EqualTo(EnvelopeStatus.EnvelopeWithdrawn));

        var histories = await GetRepository<History>().Query
            .Where(h => h.EnvelopeId == envelope.Id && h.Status == EnvelopeStatus.EnvelopeWithdrawn)
            .ToListAsync(cancel);
        Assert.That(histories, Has.Count.EqualTo(1));
    }

    [Test]
    public void DeleteEnvelope_MissingReason_ShouldThrowBadRequest()
    {
        Assert.ThrowsAsync<BadRequestException>(async () =>
            await Mediator.Send(new DeleteEnvelopeCommand
            {
                EnvelopeId = 123,
                Reason = "   "
            }.WithAuth(User.Id)));
    }

    [Test]
    public async Task DeleteEnvelope_WrongOwner_ShouldThrowForbidden()
    {
        CancellationToken cancel = default;

        var envelope = this.CreateEnvelope(User.Id);
        envelope = await GetRepository<Envelope>().CreateAsync(envelope, cancel);

        var otherUserCmd = this.CreateUserCommand();
        var otherUser = await GetRepository<DigitalData.UserManager.Domain.Entities.User>().CreateAsync(otherUserCmd, cancel);

        Assert.ThrowsAsync<ForbiddenException>(async () =>
            await Mediator.Send(new DeleteEnvelopeCommand
            {
                EnvelopeId = envelope.Id,
                Reason = "Not allowed"
            }.WithAuth(otherUser.Id), cancel));
    }
}