/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */

#include "SelectionState.h"

#include "AutoRangeArray.h"  // for AutoRangeArray
#include "EditorUtils.h"     // for EditorUtils, AutoRangeArray
#include "ErrorList.h"
#include "JoinSplitNodeDirection.h"  // for JoinNodesDirection, SplitNodeDirection

#include "mozilla/Assertions.h"    // for MOZ_ASSERT, etc.
#include "mozilla/IntegerRange.h"  // for IntegerRange
#include "mozilla/Likely.h"        // For MOZ_LIKELY and MOZ_UNLIKELY
#include "mozilla/RangeUtils.h"    // for RangeUtils
#include "mozilla/dom/RangeBinding.h"
#include "mozilla/dom/Selection.h"  // for Selection
#include "nsAString.h"              // for nsAString::Length
#include "nsCycleCollectionParticipant.h"
#include "nsDebug.h"          // for NS_WARNING, etc.
#include "nsError.h"          // for NS_OK, etc.
#include "nsIContent.h"       // for nsIContent
#include "nsISupportsImpl.h"  // for nsRange::Release
#include "nsRange.h"          // for nsRange

namespace mozilla {

using namespace dom;

/*****************************************************************************
 * mozilla::RangeItem
 *****************************************************************************/

nsINode* RangeItem::GetRoot() const {
  if (MOZ_UNLIKELY(!IsPositioned())) {
    return nullptr;
  }
  nsINode* rootNode = RangeUtils::ComputeRootNode(mStartContainer);
  if (mStartContainer == mEndContainer) {
    return rootNode;
  }
  return MOZ_LIKELY(rootNode == RangeUtils::ComputeRootNode(mEndContainer))
             ? rootNode
             : nullptr;
}

/******************************************************************************
 * mozilla::SelectionState
 *
 * Class for recording selection info.  Stores selection as collection of
 * { {startnode, startoffset} , {endnode, endoffset} } tuples.  Can't store
 * ranges since dom gravity will possibly change the ranges.
 ******************************************************************************/

template nsresult RangeUpdater::SelAdjCreateNode(const EditorDOMPoint& aPoint);
template nsresult RangeUpdater::SelAdjCreateNode(
    const EditorRawDOMPoint& aPoint);
template nsresult RangeUpdater::SelAdjInsertNode(const EditorDOMPoint& aPoint);
template nsresult RangeUpdater::SelAdjInsertNode(
    const EditorRawDOMPoint& aPoint);

SelectionState::SelectionState(const AutoRangeArray& aRanges)
    : mDirection(aRanges.GetDirection()) {
  mArray.SetCapacity(aRanges.Ranges().Length());
  for (const OwningNonNull<nsRange>& range : aRanges.Ranges()) {
    RefPtr<RangeItem> rangeItem = new RangeItem();
    rangeItem->StoreRange(range);
    mArray.AppendElement(std::move(rangeItem));
  }
}

void SelectionState::SaveSelection(Selection& aSelection) {
  // if we need more items in the array, new them
  if (mArray.Length() < aSelection.RangeCount()) {
    for (uint32_t i = mArray.Length(); i < aSelection.RangeCount(); i++) {
      mArray.AppendElement();
      mArray[i] = new RangeItem();
    }
  } else if (mArray.Length() > aSelection.RangeCount()) {
    // else if we have too many, delete them
    mArray.TruncateLength(aSelection.RangeCount());
  }

  // now store the selection ranges
  const uint32_t rangeCount = aSelection.RangeCount();
  for (const uint32_t i : IntegerRange(rangeCount)) {
    MOZ_ASSERT(aSelection.RangeCount() == rangeCount);
    const nsRange* range = aSelection.GetRangeAt(i);
    MOZ_ASSERT(range);
    if (MOZ_UNLIKELY(NS_WARN_IF(!range))) {
      continue;
    }
    mArray[i]->StoreRange(*range);
  }

  mDirection = aSelection.GetDirection();
}

nsresult SelectionState::RestoreSelection(Selection& aSelection) {
  // clear out selection
  IgnoredErrorResult ignoredError;
  aSelection.RemoveAllRanges(ignoredError);
  NS_WARNING_ASSERTION(!ignoredError.Failed(),
                       "Selection::RemoveAllRanges() failed, but ignored");

  aSelection.SetDirection(mDirection);

  ErrorResult error;
  const CopyableAutoTArray<RefPtr<RangeItem>, 10> rangeItems(mArray);
  for (const RefPtr<RangeItem>& rangeItem : rangeItems) {
    RefPtr<nsRange> range = rangeItem->GetRange();
    if (!range) {
      NS_WARNING("RangeItem::GetRange() failed");
      return NS_ERROR_FAILURE;
    }
    aSelection.AddRangeAndSelectFramesAndNotifyListeners(*range, error);
    if (error.Failed()) {
      NS_WARNING(
          "Selection::AddRangeAndSelectFramesAndNotifyListeners() failed");
      return error.StealNSResult();
    }
  }
  return NS_OK;
}

void SelectionState::ApplyTo(AutoRangeArray& aRanges) {
  aRanges.RemoveAllRanges();
  aRanges.SetDirection(mDirection);
  for (const RefPtr<RangeItem>& rangeItem : mArray) {
    RefPtr<nsRange> range = rangeItem->GetRange();
    if (MOZ_UNLIKELY(!range)) {
      continue;
    }
    aRanges.Ranges().AppendElement(std::move(range));
  }
}

bool SelectionState::Equals(const SelectionState& aOther) const {
  if (mArray.Length() != aOther.mArray.Length()) {
    return false;
  }
  if (mArray.IsEmpty()) {
    return false;  // XXX Why?
  }
  if (mDirection != aOther.mDirection) {
    return false;
  }

  for (uint32_t i : IntegerRange(mArray.Length())) {
    if (NS_WARN_IF(!mArray[i]) || NS_WARN_IF(!aOther.mArray[i]) ||
        !mArray[i]->Equals(*aOther.mArray[i])) {
      return false;
    }
  }
  // if we got here, they are equal
  return true;
}

/******************************************************************************
 * mozilla::RangeUpdater
 *
 * Class for updating nsRanges in response to editor actions.
 ******************************************************************************/

RangeUpdater::RangeUpdater() : mLocked(false) {}

void RangeUpdater::RegisterRangeItem(RangeItem& aRangeItem) {
  if (mArray.Contains(&aRangeItem)) {
    NS_ERROR("tried to register an already registered range");
    return;  // don't register it again.  It would get doubly adjusted.
  }
  mArray.AppendElement(&aRangeItem);
}

void RangeUpdater::DropRangeItem(RangeItem& aRangeItem) {
  NS_WARNING_ASSERTION(
      mArray.Contains(&aRangeItem),
      "aRangeItem is not in the range, but tried to removed from it");
  mArray.RemoveElement(&aRangeItem);
}

void RangeUpdater::RegisterSelectionState(SelectionState& aSelectionState) {
  for (RefPtr<RangeItem>& rangeItem : aSelectionState.mArray) {
    if (NS_WARN_IF(!rangeItem)) {
      continue;
    }
    RegisterRangeItem(*rangeItem);
  }
}

void RangeUpdater::DropSelectionState(SelectionState& aSelectionState) {
  for (RefPtr<RangeItem>& rangeItem : aSelectionState.mArray) {
    if (NS_WARN_IF(!rangeItem)) {
      continue;
    }
    DropRangeItem(*rangeItem);
  }
}

// gravity methods:

template <typename PT, typename CT>
nsresult RangeUpdater::SelAdjCreateNode(
    const EditorDOMPointBase<PT, CT>& aPoint) {
  if (mLocked) {
    // lock set by Will/DidReplaceParent, etc...
    return NS_OK;
  }
  if (mArray.IsEmpty()) {
    return NS_OK;
  }

  if (NS_WARN_IF(!aPoint.IsSetAndValid())) {
    return NS_ERROR_INVALID_ARG;
  }

  for (RefPtr<RangeItem>& rangeItem : mArray) {
    if (NS_WARN_IF(!rangeItem)) {
      return NS_ERROR_FAILURE;
    }
    if (rangeItem->mStartContainer == aPoint.GetContainer() &&
        rangeItem->mStartOffset > aPoint.Offset()) {
      rangeItem->mStartOffset++;
    }
    if (rangeItem->mEndContainer == aPoint.GetContainer() &&
        rangeItem->mEndOffset > aPoint.Offset()) {
      rangeItem->mEndOffset++;
    }
  }
  return NS_OK;
}

template <typename PT, typename CT>
nsresult RangeUpdater::SelAdjInsertNode(
    const EditorDOMPointBase<PT, CT>& aPoint) {
  nsresult rv = SelAdjCreateNode(aPoint);
  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
                       "RangeUpdater::SelAdjCreateNode() failed");
  return rv;
}

