/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

const lazy = {};

ChromeUtils.defineESModuleGetters(lazy, {
  ContextDescriptorType:
    "chrome://remote/content/shared/messagehandler/MessageHandler.sys.mjs",
  error: "chrome://remote/content/shared/messagehandler/Errors.sys.mjs",
  isBrowsingContextCompatible:
    "chrome://remote/content/shared/BrowsingContextUtils.sys.mjs",
  isInitialDocument:
    "chrome://remote/content/shared/BrowsingContextUtils.sys.mjs",
  isPrivilegedContext:
    "chrome://remote/content/shared/BrowsingContextUtils.sys.mjs",
  Log: "chrome://remote/content/shared/Log.sys.mjs",
  MessageHandlerFrameActor:
    "chrome://remote/content/shared/messagehandler/transports/js-window-actors/MessageHandlerFrameActor.sys.mjs",
  RemoteAgent: "chrome://remote/content/components/RemoteAgent.sys.mjs",
  TabManager: "chrome://remote/content/shared/TabManager.sys.mjs",
  waitForCurrentWindowGlobal:
    "chrome://remote/content/shared/BrowsingContextUtils.sys.mjs",
});

ChromeUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());

ChromeUtils.defineLazyGetter(lazy, "prefRetryOnAbort", () => {
  return Services.prefs.getBoolPref("remote.retry-on-abort", false);
});

const MAX_RETRY_ATTEMPTS = 10;

/**
 * RootTransport is intended to be used from a ROOT MessageHandler to communicate
 * with WINDOW_GLOBAL MessageHandlers via the MessageHandlerFrame JSWindow
 * actors.
 */
export class RootTransport {
  /**
   * @param {MessageHandler} messageHandler
   *     The MessageHandler instance which owns this RootTransport instance.
   */
  constructor(messageHandler) {
    this._messageHandler = messageHandler;

    // RootTransport will rely on the MessageHandlerFrame JSWindow actors.
    // Make sure they are registered when instantiating a RootTransport.
    lazy.MessageHandlerFrameActor.register();
  }

  /**
   * Forward the provided command to WINDOW_GLOBAL MessageHandlers via the
   * MessageHandlerFrame actors.
   *
   * @param {Command} command
   *     The command to forward. See type definition in MessageHandler.js
   * @returns {Promise}
   *     Returns a promise that resolves with the result of the command after
   *     being processed by WINDOW_GLOBAL MessageHandlers.
   */
  forwardCommand(command) {
    if (command.destination.id && command.destination.contextDescriptor) {
      throw new Error(
        "Invalid command destination with both 'id' and 'contextDescriptor' properties"
      );
    }

    // With an id given forward the command to only this specific destination.
    if (command.destination.id) {
      const browsingContext = BrowsingContext.get(command.destination.id);
      if (!browsingContext) {
        throw new lazy.error.DiscardedBrowsingContextError(
          `Unable to find a BrowsingContext for id "${command.destination.id}"`
        );
      }
      return this._sendCommandToBrowsingContext(command, browsingContext);
    }

    // ... otherwise broadcast to destinations matching the contextDescriptor.
    if (command.destination.contextDescriptor) {
      return this._broadcastCommand(command);
    }

    throw new Error(
      "Unrecognized command destination, missing 'id' or 'contextDescriptor' properties"
    );
  }

  _broadcastCommand(command) {
    const { contextDescriptor } = command.destination;
    const browsingContexts =
      this._getBrowsingContextsForDescriptor(contextDescriptor);

    return Promise.all(
      browsingContexts.map(async browsingContext => {
        try {
          return await this._sendCommandToBrowsingContext(
            command,
            browsingContext
          );
        } catch (e) {
          console.error(
            `Failed to broadcast a command to browsingContext ${browsingContext.id}`,
            e
          );
          return null;
        }
      })
    );
  }

