/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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/. */

#ifndef mozilla_dom_DocumentOrShadowRoot_h__
#define mozilla_dom_DocumentOrShadowRoot_h__

#include "mozilla/IdentifierMapEntry.h"
#include "mozilla/RelativeTo.h"
#include "mozilla/ReverseIterator.h"
#include "mozilla/dom/NameSpaceConstants.h"
#include "nsClassHashtable.h"
#include "nsContentListDeclarations.h"
#include "nsTArray.h"
#include "nsTHashSet.h"

class nsContentList;
class nsCycleCollectionTraversalCallback;
class nsINode;
class nsINodeList;
class nsWindowSizes;

namespace mozilla {
class ErrorResult;
class StyleSheet;
class ErrorResult;

namespace dom {

class Animation;
class Element;
class Document;
class DocumentOrShadowRoot;
class HTMLInputElement;
class StyleSheetList;
class ShadowRoot;
template <typename T>
class Sequence;

/**
 * A class meant to be shared by ShadowRoot and Document, that holds a list of
 * stylesheets.
 *
 * TODO(emilio, bug 1418159): In the future this should hold most of the
 * relevant style state, this should allow us to fix bug 548397.
 */
class DocumentOrShadowRoot {
  enum class Kind {
    Document,
    ShadowRoot,
  };

 public:
  // These should always be non-null, but can't use a reference because
  // dereferencing `this` on initializer lists is UB, apparently, see
  // bug 1596499.
  explicit DocumentOrShadowRoot(Document*);
  explicit DocumentOrShadowRoot(ShadowRoot*);

  // Unusual argument naming is because of cycle collection macros.
  static void Traverse(DocumentOrShadowRoot* tmp,
                       nsCycleCollectionTraversalCallback& cb);
  static void Unlink(DocumentOrShadowRoot* tmp);

  nsINode& AsNode() { return *mAsNode; }

  const nsINode& AsNode() const { return *mAsNode; }

  StyleSheet* SheetAt(size_t aIndex) const {
    return mStyleSheets.SafeElementAt(aIndex);
  }

  size_t SheetCount() const { return mStyleSheets.Length(); }

  const nsTArray<RefPtr<StyleSheet>>& AdoptedStyleSheets() const {
    return mAdoptedStyleSheets;
  }

  size_t FindSheetInsertionPointInTree(const StyleSheet&) const;

  /**
   * Returns an index for the sheet in relative style order.
   * If there are non-applicable sheets, then this index may
   * not match 1:1 with the sheet's actual index in the style set.
   *
   * Handles sheets from both mStyleSheets and mAdoptedStyleSheets
   */
  size_t StyleOrderIndexOfSheet(const StyleSheet& aSheet) const;

  StyleSheetList* StyleSheets();

  void RemoveStyleSheet(StyleSheet&);

  Element* GetElementById(const nsAString& aElementId) const;
  Element* GetElementById(nsAtom* aElementId) const;

  /**
   * This method returns _all_ the elements in this scope which have id
   * aElementId, if there are any.  Otherwise it returns null.
   *
   * This is useful for stuff like QuerySelector optimization and such.
   */
  const nsTArray<Element*>* GetAllElementsForId(
      const IdentifierMapEntry::DependentAtomOrString& aElementId) const {
    IdentifierMapEntry* entry = mIdentifierMap.GetEntry(aElementId);
    return entry ? &entry->GetIdElements() : nullptr;
  }

  already_AddRefed<nsContentList> GetElementsByTagName(
      const nsAString& aTagName) {
    return NS_GetContentList(&AsNode(), kNameSpaceID_Unknown, aTagName);
  }

  already_AddRefed<nsContentList> GetElementsByTagNameNS(
      const nsAString& aNamespaceURI, const nsAString& aLocalName);

  already_AddRefed<nsContentList> GetElementsByTagNameNS(
      const nsAString& aNamespaceURI, const nsAString& aLocalName,
      mozilla::ErrorResult&);

  already_AddRefed<nsContentList> GetElementsByClassName(
      const nsAString& aClasses);

  ~DocumentOrShadowRoot();

  Element* GetPointerLockElement();
  Element* GetFullscreenElement() const;

  Element* ElementFromPoint(float aX, float aY);
  nsINode* NodeFromPoint(float aX, float aY);

  void ElementsFromPoint(float aX, float aY, nsTArray<RefPtr<Element>>&);
  void NodesFromPoint(float aX, float aY, nsTArray<RefPtr<nsINode>>&);

  /**
   * Helper for elementFromPoint implementation that allows
   * ignoring the scroll frame and/or avoiding layout flushes.
   *
   * @see nsIDOMWindowUtils::elementFromPoint
   */
  Element* ElementFromPointHelper(float aX, float aY,
                                  bool aIgnoreRootScrollFrame,
                                  bool aFlushLayout, ViewportType aViewportType,
                                  bool aPerformRetargeting = true);

  void NodesFromRect(float aX, float aY, float aTopSize, float aRightSize,
                     float aBottomSize, float aLeftSize,
                     bool aIgnoreRootScrollFrame, bool aFlushLayout,
                     bool aOnlyVisible, float aVisibleThreshold,
                     nsTArray<RefPtr<nsINode>>&);

