/* 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 https://mozilla.org/MPL/2.0/. */

//! Traits that nodes must implement. Breaks the otherwise-cyclic dependency
//! between layout and style.

use crate::attr::{AttrSelectorOperation, CaseSensitivity, NamespaceConstraint};
use crate::matching::{ElementSelectorFlags, MatchingContext};
use crate::parser::SelectorImpl;
use std::fmt::Debug;
use std::ptr::NonNull;

/// Opaque representation of an Element, for identity comparisons.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct OpaqueElement(NonNull<()>);

unsafe impl Send for OpaqueElement {}

impl OpaqueElement {
  /// Creates a new OpaqueElement from an arbitrarily-typed pointer.
  pub fn new<T>(ptr: &T) -> Self {
    unsafe { OpaqueElement(NonNull::new_unchecked(ptr as *const T as *const () as *mut ())) }
  }
}

pub trait Element<'i>: Sized + Clone + Debug {
  type Impl: SelectorImpl<'i>;

  /// Converts self into an opaque representation.
  fn opaque(&self) -> OpaqueElement;

  fn parent_element(&self) -> Option<Self>;

  /// Whether the parent node of this element is a shadow root.
  fn parent_node_is_shadow_root(&self) -> bool;

  /// The host of the containing shadow root, if any.
  fn containing_shadow_host(&self) -> Option<Self>;

  /// The parent of a given pseudo-element, after matching a pseudo-element
  /// selector.
  ///
  /// This is guaranteed to be called in a pseudo-element.
  fn pseudo_element_originating_element(&self) -> Option<Self> {
    debug_assert!(self.is_pseudo_element());
    self.parent_element()
  }

  /// Whether we're matching on a pseudo-element.
  fn is_pseudo_element(&self) -> bool;

  /// Skips non-element nodes
  fn prev_sibling_element(&self) -> Option<Self>;

  /// Skips non-element nodes
  fn next_sibling_element(&self) -> Option<Self>;

  fn is_html_element_in_html_document(&self) -> bool;

  fn has_local_name(&self, local_name: &<Self::Impl as SelectorImpl<'i>>::BorrowedLocalName) -> bool;

  /// Empty string for no namespace
  fn has_namespace(&self, ns: &<Self::Impl as SelectorImpl<'i>>::BorrowedNamespaceUrl) -> bool;

  /// Whether this element and the `other` element have the same local name and namespace.
  fn is_same_type(&self, other: &Self) -> bool;

  fn attr_matches(
    &self,
    ns: &NamespaceConstraint<&<Self::Impl as SelectorImpl<'i>>::NamespaceUrl>,
    local_name: &<Self::Impl as SelectorImpl<'i>>::LocalName,
    operation: &AttrSelectorOperation<&<Self::Impl as SelectorImpl<'i>>::AttrValue>,
  ) -> bool;

  fn match_non_ts_pseudo_class<F>(
    &self,
    pc: &<Self::Impl as SelectorImpl<'i>>::NonTSPseudoClass,
    context: &mut MatchingContext<'_, 'i, Self::Impl>,
    flags_setter: &mut F,
  ) -> bool
  where
    F: FnMut(&Self, ElementSelectorFlags);

  fn match_pseudo_element(
    &self,
    pe: &<Self::Impl as SelectorImpl<'i>>::PseudoElement,
    context: &mut MatchingContext<'_, 'i, Self::Impl>,
  ) -> bool;

  /// Whether this element is a `link`.
  fn is_link(&self) -> bool;

  /// Returns whether the element is an HTML <slot> element.
  fn is_html_slot_element(&self) -> bool;

  /// Returns the assigned <slot> element this element is assigned to.
  ///
  /// Necessary for the `::slotted` pseudo-class.
  fn assigned_slot(&self) -> Option<Self> {
    None
  }

  fn has_id(&self, id: &<Self::Impl as SelectorImpl<'i>>::Identifier, case_sensitivity: CaseSensitivity) -> bool;

  fn has_class(
    &self,
    name: &<Self::Impl as SelectorImpl<'i>>::Identifier,
    case_sensitivity: CaseSensitivity,
  ) -> bool;

  /// Returns the mapping from the `exportparts` attribute in the reverse
  /// direction, that is, in an outer-tree -> inner-tree direction.
  fn imported_part(
    &self,
    name: &<Self::Impl as SelectorImpl<'i>>::Identifier,
  ) -> Option<<Self::Impl as SelectorImpl<'i>>::Identifier>;

  fn is_part(&self, name: &<Self::Impl as SelectorImpl<'i>>::Identifier) -> bool;

  /// Returns whether this element matches `:empty`.
  ///
  /// That is, whether it does not contain any child element or any non-zero-length text node.
  /// See http://dev.w3.org/csswg/selectors-3/#empty-pseudo
  fn is_empty(&self) -> bool;

  /// Returns whether this element matches `:root`,
  /// i.e. whether it is the root element of a document.
  ///
  /// Note: this can be false even if `.parent_element()` is `None`
  /// if the parent node is a `DocumentFragment`.
  fn is_root(&self) -> bool;

  /// Returns whether this element should ignore matching nth child
  /// selector.
  fn ignores_nth_child_selectors(&self) -> bool {
    false
  }
}