/*
 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple 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 APPLE COMPUTER, INC. ``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 APPLE COMPUTER, INC. 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.
 */

// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "third_party/blink/renderer/core/editing/visible_units.h"

#include "third_party/blink/renderer/core/editing/editing_utilities.h"
#include "third_party/blink/renderer/core/editing/ephemeral_range.h"
#include "third_party/blink/renderer/core/editing/text_segments.h"
#include "third_party/blink/renderer/core/editing/visible_position.h"
#include "third_party/blink/renderer/core/layout/layout_block_flow.h"
#include "third_party/blink/renderer/platform/instrumentation/tracing/trace_event.h"
#include "third_party/blink/renderer/platform/text/text_boundaries.h"
#include "third_party/blink/renderer/platform/text/text_break_iterator.h"

namespace blink {

namespace {

// Helpers used during word movement
static bool IsLineBreak(UChar ch) {
  return ch == kNewlineCharacter || ch == kCarriageReturnCharacter;
}

static bool IsWordBreak(UChar ch) {
  return WTF::unicode::IsAlphanumeric(ch) || IsLineBreak(ch) ||
         ch == kLowLineCharacter || WTF::unicode::IsPunct(ch);
}

PositionInFlatTree EndOfWordPositionInternal(const PositionInFlatTree& position,
                                             WordSide side) {
  class Finder final : public TextSegments::Finder {
    STACK_ALLOCATED();

   public:
    Finder(WordSide side) : side_(side) {}

   private:
    Position Find(const String text, unsigned offset) final {
      DCHECK_LE(offset, text.length());
      if (!is_first_time_)
        return FindInternal(text, offset);
      is_first_time_ = false;
      if (side_ == kPreviousWordIfOnBoundary) {
        if (offset == 0)
          return Position::Before(0);
        return FindInternal(text, offset - 1);
      }
      if (offset == text.length())
        return Position::After(offset);
      return FindInternal(text, offset);
    }

    static Position FindInternal(const String text, unsigned offset) {
      DCHECK_LE(offset, text.length());
      TextBreakIterator* it = WordBreakIterator(text.Span16());
      const int result = it->following(offset);
      if (result == kTextBreakDone || result == 0)
        return Position();
      return Position::After(result - 1);
    }

    const WordSide side_;
    bool is_first_time_ = true;
  } finder(side);
  return TextSegments::FindBoundaryForward(position, &finder);
}

PositionInFlatTree NextWordPositionInternal(
    const PositionInFlatTree& position,
    PlatformWordBehavior platform_word_behavior) {
  class Finder final : public TextSegments::Finder {
    STACK_ALLOCATED();

   public:
    Finder(PlatformWordBehavior platform_word_behavior)
        : platform_word_behavior_(platform_word_behavior) {}

   private:
    Position Find(const String text, unsigned offset) final {
      DCHECK_LE(offset, text.length());
      if (!is_first_time_ && static_cast<unsigned>(offset) < text.length()) {
        // These conditions check if we found a valid word break position after
        // another iteration of scanning contents from the position that was
        // passed to this function. Ex: |Hello |World|\n |foo |bar
        // When we are after World|, the first iteration of this loop after call
        // to TextSegments::Finder::find will return empty position as there
        // aren't any meaningful word in that inline_content. In the next
        // iteration of this loop, it fetches the word |foo, so we return the
        // current position as we don't want to skip this valid position by
        // advancing from this position and return |bar instead.
        if (IsWordBreak(text[offset]))
          return SkipWhitespaceIfNeeded(text, offset);
      }
      is_first_time_ = false;
      if (offset == text.length() || text.length() == 0)
        return Position();
      TextBreakIterator* it = WordBreakIterator(text.Span16());
      for (int runner = it->following(offset); runner != kTextBreakDone;
           runner = it->following(runner)) {
        // Move after line break
        if (IsLineBreak(text[runner]))
          return SkipWhitespaceIfNeeded(text, runner);
        // Accumulate punctuation runs
        if (static_cast<unsigned>(runner) < text.length() &&
            WTF::unicode::IsPunct(text[runner])) {
          if (WTF::unicode::IsAlphanumeric(text[runner - 1]))
            return SkipWhitespaceIfNeeded(text, runner);
          continue;
        }
        // We stop searching in the following conditions:
        // 1. When the character preceding the break is
        //    alphanumeric or punctuations or underscore or linebreaks.
        // Only on Windows:
        // 2. When the character preceding the break is a whitespace and
        //    the character following it is an alphanumeric or punctuations
        //    or underscore or linebreaks.
        if (static_cast<unsigned>(runner) < text.length() &&
            IsWordBreak(text[runner - 1]))
          return SkipWhitespaceIfNeeded(text, runner);
        else if (platform_word_behavior_ ==
                     PlatformWordBehavior::kWordSkipSpaces &&
                 static_cast<unsigned>(runner) < text.length() &&
                 IsWhitespace(text[runner - 1]) && IsWordBreak(text[runner]))
          return SkipWhitespaceIfNeeded(text, runner);
      }
      if (text[text.length() - 1] != kNewlineCharacter)
        return Position::After(text.length() - 1);
      return Position();
    }

    Position SkipWhitespaceIfNeeded(const String text, int offset) {
      DCHECK_NE(offset, kTextBreakDone);
      // On Windows next word should skip trailing whitespaces but not line
      // break
      if (platform_word_behavior_ == PlatformWordBehavior::kWordSkipSpaces) {
        for (unsigned runner = static_cast<unsigned>(offset);
             runner < text.length(); ++runner) {
          if (!(IsWhitespace(text[runner]) ||
                WTF::unicode::Direction(text[runner]) ==
                    WTF::unicode::kWhiteSpaceNeutral) ||
              IsLineBreak(text[runner]))
            return Position::Before(runner);
        }
      }
      return Position::Before(offset);
    }

    const PlatformWordBehavior platform_word_behavior_;
    bool is_first_time_ = true;
  } finder(platform_word_behavior);
  return TextSegments::FindBoundaryForward(position, &finder);
}

PositionInFlatTree PreviousWordPositionInternal(
    const PositionInFlatTree& position) {
  class Finder final : public TextSegments::Finder {
    STACK_ALLOCATED();

   private:
    Position Find(const String text, unsigned offset) final {
      DCHECK_LE(offset, text.length());
      if (!is_first_time_ && text.length() > 0 &&
          static_cast<unsigned>(offset) <= text.length()) {
        // These conditions check if we found a valid word break position after
        // another iteration of scanning contents from the position that was
        // passed to this function. Ex: |Hello |World|\n |foo |bar
        // When we are before |foo, the first iteration of this loop after call
        // to TextSegments::Finder::find will return empty position as there
        // aren't any meaningful word in that inline_content. In the next
        // iteration of this loop, it fetches the word World|, so we return the
        // current position as we don't want to skip this valid position by
        // advancing from this position and return |World instead.
        if (IsWordBreak(text[offset - 1]))
          return Position::Before(offset);
      }
      is_first_time_ = false;
      if (!offset || text.length() == 0)
        return Position();
      TextBreakIterator* it = WordBreakIterator(text.Span16());
      int punct_runner = -1;
      for (int runner = it->preceding(offset); runner != kTextBreakDone;
           runner = it->preceding(runner)) {
        // Accumulate punctuation runs
        if (static_cast<unsigned>(runner) < text.length() &&
            WTF::unicode::IsPunct(text[runner])) {
          if (WTF::unicode::IsAlphanumeric(text[runner - 1]))
            return Position::Before(runner);
          punct_runner = runner;
          continue;
        }

        if (punct_runner >= 0)
          return Position::Before(punct_runner);
        // We stop searching when the character following the break is
        // alphanumeric or punctuations or underscore or linebreaks.
        if (static_cast<unsigned>(runner) < text.length() &&
            IsWordBreak(text[runner]))
          return Position::Before(runner);
      }
      return Position::Before(0);
    }
    bool is_first_time_ = true;
  } finder;
  return TextSegments::FindBoundaryBackward(position, &finder);
}

PositionInFlatTree StartOfWordPositionInternal(
    const PositionInFlatTree& position,
    WordSide side) {
  class Finder final : public TextSegments::Finder {
    STACK_ALLOCATED();

   public:
    Finder(WordSide side) : side_(side) {}

   private:
    Position Find(const String text, unsigned offset) final {
      DCHECK_LE(offset, text.length());
      if (!is_first_time_)
        return FindInternal(text, offset);
      is_first_time_ = false;
      if (side_ == kNextWordIfOnBoundary) {
        if (offset == text.length())
          return Position::After(text.length());
        return FindInternal(text, offset + 1);
      }
      if (!offset)
        return Position::Before(offset);
      return FindInternal(text, offset);
    }

    static Position FindInternal(const String text, unsigned offset) {
      DCHECK_LE(offset, text.length());
      TextBreakIterator* it = WordBreakIterator(text.Span16());
      const int result = it->preceding(offset);
      if (result == kTextBreakDone)
        return Position();
      return Position::Before(result);
    }

    const WordSide side_;
    bool is_first_time_ = true;
  } finder(side);
  return TextSegments::FindBoundaryBackward(position, &finder);
}
}  // namespace

PositionInFlatTree EndOfWordPosition(const PositionInFlatTree& start,
                                     WordSide side) {
  return AdjustForwardPositionToAvoidCrossingEditingBoundaries(
             PositionInFlatTreeWithAffinity(
                 EndOfWordPositionInternal(start, side)),
             start)
      .GetPosition();
}

Position EndOfWordPosition(const Position& position, WordSide side) {
  return ToPositionInDOMTree(
      EndOfWordPosition(ToPositionInFlatTree(position), side));
}

// ----
// TODO(editing-dev): Because of word boundary can not be an upstream position,
// we should make this function to return |PositionInFlatTree|.
PositionInFlatTreeWithAffinity NextWordPosition(
    const PositionInFlatTree& start,
    PlatformWordBehavior platform_word_behavior) {
  const PositionInFlatTree next =
      NextWordPositionInternal(start, platform_word_behavior);
  // Note: The word boundary can not be upstream position.
  const PositionInFlatTreeWithAffinity adjusted =
      AdjustForwardPositionToAvoidCrossingEditingBoundaries(
          PositionInFlatTreeWithAffinity(next), start);
  DCHECK_EQ(adjusted.Affinity(), TextAffinity::kDownstream);
  return adjusted;
}

PositionWithAffinity NextWordPosition(
    const Position& start,
    PlatformWordBehavior platform_word_behavior) {
  const PositionInFlatTreeWithAffinity& next =
      NextWordPosition(ToPositionInFlatTree(start), platform_word_behavior);
  return ToPositionInDOMTreeWithAffinity(next);
}

PositionInFlatTreeWithAffinity PreviousWordPosition(
    const PositionInFlatTree& start) {
  const PositionInFlatTree prev = PreviousWordPositionInternal(start);
  return AdjustBackwardPositionToAvoidCrossingEditingBoundaries(
      PositionInFlatTreeWithAffinity(prev), start);
}

PositionWithAffinity PreviousWordPosition(const Position& start) {
  const PositionInFlatTreeWithAffinity& prev =
      PreviousWordPosition(ToPositionInFlatTree(start));
  return ToPositionInDOMTreeWithAffinity(prev);
}

PositionInFlatTree StartOfWordPosition(const PositionInFlatTree& position,
                                       WordSide side) {
  const PositionInFlatTree start = StartOfWordPositionInternal(position, side);
  return AdjustBackwardPositionToAvoidCrossingEditingBoundaries(
             PositionInFlatTreeWithAffinity(start), position)
      .GetPosition();
}

Position StartOfWordPosition(const Position& position, WordSide side) {
  return ToPositionInDOMTree(
      StartOfWordPosition(ToPositionInFlatTree(position), side));
}

}  // namespace blink