// Copyright 2014 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 "core/paint/TextPainter.h"

#include "core/CSSPropertyNames.h"
#include "core/frame/Settings.h"
#include "core/layout/LayoutObject.h"
#include "core/layout/LayoutTextCombine.h"
#include "core/layout/api/LineLayoutAPIShim.h"
#include "core/layout/api/LineLayoutItem.h"
#include "core/paint/BoxPainter.h"
#include "core/paint/PaintInfo.h"
#include "core/style/ComputedStyle.h"
#include "core/style/ShadowList.h"
#include "platform/fonts/Font.h"
#include "platform/graphics/GraphicsContext.h"
#include "platform/graphics/GraphicsContextStateSaver.h"
#include "platform/text/TextRun.h"
#include "wtf/Assertions.h"
#include "wtf/text/CharacterNames.h"

namespace blink {

TextPainter::TextPainter(GraphicsContext& context,
                         const Font& font,
                         const TextRun& run,
                         const LayoutPoint& textOrigin,
                         const LayoutRect& textBounds,
                         bool horizontal)
    : m_graphicsContext(context),
      m_font(font),
      m_run(run),
      m_textOrigin(textOrigin),
      m_textBounds(textBounds),
      m_horizontal(horizontal),
      m_emphasisMarkOffset(0),
      m_combinedText(0) {}

TextPainter::~TextPainter() {}

void TextPainter::setEmphasisMark(const AtomicString& emphasisMark,
                                  TextEmphasisPosition position) {
  m_emphasisMark = emphasisMark;
  const SimpleFontData* fontData = m_font.primaryFont();
  DCHECK(fontData);

  if (!fontData || emphasisMark.isNull()) {
    m_emphasisMarkOffset = 0;
  } else if (position == TextEmphasisPositionOver) {
    m_emphasisMarkOffset = -fontData->getFontMetrics().ascent() -
                           m_font.emphasisMarkDescent(emphasisMark);
  } else {
    DCHECK(position == TextEmphasisPositionUnder);
    m_emphasisMarkOffset = fontData->getFontMetrics().descent() +
                           m_font.emphasisMarkAscent(emphasisMark);
  }
}

void TextPainter::paint(unsigned startOffset,
                        unsigned endOffset,
                        unsigned length,
                        const Style& textStyle,
                        TextBlobPtr* cachedTextBlob) {
  GraphicsContextStateSaver stateSaver(m_graphicsContext, false);
  updateGraphicsContext(textStyle, stateSaver);
  if (m_combinedText) {
    m_graphicsContext.save();
    m_combinedText->transformToInlineCoordinates(m_graphicsContext,
                                                 m_textBounds);
    paintInternal<PaintText>(startOffset, endOffset, length, cachedTextBlob);
    m_graphicsContext.restore();
  } else {
    paintInternal<PaintText>(startOffset, endOffset, length, cachedTextBlob);
  }

  if (!m_emphasisMark.isEmpty()) {
    if (textStyle.emphasisMarkColor != textStyle.fillColor)
      m_graphicsContext.setFillColor(textStyle.emphasisMarkColor);

    if (m_combinedText)
      paintEmphasisMarkForCombinedText();
    else
      paintInternal<PaintEmphasisMark>(startOffset, endOffset, length);
  }
}

// static
void TextPainter::updateGraphicsContext(GraphicsContext& context,
                                        const Style& textStyle,
                                        bool horizontal,
                                        GraphicsContextStateSaver& stateSaver) {
  TextDrawingModeFlags mode = context.textDrawingMode();
  if (textStyle.strokeWidth > 0) {
    TextDrawingModeFlags newMode = mode | TextModeStroke;
    if (mode != newMode) {
      if (!stateSaver.saved())
        stateSaver.save();
      context.setTextDrawingMode(newMode);
      mode = newMode;
    }
  }

  if (mode & TextModeFill && textStyle.fillColor != context.fillColor())
    context.setFillColor(textStyle.fillColor);

  if (mode & TextModeStroke) {
    if (textStyle.strokeColor != context.strokeColor())
      context.setStrokeColor(textStyle.strokeColor);
    if (textStyle.strokeWidth != context.strokeThickness())
      context.setStrokeThickness(textStyle.strokeWidth);
  }

  if (textStyle.shadow) {
    if (!stateSaver.saved())
      stateSaver.save();
    context.setDrawLooper(textStyle.shadow->createDrawLooper(
        DrawLooperBuilder::ShadowIgnoresAlpha, textStyle.currentColor,
        horizontal));
  }
}

Color TextPainter::textColorForWhiteBackground(Color textColor) {
  int distanceFromWhite = differenceSquared(textColor, Color::white);
  // semi-arbitrarily chose 65025 (255^2) value here after a few tests;
  return distanceFromWhite > 65025 ? textColor : textColor.dark();
}

// static
TextPainter::Style TextPainter::textPaintingStyle(LineLayoutItem lineLayoutItem,
                                                  const ComputedStyle& style,
                                                  const PaintInfo& paintInfo) {
  TextPainter::Style textStyle;
  bool isPrinting = paintInfo.isPrinting();

  if (paintInfo.phase == PaintPhaseTextClip) {
    // When we use the text as a clip, we only care about the alpha, thus we
    // make all the colors black.
    textStyle.currentColor = Color::black;
    textStyle.fillColor = Color::black;
    textStyle.strokeColor = Color::black;
    textStyle.emphasisMarkColor = Color::black;
    textStyle.strokeWidth = style.textStrokeWidth();
    textStyle.shadow = 0;
  } else {
    textStyle.currentColor = style.visitedDependentColor(CSSPropertyColor);
    textStyle.fillColor =
        lineLayoutItem.resolveColor(style, CSSPropertyWebkitTextFillColor);
    textStyle.strokeColor =
        lineLayoutItem.resolveColor(style, CSSPropertyWebkitTextStrokeColor);
    textStyle.emphasisMarkColor =
        lineLayoutItem.resolveColor(style, CSSPropertyWebkitTextEmphasisColor);
    textStyle.strokeWidth = style.textStrokeWidth();
    textStyle.shadow = style.textShadow();

    // Adjust text color when printing with a white background.
    DCHECK(lineLayoutItem.document().printing() == isPrinting);
    bool forceBackgroundToWhite =
        BoxPainter::shouldForceWhiteBackgroundForPrintEconomy(
            style, lineLayoutItem.document());
    if (forceBackgroundToWhite) {
      textStyle.fillColor = textColorForWhiteBackground(textStyle.fillColor);
      textStyle.strokeColor =
          textColorForWhiteBackground(textStyle.strokeColor);
      textStyle.emphasisMarkColor =
          textColorForWhiteBackground(textStyle.emphasisMarkColor);
    }

    // Text shadows are disabled when printing. http://crbug.com/258321
    if (isPrinting)
      textStyle.shadow = 0;
  }

  return textStyle;
}

TextPainter::Style TextPainter::selectionPaintingStyle(
    LineLayoutItem lineLayoutItem,
    bool haveSelection,
    const PaintInfo& paintInfo,
    const TextPainter::Style& textStyle) {
  const LayoutObject& layoutObject =
      *LineLayoutAPIShim::constLayoutObjectFrom(lineLayoutItem);
  TextPainter::Style selectionStyle = textStyle;
  bool usesTextAsClip = paintInfo.phase == PaintPhaseTextClip;
  bool isPrinting = paintInfo.isPrinting();

  if (haveSelection) {
    if (!usesTextAsClip) {
      selectionStyle.fillColor = layoutObject.selectionForegroundColor(
          paintInfo.getGlobalPaintFlags());
      selectionStyle.emphasisMarkColor =
          layoutObject.selectionEmphasisMarkColor(
              paintInfo.getGlobalPaintFlags());
    }

    if (const ComputedStyle* pseudoStyle =
            layoutObject.getCachedPseudoStyle(PseudoIdSelection)) {
      selectionStyle.strokeColor =
          usesTextAsClip ? Color::black
                         : layoutObject.resolveColor(
                               *pseudoStyle, CSSPropertyWebkitTextStrokeColor);
      selectionStyle.strokeWidth = pseudoStyle->textStrokeWidth();
      selectionStyle.shadow = usesTextAsClip ? 0 : pseudoStyle->textShadow();
    }

    // Text shadows are disabled when printing. http://crbug.com/258321
    if (isPrinting)
      selectionStyle.shadow = 0;
  }

  return selectionStyle;
}

template <TextPainter::PaintInternalStep step>
void TextPainter::paintInternalRun(TextRunPaintInfo& textRunPaintInfo,
                                   unsigned from,
                                   unsigned to) {
  DCHECK(from <= textRunPaintInfo.run.length());
  DCHECK(to <= textRunPaintInfo.run.length());

  textRunPaintInfo.from = from;
  textRunPaintInfo.to = to;

  if (step == PaintEmphasisMark) {
    m_graphicsContext.drawEmphasisMarks(
        m_font, textRunPaintInfo, m_emphasisMark,
        FloatPoint(m_textOrigin) + IntSize(0, m_emphasisMarkOffset));
  } else {
    DCHECK(step == PaintText);
    m_graphicsContext.drawText(m_font, textRunPaintInfo,
                               FloatPoint(m_textOrigin));
  }
}

template <TextPainter::PaintInternalStep Step>
void TextPainter::paintInternal(unsigned startOffset,
                                unsigned endOffset,
                                unsigned truncationPoint,
                                TextBlobPtr* cachedTextBlob) {
  TextRunPaintInfo textRunPaintInfo(m_run);
  textRunPaintInfo.bounds = FloatRect(m_textBounds);
  if (startOffset <= endOffset) {
    // FIXME: We should be able to use cachedTextBlob in more cases.
    textRunPaintInfo.cachedTextBlob = cachedTextBlob;
    paintInternalRun<Step>(textRunPaintInfo, startOffset, endOffset);
  } else {
    if (endOffset > 0)
      paintInternalRun<Step>(textRunPaintInfo, 0, endOffset);
    if (startOffset < truncationPoint)
      paintInternalRun<Step>(textRunPaintInfo, startOffset, truncationPoint);
  }
}

void TextPainter::clipDecorationsStripe(float upper,
                                        float stripeWidth,
                                        float dilation) {
  TextRunPaintInfo textRunPaintInfo(m_run);

  if (!m_run.length())
    return;

  Vector<Font::TextIntercept> textIntercepts;
  m_font.getTextIntercepts(
      textRunPaintInfo, m_graphicsContext.deviceScaleFactor(),
      m_graphicsContext.fillPaint(),
      std::make_tuple(upper, upper + stripeWidth), textIntercepts);

  for (auto intercept : textIntercepts) {
    FloatPoint clipOrigin(m_textOrigin);
    FloatRect clipRect(
        clipOrigin + FloatPoint(intercept.m_begin, upper),
        FloatSize(intercept.m_end - intercept.m_begin, stripeWidth));
    clipRect.inflateX(dilation);
    // We need to ensure the clip rectangle is covering the full underline
    // extent. For horizontal drawing, using enclosingIntRect would be
    // sufficient, since we can clamp to full device pixels that way. However,
    // for vertical drawing, we have a transformation applied, which breaks the
    // integers-equal-device pixels assumption, so vertically inflating by 1
    // pixel makes sure we're always covering. This should only be done on the
    // clipping rectangle, not when computing the glyph intersects.
    clipRect.inflateY(1.0);
    m_graphicsContext.clipOut(clipRect);
  }
}

void TextPainter::paintEmphasisMarkForCombinedText() {
  const SimpleFontData* fontData = m_font.primaryFont();
  DCHECK(fontData);
  if (!fontData)
    return;

  DCHECK(m_combinedText);
  TextRun placeholderTextRun(&ideographicFullStopCharacter, 1);
  FloatPoint emphasisMarkTextOrigin(m_textBounds.x().toFloat(),
                                    m_textBounds.y().toFloat() +
                                        fontData->getFontMetrics().ascent() +
                                        m_emphasisMarkOffset);
  TextRunPaintInfo textRunPaintInfo(placeholderTextRun);
  textRunPaintInfo.bounds = FloatRect(m_textBounds);
  m_graphicsContext.concatCTM(rotation(m_textBounds, Clockwise));
  m_graphicsContext.drawEmphasisMarks(m_combinedText->originalFont(),
                                      textRunPaintInfo, m_emphasisMark,
                                      emphasisMarkTextOrigin);
  m_graphicsContext.concatCTM(rotation(m_textBounds, Counterclockwise));
}

}  // namespace blink