void RangeUpdater::SelAdjDeleteNode(nsINode& aNodeToDelete) {
  if (mLocked) {
    // lock set by Will/DidReplaceParent, etc...
    return;
  }

  if (mArray.IsEmpty()) {
    return;
  }

  EditorRawDOMPoint atNodeToDelete(&aNodeToDelete);
  NS_ASSERTION(atNodeToDelete.IsSetAndValid(),
               "aNodeToDelete must be an orphan node or this is called "
               "during mutation");
  // check for range endpoints that are after aNodeToDelete and in the same
  // parent
  for (RefPtr<RangeItem>& rangeItem : mArray) {
    MOZ_ASSERT(rangeItem);

    if (rangeItem->mStartContainer == atNodeToDelete.GetContainer() &&
        rangeItem->mStartOffset > atNodeToDelete.Offset()) {
      rangeItem->mStartOffset--;
    }
    if (rangeItem->mEndContainer == atNodeToDelete.GetContainer() &&
        rangeItem->mEndOffset > atNodeToDelete.Offset()) {
      rangeItem->mEndOffset--;
    }

    // check for range endpoints that are in aNodeToDelete
    if (rangeItem->mStartContainer == &aNodeToDelete) {
      rangeItem->mStartContainer = atNodeToDelete.GetContainer();
      rangeItem->mStartOffset = atNodeToDelete.Offset();
    }
    if (rangeItem->mEndContainer == &aNodeToDelete) {
      rangeItem->mEndContainer = atNodeToDelete.GetContainer();
      rangeItem->mEndOffset = atNodeToDelete.Offset();
    }

    // check for range endpoints that are in descendants of aNodeToDelete
    bool updateEndBoundaryToo = false;
    if (EditorUtils::IsDescendantOf(*rangeItem->mStartContainer,
                                    aNodeToDelete)) {
      updateEndBoundaryToo =
          rangeItem->mStartContainer == rangeItem->mEndContainer;
      rangeItem->mStartContainer = atNodeToDelete.GetContainer();
      rangeItem->mStartOffset = atNodeToDelete.Offset();
    }

    // avoid having to call IsDescendantOf() for common case of range startnode
    // == range endnode.
    if (updateEndBoundaryToo ||
        EditorUtils::IsDescendantOf(*rangeItem->mEndContainer, aNodeToDelete)) {
      rangeItem->mEndContainer = atNodeToDelete.GetContainer();
      rangeItem->mEndOffset = atNodeToDelete.Offset();
    }
  }
}

