/*
 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
 *           (C) 1999 Antti Koivisto (koivisto@kde.org)
 *           (C) 2001 Dirk Mueller (mueller@kde.org)
 * Copyright (C) 2003, 2010 Apple Inc. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#include "core/html/HTMLMetaElement.h"

#include "core/HTMLNames.h"
#include "core/dom/Document.h"
#include "core/dom/ElementTraversal.h"
#include "core/frame/LocalFrame.h"
#include "core/frame/Settings.h"
#include "core/html/HTMLHeadElement.h"
#include "core/html/parser/HTMLParserIdioms.h"
#include "core/inspector/ConsoleMessage.h"
#include "core/loader/FrameLoaderClient.h"
#include "core/loader/HttpEquiv.h"
#include "platform/RuntimeEnabledFeatures.h"
#include "wtf/text/StringToNumber.h"

namespace blink {

using namespace HTMLNames;

inline HTMLMetaElement::HTMLMetaElement(Document& document)
    : HTMLElement(metaTag, document) {}

DEFINE_NODE_FACTORY(HTMLMetaElement)

static bool isInvalidSeparator(UChar c) {
  return c == ';';
}

// Though isspace() considers \t and \v to be whitespace, Win IE doesn't.
static bool isSeparator(UChar c) {
  return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '=' ||
         c == ',' || c == '\0';
}

void HTMLMetaElement::parseContentAttribute(const String& content,
                                            void* data,
                                            Document* document,
                                            bool viewportMetaZeroValuesQuirk) {
  bool hasInvalidSeparator = false;

  // Tread lightly in this code -- it was specifically designed to mimic Win
  // IE's parsing behavior.
  unsigned keyBegin, keyEnd;
  unsigned valueBegin, valueEnd;

  String buffer = content.lower();
  unsigned length = buffer.length();
  for (unsigned i = 0; i < length; /* no increment here */) {
    // skip to first non-separator, but don't skip past the end of the string
    while (isSeparator(buffer[i])) {
      if (i >= length)
        break;
      i++;
    }
    keyBegin = i;

    // skip to first separator
    while (!isSeparator(buffer[i])) {
      hasInvalidSeparator |= isInvalidSeparator(buffer[i]);
      if (i >= length)
        break;
      i++;
    }
    keyEnd = i;

    // skip to first '=', but don't skip past a ',' or the end of the string
    while (buffer[i] != '=') {
      hasInvalidSeparator |= isInvalidSeparator(buffer[i]);
      if (buffer[i] == ',' || i >= length)
        break;
      i++;
    }

    // Skip to first non-separator, but don't skip past a ',' or the end of the
    // string.
    while (isSeparator(buffer[i])) {
      if (buffer[i] == ',' || i >= length)
        break;
      i++;
    }
    valueBegin = i;

    // skip to first separator
    while (!isSeparator(buffer[i])) {
      hasInvalidSeparator |= isInvalidSeparator(buffer[i]);
      if (i >= length)
        break;
      i++;
    }
    valueEnd = i;

    SECURITY_DCHECK(i <= length);

    String keyString = buffer.substring(keyBegin, keyEnd - keyBegin);
    String valueString = buffer.substring(valueBegin, valueEnd - valueBegin);
    processViewportKeyValuePair(document, !hasInvalidSeparator, keyString,
                                valueString, viewportMetaZeroValuesQuirk, data);
  }
  if (hasInvalidSeparator && document) {
    String message =
        "Error parsing a meta element's content: ';' is not a valid key-value "
        "pair separator. Please use ',' instead.";
    document->addConsoleMessage(ConsoleMessage::create(
        RenderingMessageSource, WarningMessageLevel, message));
  }
}

static inline float clampLengthValue(float value) {
  // Limits as defined in the css-device-adapt spec.
  if (value != ViewportDescription::ValueAuto)
    return std::min(float(10000), std::max(value, float(1)));
  return value;
}

static inline float clampScaleValue(float value) {
  // Limits as defined in the css-device-adapt spec.
  if (value != ViewportDescription::ValueAuto)
    return std::min(float(10), std::max(value, float(0.1)));
  return value;
}

