/* 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/. */

// This file is loaded into the browser window scope.
/* eslint-env mozilla/browser-window */

XPCOMUtils.defineLazyPreferenceGetter(
  this,
  "NEWTAB_ENABLED",
  "browser.newtabpage.enabled",
  false
);

XPCOMUtils.defineLazyPreferenceGetter(
  this,
  "SHOW_OTHER_BOOKMARKS",
  "browser.toolbars.bookmarks.showOtherBookmarks",
  true,
  (aPref, aPrevVal, aNewVal) => {
    BookmarkingUI.maybeShowOtherBookmarksFolder().then(() => {
      document
        .getElementById("PlacesToolbar")
        ?._placesView?.updateNodesVisibility();
    }, console.error);
  }
);
ChromeUtils.defineESModuleGetters(this, {
  PanelMultiView: "resource:///modules/PanelMultiView.sys.mjs",
  RecentlyClosedTabsAndWindowsMenuUtils:
    "resource:///modules/sessionstore/RecentlyClosedTabsAndWindowsMenuUtils.sys.mjs",
});

var StarUI = {
  _itemGuids: null,
  _isNewBookmark: false,
  _isComposing: false,
  _autoCloseTimer: 0,
  // The autoclose timer is diasbled if the user interacts with the
  // popup, such as making a change through typing or clicking on
  // the popup.
  _autoCloseTimerEnabled: true,
  // The autoclose timeout length. 3500ms matches the timeout that Pocket uses
  // in browser/components/pocket/content/panels/js/saved.js.
  _autoCloseTimeout: 3500,
  _removeBookmarksOnPopupHidden: false,

  _element(aID) {
    return document.getElementById(aID);
  },

  // Edit-bookmark panel
  get panel() {
    delete this.panel;
    this._createPanelIfNeeded();
    var element = this._element("editBookmarkPanel");
    // initially the panel is hidden
    // to avoid impacting startup / new window performance
    element.hidden = false;
    element.addEventListener("keypress", this, { mozSystemGroup: true });
    element.addEventListener("mousedown", this);
    element.addEventListener("mouseout", this);
    element.addEventListener("mousemove", this);
    element.addEventListener("compositionstart", this);
    element.addEventListener("compositionend", this);
    element.addEventListener("input", this);
    element.addEventListener("popuphidden", this);
    element.addEventListener("popupshown", this);
    return (this.panel = element);
  },

  // nsIDOMEventListener
  handleEvent(aEvent) {
    switch (aEvent.type) {
      case "mousemove":
        clearTimeout(this._autoCloseTimer);
        // The autoclose timer is not disabled on generic mouseout
        // because the user may not have actually interacted with the popup.
        break;
      case "popuphidden": {
        clearTimeout(this._autoCloseTimer);
        if (aEvent.originalTarget == this.panel) {
          this._handlePopupHiddenEvent().catch(console.error);
        }
        break;
      }
      case "keypress":
        clearTimeout(this._autoCloseTimer);
        this._autoCloseTimerEnabled = false;

        if (aEvent.defaultPrevented) {
          // The event has already been consumed inside of the panel.
          break;
        }

        switch (aEvent.keyCode) {
          case KeyEvent.DOM_VK_ESCAPE:
            if (this._isNewBookmark) {
              this._removeBookmarksOnPopupHidden = true;
            }
            this.panel.hidePopup();
            break;
          case KeyEvent.DOM_VK_RETURN:
            if (
              aEvent.target.classList.contains("expander-up") ||
              aEvent.target.classList.contains("expander-down") ||
              aEvent.target.id == "editBMPanel_newFolderButton" ||
              aEvent.target.id == "editBookmarkPanelRemoveButton"
            ) {
              // XXX Why is this necessary? The defaultPrevented check should
              //    be enough.
              break;
            }
            this.panel.hidePopup();
            break;
          // This case is for catching character-generating keypresses
          case 0:
            let accessKey = document.getElementById("key_close");
            if (eventMatchesKey(aEvent, accessKey)) {
              this.panel.hidePopup();
            }
            break;
        }
        break;
      case "compositionend":
        // After composition is committed, "mouseout" or something can set
        // auto close timer.
        this._isComposing = false;
        break;
      case "compositionstart":
        if (aEvent.defaultPrevented) {
          // If the composition was canceled, nothing to do here.
          break;
        }
        this._isComposing = true;
      // Explicit fall-through, during composition, panel shouldn't be hidden automatically.
      case "input":
      // Might have edited some text without keyboard events nor composition
      // events. Fall-through to cancel auto close in such case.
      case "mousedown":
        clearTimeout(this._autoCloseTimer);
        this._autoCloseTimerEnabled = false;
        break;
      case "mouseout":
        if (!this._autoCloseTimerEnabled) {
          // Don't autoclose the popup if the user has made a selection
          // or keypress and then subsequently mouseout.
          break;
        }
      // Explicit fall-through
      case "popupshown":
        // Don't handle events for descendent elements.
        if (aEvent.target != aEvent.currentTarget) {
          break;
        }
        // auto-close if new and not interacted with
        if (this._isNewBookmark && !this._isComposing) {
          let delay = this._autoCloseTimeout;
          if (this._closePanelQuickForTesting) {
            delay /= 10;
          }
          clearTimeout(this._autoCloseTimer);
          this._autoCloseTimer = setTimeout(() => {
            if (!this.panel.matches(":hover")) {
              this.panel.hidePopup(true);
            }
          }, delay);
          this._autoCloseTimerEnabled = true;
        }
        break;
    }
  },

  /**
   * Handle popup hidden event.
   */
  async _handlePopupHiddenEvent() {
    const { bookmarkState, didChangeFolder, selectedFolderGuid } =
      gEditItemOverlay;
    gEditItemOverlay.uninitPanel(true);

    // Capture _removeBookmarksOnPopupHidden and _itemGuids values. Reset them
    // before we handle the next popup.
    const removeBookmarksOnPopupHidden = this._removeBookmarksOnPopupHidden;
    this._removeBookmarksOnPopupHidden = false;
    const guidsForRemoval = this._itemGuids;
    this._itemGuids = null;

    if (removeBookmarksOnPopupHidden && guidsForRemoval) {
      if (!this._isNewBookmark) {
        // Remove all bookmarks for the bookmark's url, this also removes
        // the tags for the url.
        await PlacesTransactions.Remove(guidsForRemoval).transact();
      } else {
        BookmarkingUI.star.removeAttribute("starred");
      }
      return;
    }

    await this._storeRecentlyUsedFolder(selectedFolderGuid, didChangeFolder);
    await bookmarkState.save();
    if (this._isNewBookmark) {
      this.showConfirmation();
    }
  },

  async showEditBookmarkPopup(aNode, aIsNewBookmark, aUrl) {
    // Slow double-clicks (not true double-clicks) shouldn't
    // cause the panel to flicker.
    if (this.panel.state != "closed") {
      return;
    }

    this._isNewBookmark = aIsNewBookmark;
    this._itemGuids = null;

    let titleL10nID = this._isNewBookmark
      ? "bookmarks-add-bookmark"
      : "bookmarks-edit-bookmark";
    document.l10n.setAttributes(
      this._element("editBookmarkPanelTitle"),
      titleL10nID
    );

    this._element("editBookmarkPanel_showForNewBookmarks").checked =
      this.showForNewBookmarks;

    this._itemGuids = [];
    await PlacesUtils.bookmarks.fetch({ url: aUrl }, bookmark =>
      this._itemGuids.push(bookmark.guid)
    );

    let removeButton = this._element("editBookmarkPanelRemoveButton");
    if (this._isNewBookmark) {
      document.l10n.setAttributes(removeButton, "bookmark-panel-cancel");
    } else {
      // The label of the remove button differs if the URI is bookmarked
      // multiple times.
      document.l10n.setAttributes(removeButton, "bookmark-panel-remove", {
        count: this._itemGuids.length,
      });
    }

    this._setIconAndPreviewImage();

    let onPanelReady = fn => {
      let target = this.panel;
      if (target.parentNode) {
        // By targeting the panel's parent and using a capturing listener, we
        // can have our listener called before others waiting for the panel to
        // be shown (which probably expect the panel to be fully initialized)
        target = target.parentNode;
      }
      target.addEventListener(
        "popupshown",
        function (event) {
          fn();
        },
        { capture: true, once: true }
      );
    };
    await gEditItemOverlay.initPanel({
      node: aNode,
      onPanelReady,
      hiddenRows: ["location", "keyword"],
      focusedElement: "preferred",
      isNewBookmark: this._isNewBookmark,
    });

    this.panel.openPopup(BookmarkingUI.anchor, "bottomright topright");
  },

  _createPanelIfNeeded() {
    // Lazy load the editBookmarkPanel the first time we need to display it.
    if (!this._element("editBookmarkPanel")) {
      MozXULElement.insertFTLIfNeeded("browser/editBookmarkOverlay.ftl");
      let template = this._element("editBookmarkPanelTemplate");
      let clone = template.content.cloneNode(true);
      template.replaceWith(clone);
    }
  },

  _setIconAndPreviewImage() {
    let faviconImage = this._element("editBookmarkPanelFavicon");
    faviconImage.removeAttribute("iconloadingprincipal");
    faviconImage.removeAttribute("src");

    let tab = gBrowser.selectedTab;
    if (tab.hasAttribute("image") && !tab.hasAttribute("busy")) {
      faviconImage.setAttribute(
        "iconloadingprincipal",
        tab.getAttribute("iconloadingprincipal")
      );
      faviconImage.setAttribute("src", tab.getAttribute("image"));
    }

    let canvas = PageThumbs.createCanvas(window);
    PageThumbs.captureToCanvas(gBrowser.selectedBrowser, canvas).catch(e =>
      console.error(e)
    );
    document.mozSetImageElement("editBookmarkPanelImageCanvas", canvas);
  },

  removeBookmarkButtonCommand: function SU_removeBookmarkButtonCommand() {
    this._removeBookmarksOnPopupHidden = true;
    this.panel.hidePopup();
  },

  async _storeRecentlyUsedFolder(selectedFolderGuid, didChangeFolder) {
    if (!selectedFolderGuid) {
      return;
    }

    // If we're changing where a bookmark gets saved, persist that location.
    if (didChangeFolder) {
      Services.prefs.setCharPref(
        "browser.bookmarks.defaultLocation",
        selectedFolderGuid
      );
    }

    // Don't store folders that are always displayed in "Recent Folders".
    if (PlacesUtils.bookmarks.userContentRoots.includes(selectedFolderGuid)) {
      return;
    }

    // List of recently used folders:
    let lastUsedFolderGuids = await PlacesUtils.metadata.get(
      PlacesUIUtils.LAST_USED_FOLDERS_META_KEY,
      []
    );

    let index = lastUsedFolderGuids.indexOf(selectedFolderGuid);
    if (index > 1) {
      // The guid is in the array but not the most recent.
      lastUsedFolderGuids.splice(index, 1);
      lastUsedFolderGuids.unshift(selectedFolderGuid);
    } else if (index == -1) {
      lastUsedFolderGuids.unshift(selectedFolderGuid);
    }
    while (lastUsedFolderGuids.length > PlacesUIUtils.maxRecentFolders) {
      lastUsedFolderGuids.pop();
    }

    await PlacesUtils.metadata.set(
      PlacesUIUtils.LAST_USED_FOLDERS_META_KEY,
      lastUsedFolderGuids
    );
  },

  onShowForNewBookmarksCheckboxCommand() {
    Services.prefs.setBoolPref(
      "browser.bookmarks.editDialog.showForNewBookmarks",
      this._element("editBookmarkPanel_showForNewBookmarks").checked
    );
  },

  showConfirmation() {
    // Show the "Saved to bookmarks" hint for the first three times
    const HINT_COUNT_PREF =
      "browser.bookmarks.editDialog.confirmationHintShowCount";
    const HINT_COUNT = Services.prefs.getIntPref(HINT_COUNT_PREF, 0);

    if (HINT_COUNT >= 3) {
      return;
    }
    Services.prefs.setIntPref(HINT_COUNT_PREF, HINT_COUNT + 1);

    let anchor;
    if (window.toolbar.visible) {
      for (let id of ["library-button", "bookmarks-menu-button"]) {
        let element = document.getElementById(id);
        if (
          element &&
          element.getAttribute("cui-areatype") != "panel" &&
          element.getAttribute("overflowedItem") != "true"
        ) {
          anchor = element;
          break;
        }
      }
    }
    if (!anchor) {
      anchor = document.getElementById("PanelUI-menu-button");
    }
    ConfirmationHint.show(anchor, "confirmation-hint-page-bookmarked");
  },
};