  /**
   * This gets fired when the element that an id refers to changes.
   * This fires at difficult times. It is generally not safe to do anything
   * which could modify the DOM in any way. Use
   * nsContentUtils::AddScriptRunner.
   * @return true to keep the callback in the callback set, false
   * to remove it.
   */
  typedef bool (*IDTargetObserver)(Element* aOldElement, Element* aNewelement,
                                   void* aData);

  /**
   * Add an IDTargetObserver for a specific ID. The IDTargetObserver
   * will be fired whenever the content associated with the ID changes
   * in the future. If aForImage is true, mozSetImageElement can override
   * what content is associated with the ID. In that case the IDTargetObserver
   * will be notified at those times when the result of LookupImageElement
   * changes.
   * At most one (aObserver, aData, aForImage) triple can be
   * registered for each ID.
   * @return the content currently associated with the ID.
   */
  Element* AddIDTargetObserver(nsAtom* aID, IDTargetObserver aObserver,
                               void* aData, bool aForImage);

  /**
   * Remove the (aObserver, aData, aForImage) triple for a specific ID, if
   * registered.
   */
  void RemoveIDTargetObserver(nsAtom* aID, IDTargetObserver aObserver,
                              void* aData, bool aForImage);

  /**
   * Lookup an image element using its associated ID, which is usually provided
   * by |-moz-element()|. Similar to GetElementById, with the difference that
   * elements set using mozSetImageElement have higher priority.
   * @param aId the ID associated the element we want to lookup
   * @return the element associated with |aId|
   */
  Element* LookupImageElement(nsAtom* aId);

  /**
   * Check that aId is not empty and log a message to the console
   * service if it is.
   * @returns true if aId looks correct, false otherwise.
   */
  inline bool CheckGetElementByIdArg(const nsAString& aId) {
    if (aId.IsEmpty()) {
      ReportEmptyGetElementByIdArg();
      return false;
    }
    return true;
  }

  void ReportEmptyGetElementByIdArg() const;

  // Web Animations
  MOZ_CAN_RUN_SCRIPT
  void GetAnimations(nsTArray<RefPtr<Animation>>& aAnimations);

  nsINode* Retarget(nsINode*) const;

  void OnSetAdoptedStyleSheets(StyleSheet&, uint32_t aIndex, ErrorResult&);
  void OnDeleteAdoptedStyleSheets(StyleSheet&, uint32_t aIndex, ErrorResult&);

  // This is needed because ServoStyleSet / ServoAuthorData don't deal with
  // duplicate stylesheets (and it's unclear we'd want to support that as it'd
  // be a bunch of duplicate work), while adopted stylesheets do need to deal
  // with them.
  template <typename Callback>
  void EnumerateUniqueAdoptedStyleSheetsBackToFront(Callback aCallback) {
    StyleSheetSet set(mAdoptedStyleSheets.Length());
    for (StyleSheet* sheet : Reversed(mAdoptedStyleSheets)) {
      if (MOZ_UNLIKELY(!set.EnsureInserted(sheet))) {
        continue;
      }
      aCallback(*sheet);
    }
  }

 protected:
  // Cycle collection helper functions
  void TraverseSheetRefInStylesIfApplicable(
      StyleSheet&, nsCycleCollectionTraversalCallback&);
  void TraverseStyleSheets(nsTArray<RefPtr<StyleSheet>>&, const char*,
                           nsCycleCollectionTraversalCallback&);
  void UnlinkStyleSheets(nsTArray<RefPtr<StyleSheet>>&);

  using StyleSheetSet = nsTHashSet<const StyleSheet*>;
  void RemoveSheetFromStylesIfApplicable(StyleSheet&);
  void ClearAdoptedStyleSheets();

  /**
   * Clone's the argument's adopted style sheets into this.
   * This should only be used when cloning a static document for printing.
   */
  void CloneAdoptedSheetsFrom(const DocumentOrShadowRoot&);

  void InsertSheetAt(size_t aIndex, StyleSheet& aSheet);

  void AddSizeOfExcludingThis(nsWindowSizes&) const;
  void AddSizeOfOwnedSheetArrayExcludingThis(
      nsWindowSizes&, const nsTArray<RefPtr<StyleSheet>>&) const;

  /**
   * If focused element's subtree root is this document or shadow root, return
   * focused element, otherwise, get the shadow host recursively until the
   * shadow host's subtree root is this document or shadow root.
   */
  Element* GetRetargetedFocusedElement();

  nsTArray<RefPtr<StyleSheet>> mStyleSheets;
  RefPtr<StyleSheetList> mDOMStyleSheets;

  /**
   * Style sheets that are adopted by assinging to the `adoptedStyleSheets`
   * WebIDL atribute. These can only be constructed stylesheets.
   */
  nsTArray<RefPtr<StyleSheet>> mAdoptedStyleSheets;

  /*
   * mIdentifierMap works as follows for IDs:
   * 1) Attribute changes affect the table immediately (removing and adding
   *    entries as needed).
   * 2) Removals from the DOM affect the table immediately
   * 3) Additions to the DOM always update existing entries for names, and add
   *    new ones for IDs.
   */
  nsTHashtable<IdentifierMapEntry> mIdentifierMap;

  // Always non-null, see comment in the constructor as to why a pointer instead
  // of a reference.
  nsINode* mAsNode;
  const Kind mKind;
};

}  // namespace dom

}  // namespace mozilla

#endif
