final class SendFailedAsyncMessageToFailureTransportMiddleware implements MiddlewareInterface
{
    /**
     * @var MessageBusInterface
     */
    private MessageBusInterface $messageBus;

    /**
     * @var SendersLocatorInterface
     */
    private SendersLocatorInterface $sendersLocator;

    public function __construct(MessageBusInterface $messageBus, SendersLocatorInterface $sendersLocator)
    {
        $this->messageBus = $messageBus;
        $this->sendersLocator = $sendersLocator;
    }

    public function handle(Envelope $envelope, StackInterface $stack): Envelope
    {
        $resultEnvelope = $envelope;

        try {
            if ($this->isReceivedFromFailureTransport($envelope)) {
                $resultEnvelope = $envelope
                    // to avoid handling message but instead use senders to redispatch to original transport, see SendMessageMiddleware
                    ->withoutAll(ReceivedStamp::class)
                    // process this message as a new and allow it to be sent to failure transport again in case of new errors
                    ->withoutAll(SentToFailureTransportStamp::class)
                    // to avoid redelivering to failed queue again. We need to process message by original sender (QueueInterop), see SendMessageMiddleware::getSenders
                    ->withoutAll(RedeliveryStamp::class);
            }

            return $stack->next()->handle($resultEnvelope, $stack);
        } catch (AsyncTransportIsNotAvailableException $e) {
            if (!$this->isAlreadySentToFailedSender($resultEnvelope)) {
                $originalReceiverName = $this->getOriginalReceiverName($resultEnvelope);

                // taken from built-in SendFailedMessageToFailureTransportListener
                $flattenedException = class_exists(FlattenException::class) ? FlattenException::createFromThrowable($e) : null;
                $newEnvelope = $resultEnvelope
                    ->withoutAll(ReceivedStamp::class)
                    ->withoutAll(TransportMessageIdStamp::class)
                    ->with(new SentToFailureTransportStamp($originalReceiverName))
                    ->with(new DelayStamp(0))
                    ->with(new FailedToBeSentToAsyncQueue())
                    ->with(new RedeliveryStamp(0, 'failed', $e->getMessage(), $flattenedException));

                $this->messageBus->dispatch($newEnvelope);
            }
        }

        return $resultEnvelope;
    }

    /**
     * Returns `true` when the failed message is consumed from failure transport,
     * for example by running `bin/console messenger:failed:retry`
     *
     * @param Envelope $envelope
     *
     * @return bool
     */
    private function isReceivedFromFailureTransport(Envelope $envelope): bool
    {
        $failedToBeSentToAsyncQueueStamps = $envelope->all(FailedToBeSentToAsyncQueue::class);
        $receivedStamps = $envelope->all(ReceivedStamp::class);

        return \count($failedToBeSentToAsyncQueueStamps) > 0 && \count($receivedStamps) > 0;
    }

    private function isAlreadySentToFailedSender(Envelope $envelope): bool
    {
        return $envelope->last(SentToFailureTransportStamp::class) !== null;
    }

    private function getOriginalReceiverName(Envelope $resultEnvelope): string
    {
        $senders = $this->sendersLocator->getSenders($resultEnvelope);
        $aliases = [];

        foreach ($senders as $alias => $sender) {
            $aliases[] = $alias;
        }

        Assert::same(\count($aliases), 1);

        return $aliases[0];
    }
}