XPCOMUtils.defineLazyPreferenceGetter(
  StarUI,
  "showForNewBookmarks",
  "browser.bookmarks.editDialog.showForNewBookmarks"
);

var PlacesCommandHook = {
  /**
   * Adds a bookmark to the page loaded in the current browser.
   */
  async bookmarkPage() {
    let browser = gBrowser.selectedBrowser;
    let url = URL.fromURI(browser.currentURI);
    let info = await PlacesUtils.bookmarks.fetch({ url });
    let isNewBookmark = !info;
    let showEditUI = !isNewBookmark || StarUI.showForNewBookmarks;
    if (isNewBookmark) {
      // This is async because we have to validate the guid
      // coming from prefs.
      let parentGuid = await PlacesUIUtils.defaultParentGuid;
      info = { url, parentGuid };
      // Bug 1148838 - Make this code work for full page plugins.
      let charset = null;

      let isErrorPage = false;
      if (browser.documentURI) {
        isErrorPage = /^about:(neterror|certerror|blocked)/.test(
          browser.documentURI.spec
        );
      }

      try {
        if (isErrorPage) {
          let entry = await PlacesUtils.history.fetch(browser.currentURI);
          if (entry) {
            info.title = entry.title;
          }
        } else {
          info.title = browser.contentTitle;
        }
        info.title = info.title || url.href;
        charset = browser.characterSet;
      } catch (e) {
        console.error(e);
      }

      if (!StarUI.showForNewBookmarks) {
        info.guid = await PlacesTransactions.NewBookmark(info).transact();
      } else {
        info.guid = PlacesUtils.bookmarks.unsavedGuid;
        BookmarkingUI.star.setAttribute("starred", "true");
      }

      if (charset) {
        PlacesUIUtils.setCharsetForPage(url, charset, window).catch(
          console.error
        );
      }
    }

    // Revert the contents of the location bar
    gURLBar.handleRevert();

    // If it was not requested to open directly in "edit" mode, we are done.
    if (!showEditUI) {
      StarUI.showConfirmation();
      return;
    }

    let node = await PlacesUIUtils.promiseNodeLikeFromFetchInfo(info);

    await StarUI.showEditBookmarkPopup(node, isNewBookmark, url);
  },

  /**
   * Adds a bookmark to the page targeted by a link.
   * @param url (string)
   *        the address of the link target
   * @param title
   *        The link text
   */
  async bookmarkLink(url, title) {
    let bm = await PlacesUtils.bookmarks.fetch({ url });
    if (bm) {
      let node = await PlacesUIUtils.promiseNodeLikeFromFetchInfo(bm);
      await PlacesUIUtils.showBookmarkDialog(
        { action: "edit", node },
        window.top
      );
      return;
    }

    let parentGuid = await PlacesUIUtils.defaultParentGuid;
    let defaultInsertionPoint = new PlacesInsertionPoint({
      parentGuid,
    });
    await PlacesUIUtils.showBookmarkDialog(
      {
        action: "add",
        type: "bookmark",
        uri: Services.io.newURI(url),
        title,
        defaultInsertionPoint,
        hiddenRows: ["location", "keyword"],
      },
      window.top
    );
  },

  /**
   * List of nsIURI objects characterizing tabs given in param.
   * Duplicates are discarded.
   */
  getUniquePages(tabs) {
    let uniquePages = {};
    let URIs = [];

    tabs.forEach(tab => {
      let browser = tab.linkedBrowser;
      let uri = browser.currentURI;
      let title = browser.contentTitle || tab.label;
      let spec = uri.spec;
      if (!(spec in uniquePages)) {
        uniquePages[spec] = null;
        URIs.push({ uri, title });
      }
    });
    return URIs;
  },

  /**
   * List of nsIURI objects characterizing the tabs currently open in the
   * browser, modulo pinned tabs. The URIs will be in the order in which their
   * corresponding tabs appeared and duplicates are discarded.
   */
  get uniqueCurrentPages() {
    let visibleUnpinnedTabs = gBrowser.visibleTabs.filter(tab => !tab.pinned);
    return this.getUniquePages(visibleUnpinnedTabs);
  },

  /**
   * List of nsIURI objects characterizing the tabs currently
   * selected in the window. Duplicates are discarded.
   */
  get uniqueSelectedPages() {
    return this.getUniquePages(gBrowser.selectedTabs);
  },

  /**
   * Opens the Places Organizer.
   * @param {String} item The item to select in the organizer window,
   *                      options are (case sensitive):
   *                      BookmarksMenu, BookmarksToolbar, UnfiledBookmarks,
   *                      AllBookmarks, History, Downloads.
   */
  showPlacesOrganizer(item) {
    var organizer = Services.wm.getMostRecentWindow("Places:Organizer");
    // Due to bug 528706, getMostRecentWindow can return closed windows.
    if (!organizer || organizer.closed) {
      // No currently open places window, so open one with the specified mode.
      openDialog(
        "chrome://browser/content/places/places.xhtml",
        "",
        "chrome,toolbar=yes,dialog=no,resizable",
        item
      );
    } else {
      organizer.PlacesOrganizer.selectLeftPaneContainerByHierarchy(item);
      organizer.focus();
    }
  },

  searchBookmarks() {
    gURLBar.search(UrlbarTokenizer.RESTRICT.BOOKMARK, {
      searchModeEntry: "bookmarkmenu",
    });
  },

  searchHistory() {
    gURLBar.search(UrlbarTokenizer.RESTRICT.HISTORY, {
      searchModeEntry: "historymenu",
    });
  },
};

// View for the history menu.
class HistoryMenu extends PlacesMenu {
  constructor(aPopupShowingEvent) {
    super(aPopupShowingEvent, "place:sort=4&maxResults=15");
  }