  async _sendCommandToBrowsingContext(command, browsingContext) {
    const name = `${command.moduleName}.${command.commandName}`;

    let retryOnAbort = true;
    if (command.retryOnAbort !== undefined) {
      // The caller should always be able to force a value.
      retryOnAbort = command.retryOnAbort;
    } else if (!lazy.prefRetryOnAbort) {
      // If we don't retry by default do it at least for the initial document.
      retryOnAbort = lazy.isInitialDocument(browsingContext);
    }

    // If a top-level content browsing context was replaced and
    // retrying is allowed, retrieve the new one for the current browser.
    if (
      browsingContext &&
      browsingContext.isContent &&
      browsingContext.isReplaced &&
      browsingContext.top === browsingContext &&
      retryOnAbort
    ) {
      browsingContext = BrowsingContext.getCurrentTopByBrowserId(
        browsingContext.browserId
      );
    }

    if (!browsingContext || browsingContext.isDiscarded) {
      throw new lazy.error.DiscardedBrowsingContextError(
        `BrowsingContext does no longer exist`
      );
    }

    // For content browsing contexts keep a reference to the
    // webProgress, which will persist, and always use it to
    // retrieve the currently valid browsing context.
    const webProgress = browsingContext.webProgress;

    let attempts = 0;
    while (true) {
      try {
        if (browsingContext.isContent) {
          browsingContext = webProgress.browsingContext;

          // The browsing context is (re-)resolved from the web progress on
          // every attempt and may have navigated to a privileged page since
          // the command was initially dispatched. Without system access no
          // command may run in a privileged context, so refuse to forward it
          // there instead of executing with elevated privileges. Commands that
          // are always allowed regardless of privilege (e.g. the base URL
          // lookup for a navigation) opt out via `skipPrivilegeCheck`.
          if (
            !command.skipPrivilegeCheck &&
            !lazy.RemoteAgent.allowSystemAccess &&
            lazy.isPrivilegedContext(browsingContext)
          ) {
            throw new lazy.error.MessageHandlerError(
              `Cannot forward command ${name} to a privileged browsing context`
            );
          }
        }

        if (!browsingContext.currentWindowGlobal) {
          await lazy.waitForCurrentWindowGlobal(browsingContext);
        }

        return await browsingContext.currentWindowGlobal
          .getActor("MessageHandlerFrame")
          .sendCommand(command, this._messageHandler.sessionId);
      } catch (e) {
        // Re-throw the error in case it is not an AbortError.
        if (e.name != "AbortError") {
          throw e;
        }

        // Only retry if the command supports retryOnAbort and when the
        // JSWindowActor pair gets destroyed.
        if (!retryOnAbort) {
          throw new lazy.error.DiscardedBrowsingContextError(e.message);
        }

        if (++attempts > MAX_RETRY_ATTEMPTS) {
          lazy.logger.trace(
            `RootTransport reached the limit of retry attempts (${MAX_RETRY_ATTEMPTS})` +
              ` for command ${name} and browsing context ${browsingContext.id}.`
          );
          throw new lazy.error.DiscardedBrowsingContextError(e.message);
        }

        lazy.logger.trace(
          `RootTransport retrying command ${name} for ` +
            `browsing context ${browsingContext.id}, attempt: ${attempts}.`
        );
        await new Promise(resolve => Services.tm.dispatchToMainThread(resolve));
      }
    }
  }

  toString() {
    return `[object ${this.constructor.name} ${this._messageHandler.name}]`;
  }

  _getBrowsingContextsForDescriptor(contextDescriptor) {
    const { id, type } = contextDescriptor;

    if (type === lazy.ContextDescriptorType.All) {
      return this._getBrowsingContexts();
    }

    if (type === lazy.ContextDescriptorType.TopBrowsingContext) {
      return this._getBrowsingContexts({ browserId: id });
    }

    if (type === lazy.ContextDescriptorType.UserContext) {
      return this._getBrowsingContexts({ userContext: id });
    }

    // TODO: Handle other types of context descriptors.
    throw new Error(
      `Unsupported contextDescriptor type for broadcasting: ${type}`
    );
  }

  /**
   * Get all browsing contexts, optionally matching the provided options.
   *
   * @param {object} options
   * @param {string=} options.browserId
   *    The id of the browser to filter the browsing contexts by (optional).
   * @param {string=} options.userContext
   *    The id of the user context to filter the browsing contexts by (optional).
   * @returns {Array<BrowsingContext>}
   *    The browsing contexts matching the provided options or all browsing contexts
   *    if no options are provided.
   */
  _getBrowsingContexts(options = {}) {
    // extract browserId from options
    const { browserId, userContext } = options;
    let browsingContexts = [];

    // Fetch all tab related browsing contexts for top-level windows.
    for (const { browsingContext } of lazy.TabManager.getBrowsers()) {
      if (
        lazy.isBrowsingContextCompatible(browsingContext, {
          browserId,
          userContext,
        })
      ) {
        browsingContexts = browsingContexts.concat(
          browsingContext.getAllBrowsingContextsInSubtree()
        );
      }
    }

    return browsingContexts;
  }
}