nsresult RangeUpdater::SelAdjSplitNode(nsIContent& aOriginalContent,
                                       uint32_t aSplitOffset,
                                       nsIContent& aNewContent,
                                       SplitNodeDirection aSplitNodeDirection) {
  if (mLocked) {
    // lock set by Will/DidReplaceParent, etc...
    return NS_OK;
  }

  if (mArray.IsEmpty()) {
    return NS_OK;
  }

  EditorRawDOMPoint atNewNode(&aNewContent);
  if (NS_WARN_IF(!atNewNode.IsSetAndValid())) {
    return NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE;
  }

  auto AdjustDOMPoint = [&](nsCOMPtr<nsINode>& aContainer,
                            uint32_t& aOffset) -> void {
    if (aContainer == atNewNode.GetContainer()) {
      if (aSplitNodeDirection == SplitNodeDirection::LeftNodeIsNewOne) {
        // When we create a left node, we insert it before the right node.
        // In this case,
        // - `{}<right/>` should become `{}<left/><right/>` (0 -> 0)
        // - `<right/>{}` should become `<left/><right/>{}` (1 -> 2)
        // - `{<right/>}` should become `{<left/><right/>}` (0 -> 0, 1 -> 2}
        // Therefore, we need to increate the offset only when the offset is
        // larger than the offset at the left node.
        if (aOffset > atNewNode.Offset()) {
          aOffset++;
        }
      } else {
        // When we create a right node, we insert it after the left node.
        // In this case,
        // - `{}<left/>` should become `{}<left/><right/>` (0 -> 0)
        // - `<left/>{}` should become `<left/><right/>{}` (1 -> 2)
        // - `{<left/>}` should become `{<left/><right/>}` (0 -> 0, 1 -> 2}
        // Therefore, we need to increate the offset only when the offset equals
        // or is larger than the offset at the right node.
        if (aOffset >= atNewNode.Offset()) {
          aOffset++;
        }
      }
    }
    // If point is in the range which are moved from aOriginalContent to
    // aNewContent, we need to change its container to aNewContent and may need
    // to adjust the offset. If point is in the range which are not moved from
    // aOriginalContent, we may need to adjust the offset.
    if (aContainer != &aOriginalContent) {
      return;
    }
    if (aSplitNodeDirection == SplitNodeDirection::LeftNodeIsNewOne) {
      if (aOffset > aSplitOffset) {
        aOffset -= aSplitOffset;
      } else {
        aContainer = &aNewContent;
      }
    } else if (aOffset >= aSplitOffset) {
      aContainer = &aNewContent;
      aOffset -= aSplitOffset;
    }
  };

  for (RefPtr<RangeItem>& rangeItem : mArray) {
    if (NS_WARN_IF(!rangeItem)) {
      return NS_ERROR_FAILURE;
    }
    AdjustDOMPoint(rangeItem->mStartContainer, rangeItem->mStartOffset);
    AdjustDOMPoint(rangeItem->mEndContainer, rangeItem->mEndOffset);
  }
  return NS_OK;
}