  // Called by the base class (PlacesViewBase) so we can initialize some
  // element references before the several superclass constructors call our
  // methods which depend on these.
  _init() {
    super._init();
    let elements = {
      undoTabMenu: "historyUndoMenu",
      hiddenTabsMenu: "hiddenTabsMenu",
      undoWindowMenu: "historyUndoWindowMenu",
      syncTabsMenuitem: "sync-tabs-menuitem",
    };
    for (let [key, elemId] of Object.entries(elements)) {
      this[key] = document.getElementById(elemId);
    }
  }

  _getClosedTabCount() {
    try {
      return SessionStore.getClosedTabCountForWindow(window);
    } catch (ex) {
      // SessionStore doesn't track the hidden window, so just return zero then.
      return 0;
    }
  }

  toggleHiddenTabs() {
    const isShown =
      window.gBrowser && gBrowser.visibleTabs.length < gBrowser.tabs.length;
    this.hiddenTabsMenu.hidden = !isShown;
  }

  toggleRecentlyClosedTabs() {
    // enable/disable the Recently Closed Tabs sub menu
    // no restorable tabs, so disable menu
    if (this._getClosedTabCount() == 0) {
      this.undoTabMenu.setAttribute("disabled", true);
    } else {
      this.undoTabMenu.removeAttribute("disabled");
    }
  }

  /**
   * Populate when the history menu is opened
   */
  populateUndoSubmenu() {
    var undoPopup = this.undoTabMenu.menupopup;

    // remove existing menu items
    while (undoPopup.hasChildNodes()) {
      undoPopup.firstChild.remove();
    }

    // no restorable tabs, so make sure menu is disabled, and return
    if (this._getClosedTabCount() == 0) {
      this.undoTabMenu.setAttribute("disabled", true);
      return;
    }

    // enable menu
    this.undoTabMenu.removeAttribute("disabled");

    // populate menu
    let tabsFragment = RecentlyClosedTabsAndWindowsMenuUtils.getTabsFragment(
      window,
      "menuitem",
      /* aPrefixRestoreAll = */ false
    );
    undoPopup.appendChild(tabsFragment);
  }

  toggleRecentlyClosedWindows() {
    // enable/disable the Recently Closed Windows sub menu
    // no restorable windows, so disable menu
    if (SessionStore.getClosedWindowCount() == 0) {
      this.undoWindowMenu.setAttribute("disabled", true);
    } else {
      this.undoWindowMenu.removeAttribute("disabled");
    }
  }

  /**
   * Populate when the history menu is opened
   */
  populateUndoWindowSubmenu() {
    let undoPopup = this.undoWindowMenu.menupopup;

    // remove existing menu items
    while (undoPopup.hasChildNodes()) {
      undoPopup.firstChild.remove();
    }

    // no restorable windows, so make sure menu is disabled, and return
    if (SessionStore.getClosedWindowCount() == 0) {
      this.undoWindowMenu.setAttribute("disabled", true);
      return;
    }

    // enable menu
    this.undoWindowMenu.removeAttribute("disabled");

    // populate menu
    let windowsFragment =
      RecentlyClosedTabsAndWindowsMenuUtils.getWindowsFragment(
        window,
        "menuitem",
        /* aPrefixRestoreAll = */ false
      );
    undoPopup.appendChild(windowsFragment);
  }

  toggleTabsFromOtherComputers() {
    // Enable/disable the Tabs From Other Computers menu. Some of the menus handled
    // by HistoryMenu do not have this menuitem.
    if (!this.syncTabsMenuitem) {
      return;
    }

    if (!PlacesUIUtils.shouldShowTabsFromOtherComputersMenuitem()) {
      this.syncTabsMenuitem.hidden = true;
      return;
    }

    this.syncTabsMenuitem.hidden = false;
  }

  _onPopupShowing(aEvent) {
    super._onPopupShowing(aEvent);

    // Don't handle events for submenus.
    if (aEvent.target != aEvent.currentTarget) {
      return;
    }

    this.toggleHiddenTabs();
    this.toggleRecentlyClosedTabs();
    this.toggleRecentlyClosedWindows();
    this.toggleTabsFromOtherComputers();
  }

  _onCommand(aEvent) {
    aEvent = getRootEvent(aEvent);
    let placesNode = aEvent.target._placesNode;
    if (placesNode) {
      if (!PrivateBrowsingUtils.isWindowPrivate(window)) {
        PlacesUIUtils.markPageAsTyped(placesNode.uri);
      }
      openUILink(placesNode.uri, aEvent, {
        ignoreAlt: true,
        triggeringPrincipal:
          Services.scriptSecurityManager.getSystemPrincipal(),
      });
    }
  }
}

/**
 * Functions for handling events in the Bookmarks Toolbar and menu.
 */
var BookmarksEventHandler = {
  /**
   * Handler for click event for an item in the bookmarks toolbar or menu.
   * Menus and submenus from the folder buttons bubble up to this handler.
   * Left-click is handled in the onCommand function.
   * When items are middle-clicked (or clicked with modifier), open in tabs.
   * If the click came through a menu, close the menu.
   * @param aEvent
   *        DOMEvent for the click
   * @param aView
   *        The places view which aEvent should be associated with.
   */

  onMouseUp(aEvent) {
    // Handles middle-click or left-click with modifier if not browser.bookmarks.openInTabClosesMenu.
    if (aEvent.button == 2 || PlacesUIUtils.openInTabClosesMenu) {
      return;
    }
    let target = aEvent.originalTarget;
    if (target.tagName != "menuitem") {
      return;
    }
    let modifKey =
      AppConstants.platform === "macosx" ? aEvent.metaKey : aEvent.ctrlKey;
    if (modifKey || aEvent.button == 1) {
      target.setAttribute("closemenu", "none");
      var menupopup = target.parentNode;
      menupopup.addEventListener(
        "popuphidden",
        () => {
          target.removeAttribute("closemenu");
        },
        { once: true }
      );
    } else {
      // Handles edge case where same menuitem was opened previously
      // while menu was kept open, but now menu should close.
      target.removeAttribute("closemenu");
    }
  },

  onClick: function BEH_onClick(aEvent, aView) {
    // Only handle middle-click or left-click with modifiers.
    let modifKey;
    if (AppConstants.platform == "macosx") {
      modifKey = aEvent.metaKey || aEvent.shiftKey;
    } else {
      modifKey = aEvent.ctrlKey || aEvent.shiftKey;
    }

    if (aEvent.button == 2 || (aEvent.button == 0 && !modifKey)) {
      return;
    }

    var target = aEvent.originalTarget;
    // If this event bubbled up from a menu or menuitem,
    // close the menus if browser.bookmarks.openInTabClosesMenu.
    var tag = target.tagName;
    if (
      PlacesUIUtils.openInTabClosesMenu &&
      (tag == "menuitem" || tag == "menu")
    ) {
      closeMenus(aEvent.target);
    }

    if (target._placesNode && PlacesUtils.nodeIsContainer(target._placesNode)) {
      // Don't open the root folder in tabs when the empty area on the toolbar
      // is middle-clicked or when a non-bookmark item (except for Open in Tabs)
      // in a bookmarks menupopup is middle-clicked.
      if (target.localName == "menu" || target.localName == "toolbarbutton") {
        PlacesUIUtils.openMultipleLinksInTabs(
          target._placesNode,
          aEvent,
          aView
        );
      }
    } else if (aEvent.button == 1 && !(tag == "menuitem" || tag == "menu")) {
      // Call onCommand in the cases where it's not called automatically:
      // Middle-clicks outside of menus.
      this.onCommand(aEvent);
    }
  },

  /**
   * Handler for command event for an item in the bookmarks toolbar.
   * Menus and submenus from the folder buttons bubble up to this handler.
   * Opens the item.
   * @param aEvent
   *        DOMEvent for the command
   */
  onCommand: function BEH_onCommand(aEvent) {
    var target = aEvent.originalTarget;
    if (target._placesNode) {
      PlacesUIUtils.openNodeWithEvent(target._placesNode, aEvent);
      // Only record interactions through the Bookmarks Toolbar
      if (target.closest("#PersonalToolbar")) {
        Services.telemetry.scalarAdd(
          "browser.engagement.bookmarks_toolbar_bookmark_opened",
          1
        );
      }
    }
  },

  fillInBHTooltip: function BEH_fillInBHTooltip(aTooltip, aEvent) {
    var node;
    var cropped = false;
    var targetURI;

    if (aTooltip.triggerNode.localName == "treechildren") {
      var tree = aTooltip.triggerNode.parentNode;
      var cell = tree.getCellAt(aEvent.clientX, aEvent.clientY);
      if (cell.row == -1) {
        return false;
      }
      node = tree.view.nodeForTreeIndex(cell.row);
      cropped = tree.isCellCropped(cell.row, cell.col);
    } else {
      // Check whether the tooltipNode is a Places node.
      // In such a case use it, otherwise check for targetURI attribute.
      var tooltipNode = aTooltip.triggerNode;
      if (tooltipNode._placesNode) {
        node = tooltipNode._placesNode;
      } else {
        // This is a static non-Places node.
        targetURI = tooltipNode.getAttribute("targetURI");
      }
    }

    if (!node && !targetURI) {
      return false;
    }

    // Show node.label as tooltip's title for non-Places nodes.
    var title = node ? node.title : tooltipNode.label;

    // Show URL only for Places URI-nodes or nodes with a targetURI attribute.
    var url;
    if (targetURI || PlacesUtils.nodeIsURI(node)) {
      url = targetURI || node.uri;
    }

    // Show tooltip for containers only if their title is cropped.
    if (!cropped && !url) {
      return false;
    }

    let tooltipTitle = aEvent.target.querySelector(".places-tooltip-title");
    tooltipTitle.hidden = !title || title == url;
    if (!tooltipTitle.hidden) {
      tooltipTitle.textContent = title;
    }

    let tooltipUrl = aEvent.target.querySelector(".places-tooltip-uri");
    tooltipUrl.hidden = !url;
    if (!tooltipUrl.hidden) {
      // Use `value` instead of `textContent` so cropping will apply
      tooltipUrl.value = url;
    }

    // Show tooltip.
    return true;
  },
};

