/*
 * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
 * Copyright (C) 2010 Google Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "third_party/blink/renderer/core/editing/commands/apply_block_element_command.h"

#include "third_party/blink/renderer/core/dom/node_computed_style.h"
#include "third_party/blink/renderer/core/dom/text.h"
#include "third_party/blink/renderer/core/editing/commands/editing_commands_utilities.h"
#include "third_party/blink/renderer/core/editing/editing_utilities.h"
#include "third_party/blink/renderer/core/editing/selection_template.h"
#include "third_party/blink/renderer/core/editing/visible_position.h"
#include "third_party/blink/renderer/core/editing/visible_selection.h"
#include "third_party/blink/renderer/core/editing/visible_units.h"
#include "third_party/blink/renderer/core/html/html_br_element.h"
#include "third_party/blink/renderer/core/html/html_element.h"
#include "third_party/blink/renderer/core/html_names.h"
#include "third_party/blink/renderer/core/style/computed_style.h"
#include "third_party/blink/renderer/platform/bindings/exception_state.h"
#include "third_party/blink/renderer/platform/heap/heap.h"

namespace blink {

ApplyBlockElementCommand::ApplyBlockElementCommand(
    Document& document,
    const QualifiedName& tag_name,
    const AtomicString& inline_style)
    : CompositeEditCommand(document),
      tag_name_(tag_name),
      inline_style_(inline_style) {}

ApplyBlockElementCommand::ApplyBlockElementCommand(
    Document& document,
    const QualifiedName& tag_name)
    : CompositeEditCommand(document), tag_name_(tag_name) {}

void ApplyBlockElementCommand::DoApply(EditingState* editing_state) {
  // ApplyBlockElementCommands are only created directly by editor commands'
  // execution, which updates layout before entering doApply().
  DCHECK(!GetDocument().NeedsLayoutTreeUpdate());

  if (!RootEditableElementOf(EndingSelection().Base()))
    return;

  VisiblePosition visible_end = EndingVisibleSelection().VisibleEnd();
  VisiblePosition visible_start = EndingVisibleSelection().VisibleStart();
  if (visible_start.IsNull() || visible_start.IsOrphan() ||
      visible_end.IsNull() || visible_end.IsOrphan())
    return;

  // When a selection ends at the start of a paragraph, we rarely paint
  // the selection gap before that paragraph, because there often is no gap.
  // In a case like this, it's not obvious to the user that the selection
  // ends "inside" that paragraph, so it would be confusing if Indent/Outdent
  // operated on that paragraph.
  // FIXME: We paint the gap before some paragraphs that are indented with left
  // margin/padding, but not others.  We should make the gap painting more
  // consistent and then use a left margin/padding rule here.
  if (visible_end.DeepEquivalent() != visible_start.DeepEquivalent() &&
      IsStartOfParagraph(visible_end)) {
    const Position& new_end =
        PreviousPositionOf(visible_end, kCannotCrossEditingBoundary)
            .DeepEquivalent();
    SelectionInDOMTree::Builder builder;
    builder.Collapse(visible_start.ToPositionWithAffinity());
    if (new_end.IsNotNull())
      builder.Extend(new_end);
    SetEndingSelection(SelectionForUndoStep::From(builder.Build()));
    ABORT_EDITING_COMMAND_IF(EndingVisibleSelection().VisibleStart().IsNull());
    ABORT_EDITING_COMMAND_IF(EndingVisibleSelection().VisibleEnd().IsNull());
  }

  VisibleSelection selection =
      SelectionForParagraphIteration(EndingVisibleSelection());
  VisiblePosition start_of_selection = selection.VisibleStart();
  ABORT_EDITING_COMMAND_IF(start_of_selection.IsNull());
  VisiblePosition end_of_selection = selection.VisibleEnd();
  ABORT_EDITING_COMMAND_IF(end_of_selection.IsNull());
  ContainerNode* start_scope = nullptr;
  int start_index = IndexForVisiblePosition(start_of_selection, start_scope);
  ContainerNode* end_scope = nullptr;
  int end_index = IndexForVisiblePosition(end_of_selection, end_scope);

  // Due to visible position canonicalization, start and end positions could
  // move to different selection contexts one of which could be inside an
  // element that is not editable. e.g. <pre contenteditable>
  //   hello^
  // <svg viewBox="0 0 200 200" xmlns="http://www.w3.org/2000/svg">
  // <foreignObject x="20" y="20" width="80" height="80">
  //  L|orem
  // </foreignObject>
  // </svg>
  // </pre>
  if (!IsEditablePosition(start_of_selection.DeepEquivalent()) ||
      !IsEditablePosition(end_of_selection.DeepEquivalent())) {
    return;
  }

  FormatSelection(start_of_selection, end_of_selection, editing_state);
  if (editing_state->IsAborted())
    return;

  GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kEditing);

  DCHECK_EQ(start_scope, end_scope);
  DCHECK_GE(start_index, 0);
  DCHECK_LE(start_index, end_index);
  if (start_scope == end_scope && start_index >= 0 &&
      start_index <= end_index) {
    VisiblePosition start(VisiblePositionForIndex(start_index, start_scope));
    VisiblePosition end(VisiblePositionForIndex(end_index, end_scope));
    if (start.IsNotNull() && end.IsNotNull()) {
      SetEndingSelection(SelectionForUndoStep::From(
          SelectionInDOMTree::Builder()
              .Collapse(start.ToPositionWithAffinity())
              .Extend(end.DeepEquivalent())
              .Build()));
    }
  }
}

static bool IsAtUnsplittableElement(const Position& pos) {
  Node* node = pos.AnchorNode();
  return node == RootEditableElementOf(pos) ||
         node == EnclosingNodeOfType(pos, &IsTableCell);
}

void ApplyBlockElementCommand::FormatSelection(
    const VisiblePosition& start_of_selection,
    const VisiblePosition& end_of_selection,
    EditingState* editing_state) {
  // Special case empty unsplittable elements because there's nothing to split
  // and there's nothing to move.
  const Position& caret_position =
      MostForwardCaretPosition(start_of_selection.DeepEquivalent());
  if (IsAtUnsplittableElement(caret_position)) {
    HTMLElement* blockquote = CreateBlockElement();
    InsertNodeAt(blockquote, caret_position, editing_state);
    if (editing_state->IsAborted())
      return;
    auto* placeholder = MakeGarbageCollected<HTMLBRElement>(GetDocument());
    AppendNode(placeholder, blockquote, editing_state);
    if (editing_state->IsAborted())
      return;
    SetEndingSelection(SelectionForUndoStep::From(
        SelectionInDOMTree::Builder()
            .Collapse(Position::BeforeNode(*placeholder))
            .Build()));
    return;
  }

  HTMLElement* blockquote_for_next_indent = nullptr;
  VisiblePosition end_of_current_paragraph = EndOfParagraph(start_of_selection);
  const VisiblePosition& visible_end_of_last_paragraph =
      EndOfParagraph(end_of_selection);
  const Position& end_of_next_last_paragraph =
      EndOfParagraph(NextPositionOf(visible_end_of_last_paragraph))
          .DeepEquivalent();
  Position end_of_last_paragraph =
      visible_end_of_last_paragraph.DeepEquivalent();

  bool at_end = false;
  while (end_of_current_paragraph.DeepEquivalent() !=
             end_of_next_last_paragraph &&
         !at_end) {
    if (end_of_current_paragraph.DeepEquivalent() == end_of_last_paragraph)
      at_end = true;

    Position start, end;
    RangeForParagraphSplittingTextNodesIfNeeded(
        end_of_current_paragraph, end_of_last_paragraph, start, end);
    end_of_current_paragraph = CreateVisiblePosition(end);

    Node* enclosing_cell = EnclosingNodeOfType(start, &IsTableCell);
    PositionWithAffinity end_of_next_paragraph =
        EndOfNextParagrahSplittingTextNodesIfNeeded(
            end_of_current_paragraph, end_of_last_paragraph, start, end)
            .ToPositionWithAffinity();

    FormatRange(start, end, end_of_last_paragraph, blockquote_for_next_indent,
                editing_state);
    if (editing_state->IsAborted())
      return;

    // Don't put the next paragraph in the blockquote we just created for this
    // paragraph unless the next paragraph is in the same cell.
    if (enclosing_cell &&
        enclosing_cell !=
            EnclosingNodeOfType(end_of_next_paragraph.GetPosition(),
                                &IsTableCell))
      blockquote_for_next_indent = nullptr;

    // indentIntoBlockquote could move more than one paragraph if the paragraph
    // is in a list item or a table. As a result,
    // |endOfNextLastParagraph| could refer to a position no longer in the
    // document.
    if (end_of_next_last_paragraph.IsNotNull() &&
        !end_of_next_last_paragraph.IsConnected())
      break;
    // Sanity check: Make sure our moveParagraph calls didn't remove
    // endOfNextParagraph.anchorNode() If somehow, e.g. mutation
    // event handler, we did, return to prevent crashes.
    if (end_of_next_paragraph.IsNotNull() &&
        !end_of_next_paragraph.IsConnected())
      return;

    GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kEditing);
    end_of_current_paragraph = CreateVisiblePosition(end_of_next_paragraph);
  }
}

static bool IsNewLineAtPosition(const Position& position) {
  auto* text_node = DynamicTo<Text>(position.ComputeContainerNode());
  int offset = position.OffsetInContainerNode();
  if (!text_node || offset < 0 ||
      offset >= static_cast<int>(text_node->length()))
    return false;

  DummyExceptionStateForTesting exception_state;
  String text_at_position =
      text_node->substringData(offset, 1, exception_state);
  if (exception_state.HadException())
    return false;

  return text_at_position[0] == '\n';
}

static const ComputedStyle* ComputedStyleOfEnclosingTextNode(
    const Position& position) {
  if (!position.IsOffsetInAnchor() || !position.ComputeContainerNode() ||
      !position.ComputeContainerNode()->IsTextNode())
    return nullptr;
  return position.ComputeContainerNode()->GetComputedStyle();
}

void ApplyBlockElementCommand::RangeForParagraphSplittingTextNodesIfNeeded(
    const VisiblePosition& end_of_current_paragraph,
    Position& end_of_last_paragraph,
    Position& start,
    Position& end) {
  start = StartOfParagraph(end_of_current_paragraph).DeepEquivalent();
  end = end_of_current_paragraph.DeepEquivalent();

  bool is_start_and_end_on_same_node = false;
  if (const ComputedStyle* start_style =
          ComputedStyleOfEnclosingTextNode(start)) {
    is_start_and_end_on_same_node =
        ComputedStyleOfEnclosingTextNode(end) &&
        start.ComputeContainerNode() == end.ComputeContainerNode();
    bool is_start_and_end_of_last_paragraph_on_same_node =
        ComputedStyleOfEnclosingTextNode(end_of_last_paragraph) &&
        start.ComputeContainerNode() ==
            end_of_last_paragraph.ComputeContainerNode();

    // Avoid obtanining the start of next paragraph for start
    // TODO(yosin) We should use |PositionMoveType::CodePoint| for
    // |previousPositionOf()|.
    if (start_style->PreserveNewline() && IsNewLineAtPosition(start) &&
        !IsNewLineAtPosition(
            PreviousPositionOf(start, PositionMoveType::kCodeUnit)) &&
        start.OffsetInContainerNode() > 0)
      start = StartOfParagraph(CreateVisiblePosition(PreviousPositionOf(
                                   end, PositionMoveType::kCodeUnit)))
                  .DeepEquivalent();

    // If start is in the middle of a text node, split.
    if (!start_style->CollapseWhiteSpace() &&
        start.OffsetInContainerNode() > 0) {
      int start_offset = start.OffsetInContainerNode();
      auto* start_text = To<Text>(start.ComputeContainerNode());
      SplitTextNode(start_text, start_offset);
      GetDocument().UpdateStyleAndLayoutTree();

      start = Position::FirstPositionInNode(*start_text);
      if (is_start_and_end_on_same_node) {
        DCHECK_GE(end.OffsetInContainerNode(), start_offset);
        end = Position(start_text, end.OffsetInContainerNode() - start_offset);
      }
      if (is_start_and_end_of_last_paragraph_on_same_node) {
        DCHECK_GE(end_of_last_paragraph.OffsetInContainerNode(), start_offset);
        end_of_last_paragraph =
            Position(start_text, end_of_last_paragraph.OffsetInContainerNode() -
                                     start_offset);
      }
    }
  }

  if (const ComputedStyle* end_style = ComputedStyleOfEnclosingTextNode(end)) {
    bool is_end_and_end_of_last_paragraph_on_same_node =
        ComputedStyleOfEnclosingTextNode(end_of_last_paragraph) &&
        end.AnchorNode() == end_of_last_paragraph.AnchorNode();
    // Include \n at the end of line if we're at an empty paragraph
    if (end_style->PreserveNewline() && start == end &&
        end.OffsetInContainerNode() <
            static_cast<int>(To<Text>(end.ComputeContainerNode())->length())) {
      int end_offset = end.OffsetInContainerNode();
      // TODO(yosin) We should use |PositionMoveType::CodePoint| for
      // |previousPositionOf()|.
      if (!IsNewLineAtPosition(
              PreviousPositionOf(end, PositionMoveType::kCodeUnit)) &&
          IsNewLineAtPosition(end))
        end = Position(end.ComputeContainerNode(), end_offset + 1);
      if (is_end_and_end_of_last_paragraph_on_same_node &&
          end.OffsetInContainerNode() >=
              end_of_last_paragraph.OffsetInContainerNode())
        end_of_last_paragraph = end;
    }

    // If end is in the middle of a text node, split.
    if (end_style->UserModify() != EUserModify::kReadOnly &&
        !end_style->CollapseWhiteSpace() && end.OffsetInContainerNode() &&
        end.OffsetInContainerNode() <
            static_cast<int>(To<Text>(end.ComputeContainerNode())->length())) {
      auto* end_container = To<Text>(end.ComputeContainerNode());
      SplitTextNode(end_container, end.OffsetInContainerNode());
      GetDocument().UpdateStyleAndLayoutTree();

      const Node* const previous_sibling_of_end =
          end_container->previousSibling();
      DCHECK(previous_sibling_of_end);
      if (is_start_and_end_on_same_node) {
        start = FirstPositionInOrBeforeNode(*previous_sibling_of_end);
      }
      if (is_end_and_end_of_last_paragraph_on_same_node) {
        if (end_of_last_paragraph.OffsetInContainerNode() ==
            end.OffsetInContainerNode()) {
          end_of_last_paragraph =
              LastPositionInOrAfterNode(*previous_sibling_of_end);
        } else {
          end_of_last_paragraph = Position(
              end_container, end_of_last_paragraph.OffsetInContainerNode() -
                                 end.OffsetInContainerNode());
        }
      }
      end = Position::LastPositionInNode(*previous_sibling_of_end);
    }
  }
}

VisiblePosition
ApplyBlockElementCommand::EndOfNextParagrahSplittingTextNodesIfNeeded(
    VisiblePosition& end_of_current_paragraph,
    Position& end_of_last_paragraph,
    Position& start,
    Position& end) {
  const VisiblePosition& end_of_next_paragraph =
      EndOfParagraph(NextPositionOf(end_of_current_paragraph));
  const Position& end_of_next_paragraph_position =
      end_of_next_paragraph.DeepEquivalent();
  const ComputedStyle* style =
      ComputedStyleOfEnclosingTextNode(end_of_next_paragraph_position);
  if (!style)
    return end_of_next_paragraph;

  auto* const end_of_next_paragraph_text =
      To<Text>(end_of_next_paragraph_position.ComputeContainerNode());
  if (!style->PreserveNewline() ||
      !end_of_next_paragraph_position.OffsetInContainerNode() ||
      !IsNewLineAtPosition(
          Position::FirstPositionInNode(*end_of_next_paragraph_text)))
    return end_of_next_paragraph;

  // \n at the beginning of the text node immediately following the current
  // paragraph is trimmed by moveParagraphWithClones. If endOfNextParagraph was
  // pointing at this same text node, endOfNextParagraph will be shifted by one
  // paragraph. Avoid this by splitting "\n"
  SplitTextNode(end_of_next_paragraph_text, 1);
  GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kEditing);
  Text* const previous_text =
      DynamicTo<Text>(end_of_next_paragraph_text->previousSibling());
  if (end_of_next_paragraph_text == start.ComputeContainerNode() &&
      previous_text) {
    DCHECK_LT(start.OffsetInContainerNode(),
              end_of_next_paragraph_position.OffsetInContainerNode());
    start = Position(previous_text, start.OffsetInContainerNode());
  }
  if (end_of_next_paragraph_text == end.ComputeContainerNode() &&
      previous_text) {
    DCHECK_LT(end.OffsetInContainerNode(),
              end_of_next_paragraph_position.OffsetInContainerNode());
    end = Position(previous_text, end.OffsetInContainerNode());
  }
  if (end_of_next_paragraph_text ==
      end_of_last_paragraph.ComputeContainerNode()) {
    if (end_of_last_paragraph.OffsetInContainerNode() <
        end_of_next_paragraph_position.OffsetInContainerNode()) {
      // We can only fix endOfLastParagraph if the previous node was still text
      // and hasn't been modified by script.
      if (previous_text && static_cast<unsigned>(
                               end_of_last_paragraph.OffsetInContainerNode()) <=
                               previous_text->length()) {
        end_of_last_paragraph = Position(
            previous_text, end_of_last_paragraph.OffsetInContainerNode());
      }
    } else {
      end_of_last_paragraph =
          Position(end_of_next_paragraph_text,
                   end_of_last_paragraph.OffsetInContainerNode() - 1);
    }
  }

  return CreateVisiblePosition(
      Position(end_of_next_paragraph_text,
               end_of_next_paragraph_position.OffsetInContainerNode() - 1));
}

HTMLElement* ApplyBlockElementCommand::CreateBlockElement() const {
  HTMLElement* element = CreateHTMLElement(GetDocument(), tag_name_);
  if (inline_style_.length())
    element->setAttribute(html_names::kStyleAttr, inline_style_);
  return element;
}

}  // namespace blink