float HTMLMetaElement::parsePositiveNumber(Document* document,
                                           bool reportWarnings,
                                           const String& keyString,
                                           const String& valueString,
                                           bool* ok) {
  size_t parsedLength;
  float value;
  if (valueString.is8Bit())
    value = charactersToFloat(valueString.characters8(), valueString.length(),
                              parsedLength);
  else
    value = charactersToFloat(valueString.characters16(), valueString.length(),
                              parsedLength);
  if (!parsedLength) {
    if (reportWarnings)
      reportViewportWarning(document, UnrecognizedViewportArgumentValueError,
                            valueString, keyString);
    if (ok)
      *ok = false;
    return 0;
  }
  if (parsedLength < valueString.length() && reportWarnings)
    reportViewportWarning(document, TruncatedViewportArgumentValueError,
                          valueString, keyString);
  if (ok)
    *ok = true;
  return value;
}

Length HTMLMetaElement::parseViewportValueAsLength(Document* document,
                                                   bool reportWarnings,
                                                   const String& keyString,
                                                   const String& valueString) {
  // 1) Non-negative number values are translated to px lengths.
  // 2) Negative number values are translated to auto.
  // 3) device-width and device-height are used as keywords.
  // 4) Other keywords and unknown values translate to 0.0.

  if (equalIgnoringCase(valueString, "device-width"))
    return Length(DeviceWidth);
  if (equalIgnoringCase(valueString, "device-height"))
    return Length(DeviceHeight);

  float value =
      parsePositiveNumber(document, reportWarnings, keyString, valueString);

  if (value < 0)
    return Length();  // auto

  return Length(clampLengthValue(value), Fixed);
}

float HTMLMetaElement::parseViewportValueAsZoom(
    Document* document,
    bool reportWarnings,
    const String& keyString,
    const String& valueString,
    bool& computedValueMatchesParsedValue,
    bool viewportMetaZeroValuesQuirk) {
  // 1) Non-negative number values are translated to <number> values.
  // 2) Negative number values are translated to auto.
  // 3) yes is translated to 1.0.
  // 4) device-width and device-height are translated to 10.0.
  // 5) no and unknown values are translated to 0.0

  computedValueMatchesParsedValue = false;
  if (equalIgnoringCase(valueString, "yes"))
    return 1;
  if (equalIgnoringCase(valueString, "no"))
    return 0;
  if (equalIgnoringCase(valueString, "device-width"))
    return 10;
  if (equalIgnoringCase(valueString, "device-height"))
    return 10;

  float value =
      parsePositiveNumber(document, reportWarnings, keyString, valueString);

  if (value < 0)
    return ViewportDescription::ValueAuto;

  if (value > 10.0 && reportWarnings)
    reportViewportWarning(document, MaximumScaleTooLargeError, String(),
                          String());

  if (!value && viewportMetaZeroValuesQuirk)
    return ViewportDescription::ValueAuto;

  float clampedValue = clampScaleValue(value);
  if (clampedValue == value)
    computedValueMatchesParsedValue = true;

  return clampedValue;
}

bool HTMLMetaElement::parseViewportValueAsUserZoom(
    Document* document,
    bool reportWarnings,
    const String& keyString,
    const String& valueString,
    bool& computedValueMatchesParsedValue) {
  // yes and no are used as keywords.
  // Numbers >= 1, numbers <= -1, device-width and device-height are mapped to
  // yes.
  // Numbers in the range <-1, 1>, and unknown values, are mapped to no.

  computedValueMatchesParsedValue = false;
  if (equalIgnoringCase(valueString, "yes")) {
    computedValueMatchesParsedValue = true;
    return true;
  }
  if (equalIgnoringCase(valueString, "no")) {
    computedValueMatchesParsedValue = true;
    return false;
  }
  if (equalIgnoringCase(valueString, "device-width"))
    return true;
  if (equalIgnoringCase(valueString, "device-height"))
    return true;

  float value =
      parsePositiveNumber(document, reportWarnings, keyString, valueString);
  if (fabs(value) < 1)
    return false;

  return true;
}

float HTMLMetaElement::parseViewportValueAsDPI(Document* document,
                                               bool reportWarnings,
                                               const String& keyString,
                                               const String& valueString) {
  if (equalIgnoringCase(valueString, "device-dpi"))
    return ViewportDescription::ValueDeviceDPI;
  if (equalIgnoringCase(valueString, "low-dpi"))
    return ViewportDescription::ValueLowDPI;
  if (equalIgnoringCase(valueString, "medium-dpi"))
    return ViewportDescription::ValueMediumDPI;
  if (equalIgnoringCase(valueString, "high-dpi"))
    return ViewportDescription::ValueHighDPI;

  bool ok;
  float value = parsePositiveNumber(document, reportWarnings, keyString,
                                    valueString, &ok);
  if (!ok || value < 70 || value > 400)
    return ViewportDescription::ValueAuto;

  return value;
}