// Handles special drag and drop functionality for Places menus that are not
// part of a Places view (e.g. the bookmarks menu in the menubar).
var PlacesMenuDNDHandler = {
  _springLoadDelayMs: 350,
  _closeDelayMs: 500,
  _loadTimer: null,
  _closeTimer: null,
  _closingTimerNode: null,

  /**
   * Called when the user enters the <menu> element during a drag.
   * @param   event
   *          The DragEnter event that spawned the opening.
   */
  onDragEnter: function PMDH_onDragEnter(event) {
    // Opening menus in a Places popup is handled by the view itself.
    if (!this._isStaticContainer(event.target)) {
      return;
    }

    // If we re-enter the same menu or anchor before the close timer runs out,
    // we should ensure that we do not close:
    if (this._closeTimer && this._closingTimerNode === event.currentTarget) {
      this._closeTimer.cancel();
      this._closingTimerNode = null;
      this._closeTimer = null;
    }

    PlacesControllerDragHelper.currentDropTarget = event.target;
    let popup = event.target.menupopup;
    if (
      this._loadTimer ||
      popup.state === "showing" ||
      popup.state === "open"
    ) {
      return;
    }

    this._loadTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
    this._loadTimer.initWithCallback(
      () => {
        this._loadTimer = null;
        popup.setAttribute("autoopened", "true");
        popup.openPopup();
      },
      this._springLoadDelayMs,
      Ci.nsITimer.TYPE_ONE_SHOT
    );
    event.preventDefault();
    event.stopPropagation();
  },

  /**
   * Handles dragleave on the <menu> element.
   */
  onDragLeave: function PMDH_onDragLeave(event) {
    // Handle menu-button separate targets.
    if (
      event.relatedTarget === event.currentTarget ||
      (event.relatedTarget &&
        event.relatedTarget.parentNode === event.currentTarget)
    ) {
      return;
    }

    // Closing menus in a Places popup is handled by the view itself.
    if (!this._isStaticContainer(event.target)) {
      return;
    }

    PlacesControllerDragHelper.currentDropTarget = null;
    let popup = event.target.menupopup;

    if (this._loadTimer) {
      this._loadTimer.cancel();
      this._loadTimer = null;
    }
    this._closeTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
    this._closingTimerNode = event.currentTarget;
    this._closeTimer.initWithCallback(
      function () {
        this._closeTimer = null;
        this._closingTimerNode = null;
        let node = PlacesControllerDragHelper.currentDropTarget;
        let inHierarchy = false;
        while (node && !inHierarchy) {
          inHierarchy = node == event.target;
          node = node.parentNode;
        }
        if (!inHierarchy && popup && popup.hasAttribute("autoopened")) {
          popup.removeAttribute("autoopened");
          popup.hidePopup();
        }
      },
      this._closeDelayMs,
      Ci.nsITimer.TYPE_ONE_SHOT
    );
  },

  /**
   * Determines if a XUL element represents a static container.
   * @returns true if the element is a container element (menu or
   *`         menu-toolbarbutton), false otherwise.
   */
  _isStaticContainer: function PMDH__isContainer(node) {
    let isMenu =
      node.localName == "menu" ||
      (node.localName == "toolbarbutton" &&
        node.getAttribute("type") == "menu");
    let isStatic =
      !("_placesNode" in node) &&
      node.menupopup &&
      node.menupopup.hasAttribute("placespopup") &&
      !node.parentNode.hasAttribute("placespopup");
    return isMenu && isStatic;
  },

  /**
   * Called when the user drags over the <menu> element.
   * @param   event
   *          The DragOver event.
   */
  onDragOver: function PMDH_onDragOver(event) {
    PlacesControllerDragHelper.currentDropTarget = event.target;
    let ip = new PlacesInsertionPoint({
      parentGuid: PlacesUtils.bookmarks.menuGuid,
    });
    if (ip && PlacesControllerDragHelper.canDrop(ip, event.dataTransfer)) {
      event.preventDefault();
    }

    event.stopPropagation();
  },

  /**
   * Called when the user drops on the <menu> element.
   * @param   event
   *          The Drop event.
   */
  onDrop: function PMDH_onDrop(event) {
    // Put the item at the end of bookmark menu.
    let ip = new PlacesInsertionPoint({
      parentGuid: PlacesUtils.bookmarks.menuGuid,
    });
    PlacesControllerDragHelper.onDrop(ip, event.dataTransfer);
    PlacesControllerDragHelper.currentDropTarget = null;
    event.stopPropagation();
  },
};

/**
 * This object handles the initialization and uninitialization of the bookmarks
 * toolbar. It also has helper functions for the managed bookmarks button.
 */
var PlacesToolbarHelper = {
  get _viewElt() {
    return document.getElementById("PlacesToolbar");
  },

  /**
   * Initialize. This will check whether we've finished startup and can
   * show toolbars.
   */
  async init() {
    await PlacesUIUtils.canLoadToolbarContentPromise;
    this._realInit();
  },

  /**
   * Actually initialize the places view (if needed; we might still no-op).
   */
  _realInit() {
    let viewElt = this._viewElt;
    if (!viewElt || viewElt._placesView || window.closed) {
      return;
    }

    // CustomizableUI.addListener is idempotent, so we can safely
    // call this multiple times.
    CustomizableUI.addListener(this);

    if (!this._isObservingToolbars) {
      this._isObservingToolbars = true;
      window.addEventListener("toolbarvisibilitychange", this);
    }

    // If the bookmarks toolbar item is:
    // - not in a toolbar, or;
    // - the toolbar is collapsed, or;
    // - the toolbar is hidden some other way:
    // don't initialize.  Also, there is no need to initialize the toolbar if
    // customizing, because that will happen when the customization is done.
    let toolbar = this._getParentToolbar(viewElt);
    if (
      !toolbar ||
      toolbar.collapsed ||
      this._isCustomizing ||
      getComputedStyle(toolbar, "").display == "none"
    ) {
      return;
    }

    new PlacesToolbar(
      `place:parent=${PlacesUtils.bookmarks.toolbarGuid}`,
      document.getElementById("PlacesToolbarItems"),
      viewElt
    );

    if (
      toolbar.id == "PersonalToolbar" &&
      !toolbar.hasAttribute("initialized")
    ) {
      toolbar.setAttribute("initialized", "true");
      BookmarkingUI.updateEmptyToolbarMessage().catch(console.error);
    }
  },

  async getIsEmpty() {
    if (!this._viewElt._placesView) {
      return true;
    }
    await this._viewElt._placesView.promiseRebuilt();
    return !document.getElementById("PlacesToolbarItems").hasChildNodes();
  },

  handleEvent(event) {
    switch (event.type) {
      case "toolbarvisibilitychange":
        if (event.target == this._getParentToolbar(this._viewElt)) {
          this._resetView();
        }
        break;
    }
  },

  /**
   * This is a no-op if we haven't been initialized.
   */
  uninit: function PTH_uninit() {
    if (this._isObservingToolbars) {
      delete this._isObservingToolbars;
      window.removeEventListener("toolbarvisibilitychange", this);
    }
    CustomizableUI.removeListener(this);
  },

  customizeStart: function PTH_customizeStart() {
    try {
      let viewElt = this._viewElt;
      if (viewElt && viewElt._placesView) {
        viewElt._placesView.uninit();
      }
    } finally {
      this._isCustomizing = true;
    }
  },

  customizeDone: function PTH_customizeDone() {
    this._isCustomizing = false;
    this.init();
  },

  onPlaceholderCommand() {
    let widgetGroup = CustomizableUI.getWidget("personal-bookmarks");
    let widget = widgetGroup.forWindow(window);
    if (
      widget.overflowed ||
      widgetGroup.areaType == CustomizableUI.TYPE_PANEL
    ) {
      PlacesCommandHook.showPlacesOrganizer("BookmarksToolbar");
    }
  },

  _getParentToolbar(element) {
    while (element) {
      if (element.localName == "toolbar") {
        return element;
      }
      element = element.parentNode;
    }
    return null;
  },

  onWidgetUnderflow(aNode, aContainer) {
    // The view gets broken by being removed and reinserted by the overflowable
    // toolbar, so we have to force an uninit and reinit.
    let win = aNode.ownerGlobal;
    if (aNode.id == "personal-bookmarks" && win == window) {
      this._resetView();
    }
  },

  onWidgetAdded(aWidgetId, aArea, aPosition) {
    if (aWidgetId == "personal-bookmarks" && !this._isCustomizing) {
      // It's possible (with the "Add to Menu", "Add to Toolbar" context
      // options) that the Places Toolbar Items have been moved without
      // letting us prepare and handle it with with customizeStart and
      // customizeDone. If that's the case, we need to reset the views
      // since they're probably broken from the DOM reparenting.
      this._resetView();
    }
  },

  _resetView() {
    if (this._viewElt) {
      // It's possible that the placesView might not exist, and we need to
      // do a full init. This could happen if the Bookmarks Toolbar Items are
      // moved to the Menu Panel, and then to the toolbar with the "Add to Toolbar"
      // context menu option, outside of customize mode.
      if (this._viewElt._placesView) {
        this._viewElt._placesView.uninit();
      }
      this.init();
    }
  },

  async populateManagedBookmarks(popup) {
    if (popup.hasChildNodes()) {
      return;
    }
    // Show item's uri in the status bar when hovering, and clear on exit
    popup.addEventListener("DOMMenuItemActive", function (event) {
      XULBrowserWindow.setOverLink(event.target.link);
    });
    popup.addEventListener("DOMMenuItemInactive", function () {
      XULBrowserWindow.setOverLink("");
    });
    let fragment = document.createDocumentFragment();
    await this.addManagedBookmarks(
      fragment,
      Services.policies.getActivePolicies().ManagedBookmarks
    );
    popup.appendChild(fragment);
  },

  async addManagedBookmarks(menu, children) {
    for (let i = 0; i < children.length; i++) {
      let entry = children[i];
      if (entry.children) {
        // It's a folder.
        let submenu = document.createXULElement("menu");
        if (entry.name) {
          submenu.setAttribute("label", entry.name);
        } else {
          submenu.setAttribute("data-l10n-id", "managed-bookmarks-subfolder");
        }
        submenu.setAttribute("container", "true");
        submenu.setAttribute(
          "class",
          "menu-iconic bookmark-item subviewbutton"
        );
        let submenupopup = document.createXULElement("menupopup");
        submenupopup.setAttribute("placespopup", "true");
        submenu.appendChild(submenupopup);
        menu.appendChild(submenu);
        this.addManagedBookmarks(submenupopup, entry.children);
      } else if (entry.name && entry.url) {
        // It's bookmark.
        let { preferredURI } = Services.uriFixup.getFixupURIInfo(entry.url);
        let menuitem = document.createXULElement("menuitem");
        menuitem.setAttribute("label", entry.name);
        menuitem.setAttribute("image", "page-icon:" + preferredURI.spec);
        menuitem.setAttribute(
          "class",
          "menuitem-iconic bookmark-item menuitem-with-favicon subviewbutton"
        );
        menuitem.link = preferredURI.spec;
        menu.appendChild(menuitem);
      }
    }
  },

  openManagedBookmark(event) {
    openUILink(event.target.link, event, {
      triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(),
    });
  },

  onDragStartManaged(event) {
    if (!event.target.link) {
      return;
    }

    let dt = event.dataTransfer;

    let node = {};
    node.type = 0;
    node.title = event.target.label;
    node.uri = event.target.link;

    function addData(type, index) {
      let wrapNode = PlacesUtils.wrapNode(node, type);
      dt.mozSetDataAt(type, wrapNode, index);
    }

    addData(PlacesUtils.TYPE_X_MOZ_URL, 0);
    addData(PlacesUtils.TYPE_PLAINTEXT, 0);
    addData(PlacesUtils.TYPE_HTML, 0);
  },
};

