import { StompHeaders } from '@stomp/stompjs';

/**
 * Options for [RxStomp#watch]{@link RxStomp#watch}.
 *
 * These parameters control how a subscription is created, re-created on reconnects,
 * and how headers are supplied both during subscribe and unsubscribe.
 *
 * Part of `@stomp/rx-stomp`
 */
export interface IWatchParams {
  /**
   * The subscription target (destination). This is broker-specific and typically
   * looks like a queue or a topic, e.g. `/queue/orders` or `/topic/updates`.
   */
  readonly destination?: string;

  /**
   * Headers to send with the SUBSCRIBE frame. Defaults to `{}`.
   *
   * If header values may change across reconnects, supply a function that will be
   * invoked before each (re)subscription so it can return the latest headers.
   *
   * Example:
   * ```typescript
   * const subHeadersCallback = () => ({ Authorization: `Bearer ${getToken()}` });
   * const sub = rxStomp.watch({ destination: queueName, subHeaders: subHeadersCallback })
   *   .subscribe(message => { /* handle message *\/ });
   * // The function runs before every subscription and resubscription.
   * ```
   */
  readonly subHeaders?: StompHeaders | (() => StompHeaders);

  /**
   * Headers to send with the UNSUBSCRIBE frame. Defaults to `{}`.
   *
   * When headers are not known up-front, pass a function that will be invoked
   * right before unsubscribing to obtain the current headers.
   *
   * Example:
   * ```typescript
   * const unsubHeadersCallback = () => ({ reason: 'user-navigation' });
   * const sub = rxStomp.watch({ destination: queueName, unsubHeaders: unsubHeadersCallback })
   *   .subscribe(message => { /* handle message *\/ });
   * // Later:
   * sub.unsubscribe(); // The callback will be invoked to fetch headers.
   * ```
   */
  readonly unsubHeaders?: StompHeaders | (() => StompHeaders);

  /**
   * By default, the destination will be re-subscribed automatically after each
   * successful reconnection. Set to `true` to subscribe only once and suppress
   * automatic resubscriptions.
   *
   * This is useful for one-off streams or when you prefer to control the lifetime
   * explicitly across reconnects.
   */
  readonly subscribeOnlyOnce?: boolean;
}