void HTMLMetaElement::processViewportKeyValuePair(
    Document* document,
    bool reportWarnings,
    const String& keyString,
    const String& valueString,
    bool viewportMetaZeroValuesQuirk,
    void* data) {
  ViewportDescription* description = static_cast<ViewportDescription*>(data);

  if (keyString == "width") {
    const Length& width = parseViewportValueAsLength(document, reportWarnings,
                                                     keyString, valueString);
    if (!width.isAuto()) {
      description->minWidth = Length(ExtendToZoom);
      description->maxWidth = width;
    }
  } else if (keyString == "height") {
    const Length& height = parseViewportValueAsLength(document, reportWarnings,
                                                      keyString, valueString);
    if (!height.isAuto()) {
      description->minHeight = Length(ExtendToZoom);
      description->maxHeight = height;
    }
  } else if (keyString == "initial-scale") {
    description->zoom = parseViewportValueAsZoom(
        document, reportWarnings, keyString, valueString,
        description->zoomIsExplicit, viewportMetaZeroValuesQuirk);
  } else if (keyString == "minimum-scale") {
    description->minZoom = parseViewportValueAsZoom(
        document, reportWarnings, keyString, valueString,
        description->minZoomIsExplicit, viewportMetaZeroValuesQuirk);
  } else if (keyString == "maximum-scale") {
    description->maxZoom = parseViewportValueAsZoom(
        document, reportWarnings, keyString, valueString,
        description->maxZoomIsExplicit, viewportMetaZeroValuesQuirk);
  } else if (keyString == "user-scalable") {
    description->userZoom = parseViewportValueAsUserZoom(
        document, reportWarnings, keyString, valueString,
        description->userZoomIsExplicit);
  } else if (keyString == "target-densitydpi") {
    description->deprecatedTargetDensityDPI = parseViewportValueAsDPI(
        document, reportWarnings, keyString, valueString);
    if (reportWarnings)
      reportViewportWarning(document, TargetDensityDpiUnsupported, String(),
                            String());
  } else if (keyString == "minimal-ui") {
    // Ignore vendor-specific argument.
  } else if (keyString == "shrink-to-fit") {
    // Ignore vendor-specific argument.
  } else if (reportWarnings) {
    reportViewportWarning(document, UnrecognizedViewportArgumentKeyError,
                          keyString, String());
  }
}

static const char* viewportErrorMessageTemplate(ViewportErrorCode errorCode) {
  static const char* const errors[] = {
      "The key \"%replacement1\" is not recognized and ignored.",
      "The value \"%replacement1\" for key \"%replacement2\" is invalid, and "
      "has been ignored.",
      "The value \"%replacement1\" for key \"%replacement2\" was truncated to "
      "its numeric prefix.",
      "The value for key \"maximum-scale\" is out of bounds and the value has "
      "been clamped.",
      "The key \"target-densitydpi\" is not supported.",
  };

  return errors[errorCode];
}

static MessageLevel viewportErrorMessageLevel(ViewportErrorCode errorCode) {
  switch (errorCode) {
    case TruncatedViewportArgumentValueError:
    case TargetDensityDpiUnsupported:
    case UnrecognizedViewportArgumentKeyError:
    case UnrecognizedViewportArgumentValueError:
    case MaximumScaleTooLargeError:
      return WarningMessageLevel;
  }

  NOTREACHED();
  return ErrorMessageLevel;
}

void HTMLMetaElement::reportViewportWarning(Document* document,
                                            ViewportErrorCode errorCode,
                                            const String& replacement1,
                                            const String& replacement2) {
  if (!document || !document->frame())
    return;

  String message = viewportErrorMessageTemplate(errorCode);
  if (!replacement1.isNull())
    message.replace("%replacement1", replacement1);
  if (!replacement2.isNull())
    message.replace("%replacement2", replacement2);

  // FIXME: This message should be moved off the console once a solution to
  // https://bugs.webkit.org/show_bug.cgi?id=103274 exists.
  document->addConsoleMessage(ConsoleMessage::create(
      RenderingMessageSource, viewportErrorMessageLevel(errorCode), message));
}