nsresult RangeUpdater::SelAdjJoinNodes(
    const EditorRawDOMPoint& aStartOfRightContent,
    const nsIContent& aRemovedContent,
    const EditorDOMPoint& aOldPointAtRightContent,
    JoinNodesDirection aJoinNodesDirection) {
  MOZ_ASSERT(aStartOfRightContent.IsSetAndValid());
  MOZ_ASSERT(aOldPointAtRightContent.IsSet());  // Invalid point in most cases
  MOZ_ASSERT(aOldPointAtRightContent.HasOffset());

  if (mLocked) {
    // lock set by Will/DidReplaceParent, etc...
    return NS_OK;
  }

  if (mArray.IsEmpty()) {
    return NS_OK;
  }

  auto AdjustDOMPoint = [&](nsCOMPtr<nsINode>& aContainer,
                            uint32_t& aOffset) -> void {
    // FYI: Typically, containers of aOldPointAtRightContent and
    //      aStartOfRightContent are same.  They are different when one of the
    //      node was moved to somewhere and they are joined by undoing splitting
    //      a node.
    if (aContainer == &aRemovedContent) {
      // If the point is in the removed content, move the point to the new
      // point in the joined node.  If left node content is moved into
      // right node, the offset should be same.  Otherwise, we need to advance
      // the offset to length of the removed content.
      aContainer = aStartOfRightContent.GetContainer();
      if (aJoinNodesDirection == JoinNodesDirection::RightNodeIntoLeftNode) {
        aOffset += aStartOfRightContent.Offset();
      }
    }
    // TODO: If aOldPointAtRightContent.GetContainer() was in aRemovedContent,
    //       we fail to adjust container and offset here because we need to
    //       make point to where aRemoveContent was.  However, collecting all
    //       ancestors of the right content may be expensive.  What's the best
    //       approach to fix this?
    else if (aContainer == aOldPointAtRightContent.GetContainer()) {
      // If the point is in common parent of joined content nodes and it
      // pointed after the right content node, decrease the offset.
      if (aOffset > aOldPointAtRightContent.Offset()) {
        aOffset--;
      }
      // If it pointed the right content node, adjust it to point ex-first
      // content of the right node.
      else if (aOffset == aOldPointAtRightContent.Offset()) {
        aContainer = aStartOfRightContent.GetContainer();
        aOffset = aStartOfRightContent.Offset();
      }
    } else if (aContainer == aStartOfRightContent.GetContainer()) {
      // If the point is in joined node, and removed content is moved to
      // start of the joined node, we need to adjust the offset.
      if (aJoinNodesDirection == JoinNodesDirection::LeftNodeIntoRightNode) {
        aOffset += aStartOfRightContent.Offset();
      }
    }
  };

  for (RefPtr<RangeItem>& rangeItem : mArray) {
    if (NS_WARN_IF(!rangeItem)) {
      return NS_ERROR_FAILURE;
    }
    AdjustDOMPoint(rangeItem->mStartContainer, rangeItem->mStartOffset);
    AdjustDOMPoint(rangeItem->mEndContainer, rangeItem->mEndOffset);
  }

  return NS_OK;
}

