docs: public void loadAndQueueTokenBatch(@Observes @Dequeue MessageHolderWithVariants msg) throws IllegalStateException {
          final UnifiedPushMessage message = msg.getUnifiedPushMessage();
          final VariantType variantType = msg.getVariantType();
          final Collection<Variant> variants = msg.getVariants();
          final String lastTokenFromPreviousBatch = msg.getLastTokenFromPreviousBatch();
          final SenderConfiguration configuration = senderConfiguration.select(new SenderTypeLiteral(variantType)).get();
          final FlatPushMessageInformation pushMessageInformation = msg.getPushMessageInformation();
          int serialId = msg.getLastSerialId();
  
          logger.debug("Received message from queue: {}", message.getMessage().getAlert());
  
          final Criteria criteria = message.getCriteria();
          final List<String> categories = criteria.getCategories();
          final List<String> aliases = criteria.getAliases();
          final List<String> deviceTypes = criteria.getDeviceTypes();
  
          logger.info(String.format("Preparing message delivery and loading tokens for the %s 3rd-party Push Network (for %d variants)", variantType, variants.size()));
  
          for (Variant variant : variants) {
  
              try {
  
                  ResultsStream<String> tokenStream;
                  final Set<String> topics = new TreeSet<>();
                  final boolean isAndroid = variantType == VariantType.ANDROID;
  
                  // the entire batch size
                  int batchesToLoad= configuration.batchesToLoad();
  
                  // Some checks for FCM, because of topics feature from FCM (and GCM-3 in the past)
                  boolean fcmTopicRequest = (isAndroid && TokenLoaderUtils.isFCMTopicRequest(criteria));
                  if (fcmTopicRequest) {
                      // If we are able to do push for FCM topics...
                      logger.trace("Processing Firebase Topic request");
  
                      // 1)
                      // find all topics, BUT only on the very first round of batches
                      // otherwise after 10 (or what ever the max. is) another request would be sent to that topic
                      if (serialId == 0) {
                          topics.addAll(TokenLoaderUtils.extractFCMTopics(criteria, variant.getVariantID()));
  
                          // topics are handled as a first extra batch,
                          // therefore we have to adjust the number by adding this extra batch
                          batchesToLoad += 1;
                      }
  
                      // 2) always load the legacy tokens, for all number of batch iterations
                      tokenStream = clientInstallationService.findAllOldGoogleCloudMessagingDeviceTokenForVariantIDByCriteria(variant.getVariantID(), categories, aliases, deviceTypes, configuration.tokensToLoad(), lastTokenFromPreviousBatch)
                              .fetchSize(configuration.batchSize())
                              .executeQuery();
  
                      if (tokenStream.next()) {
                          logger.warn("The application still has old tokens that are not compliant to the InstanceID format");
                      }
  
                  } else {
                      logger.trace("Processing Firebase token request");
                      tokenStream = clientInstallationService.findAllDeviceTokenForVariantIDByCriteria(variant.getVariantID(), categories, aliases, deviceTypes, configuration.tokensToLoad(), lastTokenFromPreviousBatch)
                              .fetchSize(configuration.batchSize())
                              .executeQuery();
                  }
  
                  String lastTokenInBatch = null;
                  int tokensLoaded = 0;
                  for (int batchNumber = 0; batchNumber < batchesToLoad; batchNumber++) {
  
                      // increasing the serial ID,
                      // to make sure it's properly read from all block
                      ++serialId;
  
                      final Set<String> tokens = new TreeSet<>();
  
                      // On Android, the first batch is for GCM3 topics
                      // legacy tokens are submitted in the batch #2 and later
                      if (isAndroid && batchNumber == 0 && ! topics.isEmpty()) {
                          tokens.addAll(topics);
                      } else {
                          for (int i = 0; i < configuration.batchSize() && tokenStream.next(); i++) {
                              lastTokenInBatch = tokenStream.get();
                              tokens.add(lastTokenInBatch);
                              tokensLoaded += 1;
                          }
                      }
  
                      if (tokens.size() > 0) {
                          if (tryToDispatchTokens(new MessageHolderWithTokens(msg.getPushMessageInformation(), message, variant, tokens, serialId))) {
                              logger.info(String.format("Loaded batch #%s, containing %d tokens, for %s variant (%s)", serialId, tokens.size() ,variant.getType().getTypeName(), variant.getVariantID()));
                          } else {
                              logger.debug(String.format("Failing token loading transaction for batch token #%s for %s variant (%s), since queue is full, will retry...", serialId, variant.getType().getTypeName(), variant.getVariantID()));
                              context.setRollbackOnly();
                              return;
                          }
                          logger.info("Loaded batch #{}, containing {} tokens, for {} variant ({})", serialId, tokens.size() ,variant.getType().getTypeName(), variant.getVariantID());
  
                          // using combined key of variant and PMI (AGPUSH-1585):
                          //batchLoaded.fire(new BatchLoadedEvent(variant.getVariantID()+":"+msg.getPushMessageInformation().getId()));
                      } else {
                          logger.debug("Ending batch processing: No more tokens for batch #{} available", serialId);
                          break;
                      }
                  }
                  // should we trigger next transaction batch ?
                  if (tokensLoaded >= configuration.tokensToLoad()) {
                      logger.debug(String.format("Ending token loading transaction for %s variant (%s)", variant.getType().getTypeName(), variant.getVariantID()));
                      nextBatchEvent.fire(new MessageHolderWithVariants(msg.getPushMessageInformation(), message, msg.getVariantType(), variants, serialId, lastTokenInBatch));
                  } else {
                      logger.debug("All batches for {} variant were loaded ({})", variant.getType().getTypeName(), variant.getVariantID());
  
                      // using combined key of variant and PMI (AGPUSH-1585):
                      //allBatchesLoaded.fire(new AllBatchesLoadedEvent(variant.getVariantID()+":"+msg.getPushMessageInformation().getId()));
  
                      if (tokensLoaded == 0 && lastTokenFromPreviousBatch == null) {
                          // no tokens were loaded at all!
                          if (fcmTopicRequest) {
                              logger.debug("No legacy(non-InstanceID) tokens found. Just pure GCM topic requests");
                          } else {
                              logger.warn("Check your push query: Not a single token was loaded from the DB!");
                          }
                      }
                  }
              } catch (ResultStreamException e) {
                  logger.error("Failed to load batch of tokens", e);
              }
          }
      }