}
    }

    /**
     * Applies delay based on the configured interval rules.
     * This method calculates the appropriate delay for the current time
     * and applies it by sleeping the current thread.
     */
    public void delayByRules() {
        final long delay = getDelay();
        if (delay > 0) {
            ThreadUtil.sleep(delay);
        }
    }

    /**

     * @param {string} options.prefix - Prefix to use for data attributes.
     * @param {number} options.startDelay - Delay before animation, in ms.
     * @param {number} options.typeDelay - Delay between each typed character, in ms.
     * @param {number} options.lineDelay - Delay between each line, in ms.
     * @param {number} options.progressLength - Number of characters displayed as progress bar.

     * @return the delay time in milliseconds after processing
     */
    public long getDelayMillisAfterProcessing() {
        return delayMillisAfterProcessing;
    }

    /**
     * Sets the delay time in milliseconds after processing a URL.
     *
     * @param delayMillisAfterProcessing the delay time in milliseconds after processing
     */
    public void setDelayMillisAfterProcessing(final long delayMillisAfterProcessing) {

  @Override
  ListenableScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);

  /**
   * Duration-based overload of {@link #schedule(Runnable, long, TimeUnit)}.
   *
   * @since 29.0
   */
  @J2ktIncompatible
  default ListenableScheduledFuture<?> schedule(Runnable command, Duration delay) {
    return schedule(command, toNanosSaturated(delay), TimeUnit.NANOSECONDS);
  }

  /**

 *
 * <p>
 * Subclasses are responsible for implementing the abstract methods to define the actual delay
 * mechanism for each of these stages.
 * </p>
 *
 * <p>
 * The class also provides a mechanism to ignore exceptions that may occur during the delay process.
 * If {@link #ignoreException} is set to true, any exceptions thrown during the delay will be caught
 * and ignored. Otherwise, they will be re-thrown as {@link CrawlerSystemException}.

                    logger.debug("delay={}", delay);
                }
                Thread.sleep(delay);
            } while (delay > 2);

            synchronized (t) {
                t.notifyAll();
            }
            //System.out.println("numComplete=" + t.numComplete + ",numThreads=" + t.numThreads);
        }

        for (ti = 0; ti < t.numThreads; ti++) {

    /** Delay in milliseconds when no URL is in the queue */
    protected long delayMillisAtNoUrlInQueue = 500L;

    /** Delay in milliseconds before processing a URL */
    protected long delayMillisBeforeProcessing = 0L;

    /** Delay in milliseconds for waiting for new URLs */
    protected long delayMillisForWaitingNewUrl = 1000L;

    /**
     * Default constructor with default delay values.
     */

        this.delay = delay;
        this.unit = checkNotNull(unit);
      }

      /**
       * @param delay the time from now to delay execution
       * @since 33.4.0 (but since 31.1 in the JRE flavor)
       */
      @IgnoreJRERequirement // Users will use this only if they're already using Duration
      public Schedule(Duration delay) {
        this(toNanosSaturated(delay), NANOSECONDS);
      }

  }

  @Override
  public final ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
    return delegate.schedule(wrapTask(command), delay, unit);
  }

  @Override
  public final <V extends @Nullable Object> ScheduledFuture<V> schedule(
      Callable<V> task, long delay, TimeUnit unit) {
    return delegate.schedule(wrapTask(task), delay, unit);
  }

  @Override
  public final ScheduledFuture<?> scheduleAtFixedRate(

    int NO_URL_IN_QUEUE = 4;

    /** Constant indicating that the crawler is waiting for new URLs. */
    int WAIT_NEW_URL = 8;

    /**
     * Introduces a delay based on the specified type.
     *
     * @param type the type of delay to be introduced
     */
    void delay(int type);