void RangeUpdater::SelAdjReplaceText(const Text& aTextNode, uint32_t aOffset,
                                     uint32_t aReplacedLength,
                                     uint32_t aInsertedLength) {
  if (mLocked) {
    // lock set by Will/DidReplaceParent, etc...
    return;
  }

  // First, adjust selection for insertion because when offset is in the
  // replaced range, it's adjusted to aOffset and never modified by the
  // insertion if we adjust selection for deletion first.
  SelAdjInsertText(aTextNode, aOffset, aInsertedLength);

  // Then, adjust selection for deletion.
  SelAdjDeleteText(aTextNode, aOffset, aReplacedLength);
}

void RangeUpdater::SelAdjInsertText(const Text& aTextNode, uint32_t aOffset,
                                    uint32_t aInsertedLength) {
  if (mLocked) {
    // lock set by Will/DidReplaceParent, etc...
    return;
  }

  for (RefPtr<RangeItem>& rangeItem : mArray) {
    MOZ_ASSERT(rangeItem);

    if (rangeItem->mStartContainer == &aTextNode &&
        rangeItem->mStartOffset > aOffset) {
      rangeItem->mStartOffset += aInsertedLength;
    }
    if (rangeItem->mEndContainer == &aTextNode &&
        rangeItem->mEndOffset > aOffset) {
      rangeItem->mEndOffset += aInsertedLength;
    }
  }
}

void RangeUpdater::SelAdjDeleteText(const Text& aTextNode, uint32_t aOffset,
                                    uint32_t aDeletedLength) {
  if (mLocked) {
    // lock set by Will/DidReplaceParent, etc...
    return;
  }

  for (RefPtr<RangeItem>& rangeItem : mArray) {
    MOZ_ASSERT(rangeItem);

    if (rangeItem->mStartContainer == &aTextNode &&
        rangeItem->mStartOffset > aOffset) {
      if (rangeItem->mStartOffset >= aDeletedLength) {
        rangeItem->mStartOffset -= aDeletedLength;
      } else {
        rangeItem->mStartOffset = 0;
      }
    }
    if (rangeItem->mEndContainer == &aTextNode &&
        rangeItem->mEndOffset > aOffset) {
      if (rangeItem->mEndOffset >= aDeletedLength) {
        rangeItem->mEndOffset -= aDeletedLength;
      } else {
        rangeItem->mEndOffset = 0;
      }
    }
  }
}

