/**
   * Return the Nth immediate child of this node, or null if the index is out of bounds. Use to
   * implement NodeList.item().
   *
   * @param index int
   */
  private Node nodeListItem(int index) {

    if (fNodeListCache == null) {
      // get rid of trivial case
      if (firstChild == lastChild()) {
        return index == 0 ? firstChild : null;
      }
      // otherwise request a cache object
      fNodeListCache = ownerDocument.getNodeListCache(this);
    }
    int i = fNodeListCache.fChildIndex;
    ChildNode n = fNodeListCache.fChild;
    boolean firstAccess = true;
    // short way
    if (i != -1 && n != null) {
      firstAccess = false;
      if (i < index) {
        while (i < index && n != null) {
          i++;
          n = n.nextSibling;
        }
      } else if (i > index) {
        while (i > index && n != null) {
          i--;
          n = n.previousSibling();
        }
      }
    } else {
      // long way
      if (index < 0) {
        return null;
      }
      n = firstChild;
      for (i = 0; i < index && n != null; i++) {
        n = n.nextSibling;
      }
    }

    // release cache if reaching last child or first child
    if (!firstAccess && (n == firstChild || n == lastChild())) {
      fNodeListCache.fChildIndex = -1;
      fNodeListCache.fChild = null;
      ownerDocument.freeNodeListCache(fNodeListCache);
      // we can keep using the cache until it is actually reused
      // fNodeListCache will be nulled by the pool (document) if that
      // happens.
      // fNodeListCache = null;
    } else {
      // otherwise update it
      fNodeListCache.fChildIndex = i;
      fNodeListCache.fChild = n;
    }
    return n;
  } // nodeListItem(int):Node
  /**
   * Count the immediate children of this node. Use to implement NodeList.getLength().
   *
   * @return int
   */
  private int nodeListGetLength() {

    if (fNodeListCache == null) {
      // get rid of trivial cases
      if (firstChild == null) {
        return 0;
      }
      if (firstChild == lastChild()) {
        return 1;
      }
      // otherwise request a cache object
      fNodeListCache = ownerDocument.getNodeListCache(this);
    }
    if (fNodeListCache.fLength == -1) { // is the cached length invalid ?
      int l;
      ChildNode n;
      // start from the cached node if we have one
      if (fNodeListCache.fChildIndex != -1 && fNodeListCache.fChild != null) {
        l = fNodeListCache.fChildIndex;
        n = fNodeListCache.fChild;
      } else {
        n = firstChild;
        l = 0;
      }
      while (n != null) {
        l++;
        n = n.nextSibling;
      }
      fNodeListCache.fLength = l;
    }

    return fNodeListCache.fLength;
  } // nodeListGetLength():int
  /**
   * Make newChild occupy the location that oldChild used to have. Note that newChild will first be
   * removed from its previous parent, if any. Equivalent to inserting newChild before oldChild,
   * then removing oldChild.
   *
   * @return oldChild, in its new state (removed).
   * @throws DOMException(HIERARCHY_REQUEST_ERR) if newChild is of a type that shouldn't be a child
   *     of this node, or if newChild is one of our ancestors.
   * @throws DOMException(WRONG_DOCUMENT_ERR) if newChild has a different owner document than we do.
   * @throws DOMException(NOT_FOUND_ERR) if oldChild is not a child of this node.
   * @throws DOMException(NO_MODIFICATION_ALLOWED_ERR) if this node is read-only.
   */
  public Node replaceChild(Node newChild, Node oldChild) throws DOMException {
    // If Mutation Events are being generated, this operation might
    // throw aggregate events twice when modifying an Attr -- once
    // on insertion and once on removal. DOM Level 2 does not specify
    // this as either desirable or undesirable, but hints that
    // aggregations should be issued only once per user request.

    // notify document
    ownerDocument.replacingNode(this);

    internalInsertBefore(newChild, oldChild, true);
    if (newChild != oldChild) {
      internalRemoveChild(oldChild, true);
    }

    // notify document
    ownerDocument.replacedNode(this);

    return oldChild;
  }
  /**
   * NON-DOM INTERNAL: Within DOM actions,we sometimes need to be able to control which mutation
   * events are spawned. This version of the removeChild operation allows us to do so. It is not
   * intended for use by application programs.
   */
  Node internalRemoveChild(Node oldChild, boolean replace) throws DOMException {

    CoreDocumentImpl ownerDocument = ownerDocument();
    if (ownerDocument.errorChecking) {
      if (isReadOnly()) {
        throw new DOMException(
            DOMException.NO_MODIFICATION_ALLOWED_ERR,
            DOMMessageFormatter.formatMessage(
                DOMMessageFormatter.DOM_DOMAIN, "NO_MODIFICATION_ALLOWED_ERR", null));
      }
      if (oldChild != null && oldChild.getParentNode() != this) {
        throw new DOMException(
            DOMException.NOT_FOUND_ERR,
            DOMMessageFormatter.formatMessage(
                DOMMessageFormatter.DOM_DOMAIN, "NOT_FOUND_ERR", null));
      }
    }

    ChildNode oldInternal = (ChildNode) oldChild;

    // notify document
    ownerDocument.removingNode(this, oldInternal, replace);

    // update cached length if we have any
    if (fNodeListCache != null) {
      if (fNodeListCache.fLength != -1) {
        fNodeListCache.fLength--;
      }
      if (fNodeListCache.fChildIndex != -1) {
        // if the removed node is the cached node
        // move the cache to its (soon former) previous sibling
        if (fNodeListCache.fChild == oldInternal) {
          fNodeListCache.fChildIndex--;
          fNodeListCache.fChild = oldInternal.previousSibling();
        } else {
          // otherwise just invalidate the cache
          fNodeListCache.fChildIndex = -1;
        }
      }
    }

    // Patch linked list around oldChild
    // Note: lastChild == firstChild.previousSibling
    if (oldInternal == firstChild) {
      // removing first child
      oldInternal.isFirstChild(false);
      firstChild = oldInternal.nextSibling;
      if (firstChild != null) {
        firstChild.isFirstChild(true);
        firstChild.previousSibling = oldInternal.previousSibling;
      }
    } else {
      ChildNode prev = oldInternal.previousSibling;
      ChildNode next = oldInternal.nextSibling;
      prev.nextSibling = next;
      if (next == null) {
        // removing last child
        firstChild.previousSibling = prev;
      } else {
        // removing some other child in the middle
        next.previousSibling = prev;
      }
    }

    // Save previous sibling for normalization checking.
    ChildNode oldPreviousSibling = oldInternal.previousSibling();

    // Remove oldInternal's references to tree
    oldInternal.ownerNode = ownerDocument;
    oldInternal.isOwned(false);
    oldInternal.nextSibling = null;
    oldInternal.previousSibling = null;

    changed();

    // notify document
    ownerDocument.removedNode(this, replace);

    checkNormalizationAfterRemove(oldPreviousSibling);

    return oldInternal;
  } // internalRemoveChild(Node,boolean):Node
  /**
   * NON-DOM INTERNAL: Within DOM actions,we sometimes need to be able to control which mutation
   * events are spawned. This version of the insertBefore operation allows us to do so. It is not
   * intended for use by application programs.
   */
  Node internalInsertBefore(Node newChild, Node refChild, boolean replace) throws DOMException {

    boolean errorChecking = ownerDocument.errorChecking;

    if (newChild.getNodeType() == Node.DOCUMENT_FRAGMENT_NODE) {
      // SLOW BUT SAFE: We could insert the whole subtree without
      // juggling so many next/previous pointers. (Wipe out the
      // parent's child-list, patch the parent pointers, set the
      // ends of the list.) But we know some subclasses have special-
      // case behavior they add to insertBefore(), so we don't risk it.
      // This approch also takes fewer bytecodes.

      // NOTE: If one of the children is not a legal child of this
      // node, throw HIERARCHY_REQUEST_ERR before _any_ of the children
      // have been transferred. (Alternative behaviors would be to
      // reparent up to the first failure point or reparent all those
      // which are acceptable to the target node, neither of which is
      // as robust. PR-DOM-0818 isn't entirely clear on which it
      // recommends?????

      // No need to check kids for right-document; if they weren't,
      // they wouldn't be kids of that DocFrag.
      if (errorChecking) {
        for (Node kid = newChild.getFirstChild(); // Prescan
            kid != null;
            kid = kid.getNextSibling()) {

          if (!ownerDocument.isKidOK(this, kid)) {
            throw new DOMException(
                DOMException.HIERARCHY_REQUEST_ERR,
                DOMMessageFormatter.formatMessage(
                    DOMMessageFormatter.DOM_DOMAIN, "HIERARCHY_REQUEST_ERR", null));
          }
        }
      }

      while (newChild.hasChildNodes()) {
        insertBefore(newChild.getFirstChild(), refChild);
      }
      return newChild;
    }

    if (newChild == refChild) {
      // stupid case that must be handled as a no-op triggering events...
      refChild = refChild.getNextSibling();
      removeChild(newChild);
      insertBefore(newChild, refChild);
      return newChild;
    }

    if (needsSyncChildren()) {
      synchronizeChildren();
    }

    if (errorChecking) {
      if (isReadOnly()) {
        throw new DOMException(
            DOMException.NO_MODIFICATION_ALLOWED_ERR,
            DOMMessageFormatter.formatMessage(
                DOMMessageFormatter.DOM_DOMAIN, "NO_MODIFICATION_ALLOWED_ERR", null));
      }
      if (newChild.getOwnerDocument() != ownerDocument && newChild != ownerDocument) {
        throw new DOMException(
            DOMException.WRONG_DOCUMENT_ERR,
            DOMMessageFormatter.formatMessage(
                DOMMessageFormatter.DOM_DOMAIN, "WRONG_DOCUMENT_ERR", null));
      }
      if (!ownerDocument.isKidOK(this, newChild)) {
        throw new DOMException(
            DOMException.HIERARCHY_REQUEST_ERR,
            DOMMessageFormatter.formatMessage(
                DOMMessageFormatter.DOM_DOMAIN, "HIERARCHY_REQUEST_ERR", null));
      }
      // refChild must be a child of this node (or null)
      if (refChild != null && refChild.getParentNode() != this) {
        throw new DOMException(
            DOMException.NOT_FOUND_ERR,
            DOMMessageFormatter.formatMessage(
                DOMMessageFormatter.DOM_DOMAIN, "NOT_FOUND_ERR", null));
      }

      // Prevent cycles in the tree
      // newChild cannot be ancestor of this Node,
      // and actually cannot be this
      if (ownerDocument.ancestorChecking) {
        boolean treeSafe = true;
        for (NodeImpl a = this; treeSafe && a != null; a = a.parentNode()) {
          treeSafe = newChild != a;
        }
        if (!treeSafe) {
          throw new DOMException(
              DOMException.HIERARCHY_REQUEST_ERR,
              DOMMessageFormatter.formatMessage(
                  DOMMessageFormatter.DOM_DOMAIN, "HIERARCHY_REQUEST_ERR", null));
        }
      }
    }

    // notify document
    ownerDocument.insertingNode(this, replace);

    // Convert to internal type, to avoid repeated casting
    ChildNode newInternal = (ChildNode) newChild;

    Node oldparent = newInternal.parentNode();
    if (oldparent != null) {
      oldparent.removeChild(newInternal);
    }

    // Convert to internal type, to avoid repeated casting
    ChildNode refInternal = (ChildNode) refChild;

    // Attach up
    newInternal.ownerNode = this;
    newInternal.isOwned(true);

    // Attach before and after
    // Note: firstChild.previousSibling == lastChild!!
    if (firstChild == null) {
      // this our first and only child
      firstChild = newInternal;
      newInternal.isFirstChild(true);
      newInternal.previousSibling = newInternal;
    } else {
      if (refInternal == null) {
        // this is an append
        ChildNode lastChild = firstChild.previousSibling;
        lastChild.nextSibling = newInternal;
        newInternal.previousSibling = lastChild;
        firstChild.previousSibling = newInternal;
      } else {
        // this is an insert
        if (refChild == firstChild) {
          // at the head of the list
          firstChild.isFirstChild(false);
          newInternal.nextSibling = firstChild;
          newInternal.previousSibling = firstChild.previousSibling;
          firstChild.previousSibling = newInternal;
          firstChild = newInternal;
          newInternal.isFirstChild(true);
        } else {
          // somewhere in the middle
          ChildNode prev = refInternal.previousSibling;
          newInternal.nextSibling = refInternal;
          prev.nextSibling = newInternal;
          refInternal.previousSibling = newInternal;
          newInternal.previousSibling = prev;
        }
      }
    }

    changed();

    // update cached length if we have any
    if (fNodeListCache != null) {
      if (fNodeListCache.fLength != -1) {
        fNodeListCache.fLength++;
      }
      if (fNodeListCache.fChildIndex != -1) {
        // if we happen to insert just before the cached node, update
        // the cache to the new node to match the cached index
        if (fNodeListCache.fChild == refInternal) {
          fNodeListCache.fChild = newInternal;
        } else {
          // otherwise just invalidate the cache
          fNodeListCache.fChildIndex = -1;
        }
      }
    }

    // notify document
    ownerDocument.insertedNode(this, newInternal, replace);

    checkNormalizationAfterInsert(newInternal);

    return newChild;
  } // internalInsertBefore(Node,Node,boolean):Node