void HTMLMetaElement::getViewportDescriptionFromContentAttribute(
    const String& content,
    ViewportDescription& description,
    Document* document,
    bool viewportMetaZeroValuesQuirk) {
  parseContentAttribute(content, (void*)&description, document,
                        viewportMetaZeroValuesQuirk);

  if (description.minZoom == ViewportDescription::ValueAuto)
    description.minZoom = 0.25;

  if (description.maxZoom == ViewportDescription::ValueAuto) {
    description.maxZoom = 5;
    description.minZoom = std::min(description.minZoom, float(5));
  }
}
void HTMLMetaElement::processViewportContentAttribute(
    const String& content,
    ViewportDescription::Type origin) {
  DCHECK(!content.isNull());

  if (!document().shouldOverrideLegacyDescription(origin))
    return;

  ViewportDescription descriptionFromLegacyTag(origin);
  if (document().shouldMergeWithLegacyDescription(origin))
    descriptionFromLegacyTag = document().viewportDescription();

  getViewportDescriptionFromContentAttribute(
      content, descriptionFromLegacyTag, &document(),
      document().settings() &&
          document().settings()->viewportMetaZeroValuesQuirk());

  document().setViewportDescription(descriptionFromLegacyTag);
}

void HTMLMetaElement::parseAttribute(const QualifiedName& name,
                                     const AtomicString& oldValue,
                                     const AtomicString& value) {
  if (name == http_equivAttr || name == contentAttr) {
    process();
    return;
  }

  if (name != nameAttr)
    HTMLElement::parseAttribute(name, oldValue, value);
}

Node::InsertionNotificationRequest HTMLMetaElement::insertedInto(
    ContainerNode* insertionPoint) {
  HTMLElement::insertedInto(insertionPoint);
  return InsertionShouldCallDidNotifySubtreeInsertions;
}

void HTMLMetaElement::didNotifySubtreeInsertionsToDocument() {
  process();
}

static bool inDocumentHead(HTMLMetaElement* element) {
  if (!element->isConnected())
    return false;

  return Traversal<HTMLHeadElement>::firstAncestor(*element);
}

void HTMLMetaElement::process() {
  if (!isConnected())
    return;

  // All below situations require a content attribute (which can be the empty
  // string).
  const AtomicString& contentValue = fastGetAttribute(contentAttr);
  if (contentValue.isNull())
    return;

  const AtomicString& nameValue = fastGetAttribute(nameAttr);
  if (!nameValue.isEmpty()) {
    if (equalIgnoringCase(nameValue, "viewport"))
      processViewportContentAttribute(contentValue,
                                      ViewportDescription::ViewportMeta);
    else if (equalIgnoringCase(nameValue, "referrer"))
      document().parseAndSetReferrerPolicy(contentValue,
                                           true /* support legacy keywords */);
    else if (equalIgnoringCase(nameValue, "handheldfriendly") &&
             equalIgnoringCase(contentValue, "true"))
      processViewportContentAttribute(
          "width=device-width", ViewportDescription::HandheldFriendlyMeta);
    else if (equalIgnoringCase(nameValue, "mobileoptimized"))
      processViewportContentAttribute("width=device-width, initial-scale=1",
                                      ViewportDescription::MobileOptimizedMeta);
    else if (equalIgnoringCase(nameValue, "theme-color") && document().frame())
      document().frame()->loader().client()->dispatchDidChangeThemeColor();
  }

  // Get the document to process the tag, but only if we're actually part of DOM
  // tree (changing a meta tag while it's not in the tree shouldn't have any
  // effect on the document).

  const AtomicString& httpEquivValue = fastGetAttribute(http_equivAttr);
  if (httpEquivValue.isEmpty())
    return;

  HttpEquiv::process(document(), httpEquivValue, contentValue,
                     inDocumentHead(this));
}

WTF::TextEncoding HTMLMetaElement::computeEncoding() const {
  HTMLAttributeList attributeList;
  for (const Attribute& attr : attributes())
    attributeList.append(
        std::make_pair(attr.name().localName(), attr.value().getString()));
  return encodingFromMetaAttributes(attributeList);
}

const AtomicString& HTMLMetaElement::content() const {
  return getAttribute(contentAttr);
}

const AtomicString& HTMLMetaElement::httpEquiv() const {
  return getAttribute(http_equivAttr);
}

const AtomicString& HTMLMetaElement::name() const {
  return getNameAttribute();
}
}