void RangeUpdater::DidReplaceContainer(const Element& aRemovedElement,
                                       Element& aInsertedElement) {
  if (NS_WARN_IF(!mLocked)) {
    return;
  }
  mLocked = false;

  for (RefPtr<RangeItem>& rangeItem : mArray) {
    if (NS_WARN_IF(!rangeItem)) {
      return;
    }

    if (rangeItem->mStartContainer == &aRemovedElement) {
      rangeItem->mStartContainer = &aInsertedElement;
    }
    if (rangeItem->mEndContainer == &aRemovedElement) {
      rangeItem->mEndContainer = &aInsertedElement;
    }
  }
}

void RangeUpdater::DidRemoveContainer(const Element& aRemovedElement,
                                      nsINode& aRemovedElementContainerNode,
                                      uint32_t aOldOffsetOfRemovedElement,
                                      uint32_t aOldChildCountOfRemovedElement) {
  if (NS_WARN_IF(!mLocked)) {
    return;
  }
  mLocked = false;

  for (RefPtr<RangeItem>& rangeItem : mArray) {
    if (NS_WARN_IF(!rangeItem)) {
      return;
    }

    if (rangeItem->mStartContainer == &aRemovedElement) {
      rangeItem->mStartContainer = &aRemovedElementContainerNode;
      rangeItem->mStartOffset += aOldOffsetOfRemovedElement;
    } else if (rangeItem->mStartContainer == &aRemovedElementContainerNode &&
               rangeItem->mStartOffset > aOldOffsetOfRemovedElement) {
      rangeItem->mStartOffset += aOldChildCountOfRemovedElement - 1;
    }

    if (rangeItem->mEndContainer == &aRemovedElement) {
      rangeItem->mEndContainer = &aRemovedElementContainerNode;
      rangeItem->mEndOffset += aOldOffsetOfRemovedElement;
    } else if (rangeItem->mEndContainer == &aRemovedElementContainerNode &&
               rangeItem->mEndOffset > aOldOffsetOfRemovedElement) {
      rangeItem->mEndOffset += aOldChildCountOfRemovedElement - 1;
    }
  }
}

void RangeUpdater::DidMoveNode(const nsINode& aOldParent, uint32_t aOldOffset,
                               const nsINode& aNewParent, uint32_t aNewOffset) {
  if (mLocked) {
    // Do nothing if moving nodes is occurred while changing the container.
    return;
  }
  auto AdjustDOMPoint = [&](nsCOMPtr<nsINode>& aNode, uint32_t& aOffset) {
    if (aNode == &aOldParent) {
      // If previously pointed the moved content, it should keep pointing it.
      if (aOffset == aOldOffset) {
        aNode = const_cast<nsINode*>(&aNewParent);
        aOffset = aNewOffset;
      } else if (aOffset > aOldOffset) {
        aOffset--;
      }
      return;
    }
    if (aNode == &aNewParent) {
      if (aOffset > aNewOffset) {
        aOffset++;
      }
    }
  };
  for (RefPtr<RangeItem>& rangeItem : mArray) {
    if (NS_WARN_IF(!rangeItem)) {
      return;
    }

    AdjustDOMPoint(rangeItem->mStartContainer, rangeItem->mStartOffset);
    AdjustDOMPoint(rangeItem->mEndContainer, rangeItem->mEndOffset);
  }
}

/******************************************************************************
 * mozilla::RangeItem
 *
 * Helper struct for SelectionState.  This stores range endpoints.
 ******************************************************************************/

NS_IMPL_CYCLE_COLLECTION(RangeItem, mStartContainer, mEndContainer)

void RangeItem::StoreRange(const nsRange& aRange) {
  mStartContainer = aRange.GetStartContainer();
  mStartOffset = aRange.StartOffset();
  mEndContainer = aRange.GetEndContainer();
  mEndOffset = aRange.EndOffset();
}

already_AddRefed<nsRange> RangeItem::GetRange() const {
  RefPtr<nsRange> range = nsRange::Create(
      mStartContainer, mStartOffset, mEndContainer, mEndOffset, IgnoreErrors());
  NS_WARNING_ASSERTION(range, "nsRange::Create() failed");
  return range.forget();
}

}  // namespace mozilla