/**
 * Handles the bookmarks menu-button in the toolbar.
 */

var BookmarkingUI = {
  STAR_ID: "star-button",
  STAR_BOX_ID: "star-button-box",
  BOOKMARK_BUTTON_ID: "bookmarks-menu-button",
  BOOKMARK_BUTTON_SHORTCUT: "addBookmarkAsKb",
  get button() {
    delete this.button;
    let widgetGroup = CustomizableUI.getWidget(this.BOOKMARK_BUTTON_ID);
    return (this.button = widgetGroup.forWindow(window).node);
  },

  get star() {
    delete this.star;
    return (this.star = document.getElementById(this.STAR_ID));
  },

  get starBox() {
    delete this.starBox;
    return (this.starBox = document.getElementById(this.STAR_BOX_ID));
  },

  get anchor() {
    let action = PageActions.actionForID(PageActions.ACTION_ID_BOOKMARK);
    return BrowserPageActions.panelAnchorNodeForAction(action);
  },

  get stringbundleset() {
    delete this.stringbundleset;
    return (this.stringbundleset = document.getElementById("stringbundleset"));
  },

  get toolbar() {
    delete this.toolbar;
    return (this.toolbar = document.getElementById("PersonalToolbar"));
  },

  STATUS_UPDATING: -1,
  STATUS_UNSTARRED: 0,
  STATUS_STARRED: 1,
  get status() {
    if (this._pendingUpdate) {
      return this.STATUS_UPDATING;
    }
    return this.star.hasAttribute("starred")
      ? this.STATUS_STARRED
      : this.STATUS_UNSTARRED;
  },

  onPopupShowing: function BUI_onPopupShowing(event) {
    // Don't handle events for submenus.
    if (event.target != event.currentTarget) {
      return;
    }

    // On non-photon, this code should never be reached. However, if you click
    // the outer button's border, some cpp code for the menu button's XBL
    // binding decides to open the popup even though the dropmarker is invisible.
    //
    // Separately, in Photon, if the button is in the dynamic portion of the
    // overflow panel, we want to show a subview instead.
    if (
      this.button.getAttribute("cui-areatype") == CustomizableUI.TYPE_PANEL ||
      this.button.hasAttribute("overflowedItem")
    ) {
      this._showSubView();
      event.preventDefault();
      event.stopPropagation();
      return;
    }

    let widget = CustomizableUI.getWidget(this.BOOKMARK_BUTTON_ID).forWindow(
      window
    );
    if (widget.overflowed) {
      // Don't open a popup in the overflow popup, rather just open the Library.
      event.preventDefault();
      widget.node.removeAttribute("closemenu");
      PlacesCommandHook.showPlacesOrganizer("BookmarksMenu");
      return;
    }

    this._initMobileBookmarks(document.getElementById("BMB_mobileBookmarks"));

    this.updateLabel(
      "BMB_viewBookmarksSidebar",
      SidebarUI.currentID == "viewBookmarksSidebar"
    );
    this.updateLabel("BMB_viewBookmarksToolbar", !this.toolbar.collapsed);
  },

  updateLabel(elementId, visible) {
    let element = PanelMultiView.getViewNode(document, elementId);
    let l10nID = element.getAttribute("data-l10n-id");
    document.l10n.setAttributes(element, l10nID, { isVisible: !!visible });
  },

  toggleBookmarksToolbar(reason) {
    let newState = this.toolbar.collapsed ? "always" : "never";
    Services.prefs.setCharPref(
      "browser.toolbars.bookmarks.visibility",
      // See firefox.js for possible values
      newState
    );

    CustomizableUI.setToolbarVisibility(this.toolbar.id, newState, false);
    BrowserUsageTelemetry.recordToolbarVisibility(
      this.toolbar.id,
      newState,
      reason
    );
  },

  isOnNewTabPage({ currentURI }) {
    // Prevent loading AboutNewTab.jsm during startup path if it
    // is only the newTabURL getter we are interested in.
    let newTabURL = Cu.isModuleLoaded("resource:///modules/AboutNewTab.jsm")
      ? AboutNewTab.newTabURL
      : "about:newtab";
    // Don't treat a custom "about:blank" new tab URL as the "New Tab Page"
    // due to about:blank being used in different contexts and the
    // difficulty in determining if the eventual page load is
    // about:blank or if the about:blank load is just temporary.
    if (newTabURL == "about:blank") {
      newTabURL = "about:newtab";
    }
    let newTabURLs = [newTabURL, "about:home"];
    if (PrivateBrowsingUtils.isWindowPrivate(window)) {
      newTabURLs.push("about:privatebrowsing");
    }
    return newTabURLs.some(uri => currentURI?.spec.startsWith(uri));
  },

  buildBookmarksToolbarSubmenu(toolbar) {
    let alwaysShowMenuItem = document.createXULElement("menuitem");
    let alwaysHideMenuItem = document.createXULElement("menuitem");
    let showOnNewTabMenuItem = document.createXULElement("menuitem");
    let menuPopup = document.createXULElement("menupopup");
    menuPopup.append(
      alwaysShowMenuItem,
      showOnNewTabMenuItem,
      alwaysHideMenuItem
    );
    let menu = document.createXULElement("menu");
    menu.appendChild(menuPopup);

    menu.setAttribute("label", toolbar.getAttribute("toolbarname"));
    menu.setAttribute("id", "toggle_" + toolbar.id);
    menu.setAttribute("accesskey", toolbar.getAttribute("accesskey"));
    menu.setAttribute("toolbarId", toolbar.id);

    // Used by the Places context menu in the Bookmarks Toolbar
    // when nothing is selected
    menu.setAttribute("selection-type", "none|single");

    MozXULElement.insertFTLIfNeeded("browser/toolbarContextMenu.ftl");
    let menuItems = [
      [
        showOnNewTabMenuItem,
        "toolbar-context-menu-bookmarks-toolbar-on-new-tab-2",
        "newtab",
      ],
      [
        alwaysShowMenuItem,
        "toolbar-context-menu-bookmarks-toolbar-always-show-2",
        "always",
      ],
      [
        alwaysHideMenuItem,
        "toolbar-context-menu-bookmarks-toolbar-never-show-2",
        "never",
      ],
    ];
    menuItems.map(([menuItem, l10nId, visibilityEnum]) => {
      document.l10n.setAttributes(menuItem, l10nId);
      menuItem.setAttribute("type", "radio");
      // The persisted state of the PersonalToolbar is stored in
      // "browser.toolbars.bookmarks.visibility".
      menuItem.setAttribute(
        "checked",
        gBookmarksToolbarVisibility == visibilityEnum
      );
      // Identify these items for "onViewToolbarCommand" so
      // we know to check the visibilityEnum value.
      menuItem.dataset.bookmarksToolbarVisibility = true;
      menuItem.dataset.visibilityEnum = visibilityEnum;
      menuItem.addEventListener("command", onViewToolbarCommand);
    });
    let menuItemForNextStateFromKbShortcut =
      gBookmarksToolbarVisibility == "never"
        ? alwaysShowMenuItem
        : alwaysHideMenuItem;
    menuItemForNextStateFromKbShortcut.setAttribute(
      "key",
      "viewBookmarksToolbarKb"
    );

    return menu;
  },

  /**
   * Check if we need to make the empty toolbar message `hidden`.
   * We'll have it unhidden during startup, to make sure the toolbar
   * has height, and we'll unhide it if there is nothing else on the toolbar.
   * We hide it in customize mode, unless there's nothing on the toolbar.
   */
  async updateEmptyToolbarMessage() {
    let checkNumBookmarksOnToolbar = false;
    let hasVisibleChildren = (() => {
      // Do we have visible kids?
      if (
        this.toolbar.querySelector(
          `:scope > toolbarpaletteitem > toolbarbutton:not([hidden]),
           :scope > toolbarpaletteitem > toolbaritem:not([hidden], #personal-bookmarks),
           :scope > toolbarbutton:not([hidden]),
           :scope > toolbaritem:not([hidden], #personal-bookmarks)`
        )
      ) {
        return true;
      }
      if (!this.toolbar.hasAttribute("initialized") && !this._isCustomizing) {
        // If the bookmarks are here but it's early in startup, show the
        // message. It'll get made visibility: hidden early in startup anyway -
        // it's just to ensure the toolbar has height.
        return false;
      }
      // Hmm, apparently not. Check for bookmarks or customize mode:
      let bookmarksToolbarItemsPlacement =
        CustomizableUI.getPlacementOfWidget("personal-bookmarks");
      let bookmarksItemInToolbar =
        bookmarksToolbarItemsPlacement?.area == CustomizableUI.AREA_BOOKMARKS;
      if (!bookmarksItemInToolbar) {
        return false;
      }
      if (this._isCustomizing) {
        return true;
      }
      // Check visible bookmark nodes.
      if (
        this.toolbar.querySelector(
          `#PlacesToolbarItems > toolbarseparator,
           #PlacesToolbarItems > toolbarbutton`
        )
      ) {
        return true;
      }
      checkNumBookmarksOnToolbar = true;
      return false;
    })();

    if (checkNumBookmarksOnToolbar) {
      hasVisibleChildren = !(await PlacesToolbarHelper.getIsEmpty());
    }

    let emptyMsg = document.getElementById("personal-toolbar-empty");
    emptyMsg.hidden = hasVisibleChildren;
    emptyMsg.toggleAttribute("nowidth", !hasVisibleChildren);
  },

  openLibraryIfLinkClicked(event) {
    if (
      ((event.type == "click" && event.button == 0) ||
        (event.type == "keydown" && event.keyCode == KeyEvent.DOM_VK_RETURN)) &&
      event.target.localName == "a"
    ) {
      PlacesCommandHook.showPlacesOrganizer("BookmarksToolbar");
    }
  },

  // Set by sync after syncing bookmarks successfully once.
  MOBILE_BOOKMARKS_PREF: "browser.bookmarks.showMobileBookmarks",

  _shouldShowMobileBookmarks() {
    return Services.prefs.getBoolPref(this.MOBILE_BOOKMARKS_PREF, false);
  },

  _initMobileBookmarks(mobileMenuItem) {
    mobileMenuItem.hidden = !this._shouldShowMobileBookmarks();
  },

  _uninitView: function BUI__uninitView() {
    // When an element with a placesView attached is removed and re-inserted,
    // XBL reapplies the binding causing any kind of issues and possible leaks,
    // so kill current view and let popupshowing generate a new one.
    if (this.button._placesView) {
      this.button._placesView.uninit();
    }
    // Also uninit the main menubar placesView, since it would have the same
    // issues.
    let menubar = document.getElementById("bookmarksMenu");
    if (menubar && menubar._placesView) {
      menubar._placesView.uninit();
    }

    // We have to do the same thing for the "special" views underneath the
    // the bookmarks menu.
    const kSpecialViewNodeIDs = [
      "BMB_bookmarksToolbar",
      "BMB_unsortedBookmarks",
    ];
    for (let viewNodeID of kSpecialViewNodeIDs) {
      let elem = document.getElementById(viewNodeID);
      if (elem && elem._placesView) {
        elem._placesView.uninit();
      }
    }
  },

  onCustomizeStart: function BUI_customizeStart(aWindow) {
    if (aWindow == window) {
      this._uninitView();
      this._isCustomizing = true;

      this.updateEmptyToolbarMessage().catch(console.error);

      let isVisible =
        Services.prefs.getCharPref(
          "browser.toolbars.bookmarks.visibility",
          "newtab"
        ) != "never";
      // Temporarily show the bookmarks toolbar in Customize mode if
      // the toolbar isn't set to Never. We don't have to worry about
      // hiding when leaving customize mode since the toolbar will
      // hide itself on location change.
      setToolbarVisibility(this.toolbar, isVisible, false);
    }
  },

  onWidgetAdded: function BUI_widgetAdded(aWidgetId, aArea) {
    if (aWidgetId == this.BOOKMARK_BUTTON_ID) {
      this._onWidgetWasMoved();
    }
    if (aArea == CustomizableUI.AREA_BOOKMARKS) {
      this.updateEmptyToolbarMessage().catch(console.error);
    }
  },

  onWidgetRemoved: function BUI_widgetRemoved(aWidgetId, aOldArea) {
    if (aWidgetId == this.BOOKMARK_BUTTON_ID) {
      this._onWidgetWasMoved();
    }
    if (aOldArea == CustomizableUI.AREA_BOOKMARKS) {
      this.updateEmptyToolbarMessage().catch(console.error);
    }
  },

  onWidgetReset: function BUI_widgetReset(aNode, aContainer) {
    if (aNode == this.button) {
      this._onWidgetWasMoved();
    }
  },

  onWidgetUndoMove: function BUI_undoWidgetUndoMove(aNode, aContainer) {
    if (aNode == this.button) {
      this._onWidgetWasMoved();
    }
  },

  onWidgetBeforeDOMChange: function BUI_onWidgetBeforeDOMChange(
    aNode,
    aNextNode,
    aContainer,
    aIsRemoval
  ) {
    if (aNode.id == "import-button") {
      this._updateImportButton(aNode, aIsRemoval ? null : aContainer);
    }
  },

  _updateImportButton: function BUI_updateImportButton(aNode, aContainer) {
    // The import button behaves like a bookmark item when in the bookmarks
    // toolbar, otherwise like a regular toolbar button.
    let isBookmarkItem = aContainer == this.toolbar;
    aNode.classList.toggle("toolbarbutton-1", !isBookmarkItem);
    aNode.classList.toggle("bookmark-item", isBookmarkItem);
  },

  _onWidgetWasMoved: function BUI_widgetWasMoved() {
    // If we're moved outside of customize mode, we need to uninit
    // our view so it gets reconstructed.
    if (!this._isCustomizing) {
      this._uninitView();
    }
  },

  onCustomizeEnd: function BUI_customizeEnd(aWindow) {
    if (aWindow == window) {
      this._isCustomizing = false;
      this.updateEmptyToolbarMessage().catch(console.error);
    }
  },

  init() {
    CustomizableUI.addListener(this);
    let importButton = document.getElementById("import-button");
    if (importButton) {
      this._updateImportButton(importButton, importButton.parentNode);
    }
    this.updateEmptyToolbarMessage().catch(console.error);
  },

  _hasBookmarksObserver: false,
  _itemGuids: new Set(),
  uninit: function BUI_uninit() {
    this.updateBookmarkPageMenuItem(true);
    CustomizableUI.removeListener(this);

    this._uninitView();

    if (this._hasBookmarksObserver) {
      PlacesUtils.observers.removeListener(
        [
          "bookmark-added",
          "bookmark-removed",
          "bookmark-moved",
          "bookmark-url-changed",
        ],
        this.handlePlacesEvents
      );
    }

    if (this._pendingUpdate) {
      delete this._pendingUpdate;
    }
  },

  onLocationChange: function BUI_onLocationChange() {
    if (this._uri && gBrowser.currentURI.equals(this._uri)) {
      return;
    }
    this.updateStarState();
  },

  updateStarState: function BUI_updateStarState() {
    this._uri = gBrowser.currentURI;
    this._itemGuids.clear();
    let guids = new Set();

    // those objects are use to check if we are in the current iteration before
    // returning any result.
    let pendingUpdate = (this._pendingUpdate = {});

    PlacesUtils.bookmarks
      .fetch({ url: this._uri }, b => guids.add(b.guid), { concurrent: true })
      .catch(console.error)
      .then(() => {
        if (pendingUpdate != this._pendingUpdate) {
          return;
        }

        // It's possible that "bookmark-added" gets called before the async statement
        // calls back.  For such an edge case, retain all unique entries from the
        // array.
        if (this._itemGuids.size > 0) {
          this._itemGuids = new Set(...this._itemGuids, ...guids);
        } else {
          this._itemGuids = guids;
        }

        this._updateStar();

        // Start observing bookmarks if needed.
        if (!this._hasBookmarksObserver) {
          try {
            this.handlePlacesEvents = this.handlePlacesEvents.bind(this);
            PlacesUtils.observers.addListener(
              [
                "bookmark-added",
                "bookmark-removed",
                "bookmark-moved",
                "bookmark-url-changed",
              ],
              this.handlePlacesEvents
            );
            this._hasBookmarksObserver = true;
          } catch (ex) {
            console.error(
              "BookmarkingUI failed adding a bookmarks observer: ",
              ex
            );
          }
        }

        delete this._pendingUpdate;
      });
  },

  _updateStar: function BUI__updateStar() {
    let starred = this._itemGuids.size > 0;

    // Update the image for all elements.
    for (let element of [
      this.star,
      document.getElementById("context-bookmarkpage"),
      PanelMultiView.getViewNode(document, "panelMenuBookmarkThisPage"),
      document.getElementById("pageAction-panel-bookmark"),
    ]) {
      if (!element) {
        // The page action panel element may not have been created yet.
        continue;
      }
      if (starred) {
        element.setAttribute("starred", "true");
      } else {
        element.removeAttribute("starred");
      }
    }

    if (!this.starBox) {
      // The BOOKMARK_BUTTON_SHORTCUT exists only in browser.xhtml.
      // Return early if we're not in this context, but still reset the
      // Bookmark Page items.
      this.updateBookmarkPageMenuItem(true);
      return;
    }

    // Update the tooltip for elements that require it.
    let shortcut = document.getElementById(this.BOOKMARK_BUTTON_SHORTCUT);
    let l10nArgs = {
      shortcut: ShortcutUtils.prettifyShortcut(shortcut),
    };
    document.l10n.setAttributes(
      this.starBox,
      starred ? "urlbar-star-edit-bookmark" : "urlbar-star-add-bookmark",
      l10nArgs
    );

    // Update the Bookmark Page menuitem when bookmarked state changes.
    this.updateBookmarkPageMenuItem();

    Services.obs.notifyObservers(
      null,
      "bookmark-icon-updated",
      starred ? "starred" : "unstarred"
    );
  },

  /**
   * Update the "Bookmark Page…" menuitems on the menubar, panels, context
   * menu and page actions.
   * @param {boolean} [forceReset] passed when we're destroyed and the label
   * should go back to the default (Bookmark Page), for MacOS.
   */
  updateBookmarkPageMenuItem(forceReset = false) {
    let isStarred = !forceReset && this._itemGuids.size > 0;
    // Define the l10n id which will be used to localize elements
    // that only require a label using the menubar.ftl messages.
    let menuItemL10nId = isStarred ? "menu-edit-bookmark" : "menu-bookmark-tab";
    let menuItem = document.getElementById("menu_bookmarkThisPage");
    if (menuItem) {
      // Localize the menubar item.
      document.l10n.setAttributes(menuItem, menuItemL10nId);
    }

    let panelMenuItemL10nId = isStarred
      ? "bookmarks-subview-edit-bookmark"
      : "bookmarks-subview-bookmark-tab";
    let panelMenuToolbarButton = PanelMultiView.getViewNode(
      document,
      "panelMenuBookmarkThisPage"
    );
    if (panelMenuToolbarButton) {
      document.l10n.setAttributes(panelMenuToolbarButton, panelMenuItemL10nId);
    }

    // Localize the context menu item element.
    let contextItem = document.getElementById("context-bookmarkpage");
    // On macOS regular menuitems are used and the shortcut isn't added
    if (contextItem) {
      if (AppConstants.platform == "macosx") {
        let contextItemL10nId = isStarred
          ? "main-context-menu-edit-bookmark-mac"
          : "main-context-menu-bookmark-page-mac";
        document.l10n.setAttributes(contextItem, contextItemL10nId);
      } else {
        let shortcutElem = document.getElementById(
          this.BOOKMARK_BUTTON_SHORTCUT
        );
        if (shortcutElem) {
          let shortcut = ShortcutUtils.prettifyShortcut(shortcutElem);
          let contextItemL10nId = isStarred
            ? "main-context-menu-edit-bookmark-with-shortcut"
            : "main-context-menu-bookmark-page-with-shortcut";
          let l10nArgs = { shortcut };
          document.l10n.setAttributes(contextItem, contextItemL10nId, l10nArgs);
        } else {
          let contextItemL10nId = isStarred
            ? "main-context-menu-edit-bookmark"
            : "main-context-menu-bookmark-page";
          document.l10n.setAttributes(contextItem, contextItemL10nId);
        }
      }
    }

    // Update Page Actions.
    if (document.getElementById("page-action-buttons")) {
      // Fetch the label attribute value of the message and
      // apply it on the star title.
      //
      // Note: This should be updated once bug 1608198 is fixed.
      this._latestMenuItemL10nId = menuItemL10nId;
      document.l10n.formatMessages([{ id: menuItemL10nId }]).then(l10n => {
        // It's possible for this promise to be scheduled multiple times.
        // In such a case, we'd like to avoid setting the title if there's
        // a newer l10n id pending to be set.
        if (this._latestMenuItemL10nId != menuItemL10nId) {
          return;
        }

        // We assume that menuItemL10nId has a single attribute.
        let label = l10n[0].attributes[0].value;

        // Update the label for the page action panel.
        let panelButton = BrowserPageActions.panelButtonNodeForActionID(
          PageActions.ACTION_ID_BOOKMARK
        );
        if (panelButton) {
          panelButton.setAttribute("label", label);
        }
      });
    }
  },

  onMainMenuPopupShowing: function BUI_onMainMenuPopupShowing(event) {
    // Don't handle events for submenus.
    if (event.target != event.currentTarget) {
      return;
    }

    this._initMobileBookmarks(document.getElementById("menu_mobileBookmarks"));
  },

  showSubView(anchor) {
    this._showSubView(null, anchor);
  },

  _showSubView(
    event,
    anchor = document.getElementById(this.BOOKMARK_BUTTON_ID)
  ) {
    let view = PanelMultiView.getViewNode(document, "PanelUI-bookmarks");
    view.addEventListener("ViewShowing", this);
    view.addEventListener("ViewHiding", this);
    anchor.setAttribute("closemenu", "none");
    this.updateLabel("panelMenu_viewBookmarksToolbar", !this.toolbar.collapsed);
    PanelUI.showSubView("PanelUI-bookmarks", anchor, event);
  },

  onCommand: function BUI_onCommand(aEvent) {
    if (aEvent.target != aEvent.currentTarget) {
      return;
    }

    // Handle special case when the button is in the panel.
    if (this.button.getAttribute("cui-areatype") == CustomizableUI.TYPE_PANEL) {
      this._showSubView(aEvent);
      return;
    }
    let widget = CustomizableUI.getWidget(this.BOOKMARK_BUTTON_ID).forWindow(
      window
    );
    if (widget.overflowed) {
      // Close the overflow panel because the Edit Bookmark panel will appear.
      widget.node.removeAttribute("closemenu");
    }
    this.onStarCommand(aEvent);
  },

  onStarCommand(aEvent) {
    // Ignore non-left clicks on the star, or if we are updating its state.
    if (
      !this._pendingUpdate &&
      (aEvent.type != "click" || aEvent.button == 0)
    ) {
      PlacesCommandHook.bookmarkPage();
    }
  },

  handleEvent: function BUI_handleEvent(aEvent) {
    switch (aEvent.type) {
      case "ViewShowing":
        this.onPanelMenuViewShowing(aEvent);
        break;
      case "ViewHiding":
        this.onPanelMenuViewHiding(aEvent);
        break;
    }
  },

  onPanelMenuViewShowing: function BUI_onViewShowing(aEvent) {
    let panelview = aEvent.target;

    // Get all statically placed buttons to supply them with keyboard shortcuts.
    let staticButtons = panelview.getElementsByTagName("toolbarbutton");
    for (let i = 0, l = staticButtons.length; i < l; ++i) {
      CustomizableUI.addShortcut(staticButtons[i]);
    }

    // Setup the Places view.
    // We restrict the amount of results to 42. Not 50, but 42. Why? Because 42.
    let query =
      "place:queryType=" +
      Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS +
      "&sort=" +
      Ci.nsINavHistoryQueryOptions.SORT_BY_DATEADDED_DESCENDING +
      "&maxResults=42&excludeQueries=1";

    this._panelMenuView = new PlacesPanelview(
      query,
      document.getElementById("panelMenu_bookmarksMenu"),
      panelview
    );
    panelview.removeEventListener("ViewShowing", this);
  },

  onPanelMenuViewHiding: function BUI_onViewHiding(aEvent) {
    this._panelMenuView.uninit();
    delete this._panelMenuView;
    aEvent.target.removeEventListener("ViewHiding", this);
  },

  handlePlacesEvents(aEvents) {
    let isStarUpdateNeeded = false;
    let affectsOtherBookmarksFolder = false;
    let affectsBookmarksToolbarFolder = false;

    for (let ev of aEvents) {
      switch (ev.type) {
        case "bookmark-added":
          // Only need to update the UI if it wasn't marked as starred before:
          if (this._itemGuids.size == 0) {
            if (ev.url && ev.url == this._uri.spec) {
              // If a new bookmark has been added to the tracked uri, register it.
              if (!this._itemGuids.has(ev.guid)) {
                this._itemGuids.add(ev.guid);
                isStarUpdateNeeded = true;
              }
            }
          }

          if (ev.parentGuid === PlacesUtils.bookmarks.toolbarGuid) {
            Services.telemetry.scalarAdd(
              "browser.engagement.bookmarks_toolbar_bookmark_added",
              1
            );
          }
          break;
        case "bookmark-removed":
          // If one of the tracked bookmarks has been removed, unregister it.
          if (this._itemGuids.has(ev.guid)) {
            this._itemGuids.delete(ev.guid);
            // Only need to update the UI if the page is no longer starred
            if (this._itemGuids.size == 0) {
              isStarUpdateNeeded = true;
            }
          }

          // Reset the default location if it is equal to the folder
          // being deleted. Just check the preference directly since we
          // do not want to do a asynchronous db lookup.
          PlacesUIUtils.defaultParentGuid.then(parentGuid => {
            if (
              ev.itemType == PlacesUtils.bookmarks.TYPE_FOLDER &&
              ev.guid == parentGuid
            ) {
              Services.prefs.setCharPref(
                "browser.bookmarks.defaultLocation",
                PlacesUtils.bookmarks.toolbarGuid
              );
            }
          });
          break;
        case "bookmark-moved":
          if (
            ev.parentGuid === PlacesUtils.bookmarks.unfiledGuid ||
            ev.oldParentGuid === PlacesUtils.bookmarks.unfiledGuid
          ) {
            affectsOtherBookmarksFolder = true;
          }

          if (
            ev.parentGuid == PlacesUtils.bookmarks.toolbarGuid ||
            ev.oldParentGuid == PlacesUtils.bookmarks.toolbarGuid
          ) {
            affectsBookmarksToolbarFolder = true;
            if (ev.oldParentGuid != PlacesUtils.bookmarks.toolbarGuid) {
              Services.telemetry.scalarAdd(
                "browser.engagement.bookmarks_toolbar_bookmark_added",
                1
              );
            }
          }
          break;
        case "bookmark-url-changed":
          // If the changed bookmark was tracked, check if it is now pointing to
          // a different uri and unregister it.
          if (this._itemGuids.has(ev.guid) && ev.url != this._uri.spec) {
            this._itemGuids.delete(ev.guid);
            // Only need to update the UI if the page is no longer starred
            if (this._itemGuids.size == 0) {
              this._updateStar();
            }
          } else if (
            !this._itemGuids.has(ev.guid) &&
            ev.url == this._uri.spec
          ) {
            // If another bookmark is now pointing to the tracked uri, register it.
            this._itemGuids.add(ev.guid);
            // Only need to update the UI if it wasn't marked as starred before:
            if (this._itemGuids.size == 1) {
              this._updateStar();
            }
          }

          break;
      }

      if (ev.parentGuid == PlacesUtils.bookmarks.unfiledGuid) {
        affectsOtherBookmarksFolder = true;
      } else if (ev.parentGuid == PlacesUtils.bookmarks.toolbarGuid) {
        affectsBookmarksToolbarFolder = true;
      }
    }

    if (isStarUpdateNeeded) {
      this._updateStar();
    }

    // Run after the notification has been handled by the views.
    Services.tm.dispatchToMainThread(() => {
      if (affectsOtherBookmarksFolder) {
        this.maybeShowOtherBookmarksFolder().catch(console.error);
      }
      if (affectsBookmarksToolbarFolder) {
        this.updateEmptyToolbarMessage().catch(console.error);
      }
    });
  },

  onWidgetUnderflow(aNode, aContainer) {
    let win = aNode.ownerGlobal;
    if (aNode.id != this.BOOKMARK_BUTTON_ID || win != window) {
      return;
    }

    // The view gets broken by being removed and reinserted. Uninit
    // here so popupshowing will generate a new one:
    this._uninitView();
  },

  async maybeShowOtherBookmarksFolder() {
    // PlacesToolbar._placesView can be undefined if the toolbar isn't initialized,
    // collapsed, or hidden in some other way.
    let toolbar = document.getElementById("PlacesToolbar");
    if (!toolbar?._placesView) {
      return;
    }

    let placement = CustomizableUI.getPlacementOfWidget("personal-bookmarks");
    let otherBookmarks = document.getElementById("OtherBookmarks");
    if (
      !SHOW_OTHER_BOOKMARKS ||
      placement?.area != CustomizableUI.AREA_BOOKMARKS
    ) {
      if (otherBookmarks) {
        otherBookmarks.hidden = true;
      }
      return;
    }

    let instance = (this._showOtherBookmarksInstance = {});
    let unfiledGuid = PlacesUtils.bookmarks.unfiledGuid;
    let numberOfBookmarks = (await PlacesUtils.bookmarks.fetch(unfiledGuid))
      .childCount;
    if (instance != this._showOtherBookmarksInstance) {
      return;
    }

    if (numberOfBookmarks > 0) {
      // Build the "Other Bookmarks" button if it doesn't exist.
      if (!otherBookmarks) {
        const node = PlacesUtils.getFolderContents(unfiledGuid).root;
        otherBookmarks = this.buildOtherBookmarksFolder(node);
      }
      otherBookmarks.hidden = false;
    } else if (otherBookmarks) {
      otherBookmarks.hidden = true;
    }
  },

  buildShowOtherBookmarksMenuItem() {
    // Building this only if there's bookmarks in unfiled would cause
    // synchronous IO, thus we just add it as disabled and enable it once the
    // information is available.
    let menuItem = document.createXULElement("menuitem");

    menuItem.setAttribute("id", "show-other-bookmarks_PersonalToolbar");
    menuItem.setAttribute("toolbarId", "PersonalToolbar");
    menuItem.setAttribute("type", "checkbox");
    menuItem.setAttribute("checked", SHOW_OTHER_BOOKMARKS);
    menuItem.setAttribute("selection-type", "none|single");
    menuItem.setAttribute("start-disabled", "true");

    MozXULElement.insertFTLIfNeeded("browser/toolbarContextMenu.ftl");
    document.l10n.setAttributes(
      menuItem,
      "toolbar-context-menu-bookmarks-show-other-bookmarks"
    );
    menuItem.addEventListener("command", () => {
      Services.prefs.setBoolPref(
        "browser.toolbars.bookmarks.showOtherBookmarks",
        !SHOW_OTHER_BOOKMARKS
      );
    });
    // Enable the menuItem if there's unfiled bookmarks
    PlacesUtils.bookmarks.fetch(PlacesUtils.bookmarks.unfiledGuid).then(bm => {
      if (bm.childCount) {
        menuItem.disabled = false;
      }
    });

    return menuItem;
  },

  buildOtherBookmarksFolder(node) {
    let otherBookmarksButton = document.createXULElement("toolbarbutton");
    otherBookmarksButton.setAttribute("type", "menu");
    otherBookmarksButton.setAttribute("container", "true");
    otherBookmarksButton.setAttribute(
      "onpopupshowing",
      "document.getElementById('PlacesToolbar')._placesView._onOtherBookmarksPopupShowing(event);"
    );
    otherBookmarksButton.id = "OtherBookmarks";
    otherBookmarksButton.className = "bookmark-item";
    otherBookmarksButton.hidden = "true";

    MozXULElement.insertFTLIfNeeded("browser/places.ftl");
    document.l10n.setAttributes(otherBookmarksButton, "other-bookmarks-folder");

    let otherBookmarksPopup = document.createXULElement("menupopup", {
      is: "places-popup",
    });
    otherBookmarksPopup.setAttribute("placespopup", "true");
    otherBookmarksPopup.setAttribute("type", "arrow");
    otherBookmarksPopup.setAttribute("context", "placesContext");
    otherBookmarksPopup.id = "OtherBookmarksPopup";

    otherBookmarksPopup._placesNode = PlacesUtils.asContainer(node);
    otherBookmarksButton._placesNode = PlacesUtils.asContainer(node);

    otherBookmarksButton.appendChild(otherBookmarksPopup);

    let chevronButton = document.getElementById("PlacesChevron");
    chevronButton.parentNode.append(otherBookmarksButton);

    let placesToolbar = document.getElementById("PlacesToolbar");
    placesToolbar._placesView._otherBookmarks = otherBookmarksButton;
    placesToolbar._placesView._otherBookmarksPopup = otherBookmarksPopup;
    return otherBookmarksButton;
  },
};
