/*
 * Copyright (C) 2013 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 GOOGLE 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 GOOGLE 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.
 */

#include "third_party/blink/renderer/core/html/parser/html_tree_builder_simulator.h"

#include "third_party/blink/public/mojom/script/script_type.mojom-blink.h"
#include "third_party/blink/renderer/core/html/parser/html_parser_idioms.h"
#include "third_party/blink/renderer/core/html/parser/html_tokenizer.h"
#include "third_party/blink/renderer/core/html/parser/html_tree_builder.h"
#include "third_party/blink/renderer/core/html_names.h"
#include "third_party/blink/renderer/core/mathml_names.h"
#include "third_party/blink/renderer/core/script/script_loader.h"
#include "third_party/blink/renderer/core/svg_names.h"

namespace blink {

using namespace html_names;

static bool TokenExitsForeignContent(const CompactHTMLToken& token) {
  // FIXME: This is copied from HTMLTreeBuilder::processTokenInForeignContent
  // and changed to use threadSafeHTMLNamesMatch.
  const String& tag_name = token.Data();
  return ThreadSafeMatch(tag_name, kBTag) ||
         ThreadSafeMatch(tag_name, kBigTag) ||
         ThreadSafeMatch(tag_name, kBlockquoteTag) ||
         ThreadSafeMatch(tag_name, kBodyTag) ||
         ThreadSafeMatch(tag_name, kBrTag) ||
         ThreadSafeMatch(tag_name, kCenterTag) ||
         ThreadSafeMatch(tag_name, kCodeTag) ||
         ThreadSafeMatch(tag_name, kDdTag) ||
         ThreadSafeMatch(tag_name, kDivTag) ||
         ThreadSafeMatch(tag_name, kDlTag) ||
         ThreadSafeMatch(tag_name, kDtTag) ||
         ThreadSafeMatch(tag_name, kEmTag) ||
         ThreadSafeMatch(tag_name, kEmbedTag) ||
         ThreadSafeMatch(tag_name, kH1Tag) ||
         ThreadSafeMatch(tag_name, kH2Tag) ||
         ThreadSafeMatch(tag_name, kH3Tag) ||
         ThreadSafeMatch(tag_name, kH4Tag) ||
         ThreadSafeMatch(tag_name, kH5Tag) ||
         ThreadSafeMatch(tag_name, kH6Tag) ||
         ThreadSafeMatch(tag_name, kHeadTag) ||
         ThreadSafeMatch(tag_name, kHrTag) ||
         ThreadSafeMatch(tag_name, kITag) ||
         ThreadSafeMatch(tag_name, kImgTag) ||
         ThreadSafeMatch(tag_name, kLiTag) ||
         ThreadSafeMatch(tag_name, kListingTag) ||
         ThreadSafeMatch(tag_name, kMenuTag) ||
         ThreadSafeMatch(tag_name, kMetaTag) ||
         ThreadSafeMatch(tag_name, kNobrTag) ||
         ThreadSafeMatch(tag_name, kOlTag) ||
         ThreadSafeMatch(tag_name, kPTag) ||
         ThreadSafeMatch(tag_name, kPreTag) ||
         ThreadSafeMatch(tag_name, kRubyTag) ||
         ThreadSafeMatch(tag_name, kSTag) ||
         ThreadSafeMatch(tag_name, kSmallTag) ||
         ThreadSafeMatch(tag_name, kSpanTag) ||
         ThreadSafeMatch(tag_name, kStrongTag) ||
         ThreadSafeMatch(tag_name, kStrikeTag) ||
         ThreadSafeMatch(tag_name, kSubTag) ||
         ThreadSafeMatch(tag_name, kSupTag) ||
         ThreadSafeMatch(tag_name, kTableTag) ||
         ThreadSafeMatch(tag_name, kTtTag) ||
         ThreadSafeMatch(tag_name, kUTag) ||
         ThreadSafeMatch(tag_name, kUlTag) ||
         ThreadSafeMatch(tag_name, kVarTag) ||
         (ThreadSafeMatch(tag_name, kFontTag) &&
          (token.GetAttributeItem(kColorAttr) ||
           token.GetAttributeItem(kFaceAttr) ||
           token.GetAttributeItem(kSizeAttr)));
}

static bool TokenExitsMath(const CompactHTMLToken& token) {
  // FIXME: This is copied from HTMLElementStack::isMathMLTextIntegrationPoint
  // and changed to use threadSafeMatch.
  const String& tag_name = token.Data();
  return ThreadSafeMatch(tag_name, mathml_names::kMiTag) ||
         ThreadSafeMatch(tag_name, mathml_names::kMoTag) ||
         ThreadSafeMatch(tag_name, mathml_names::kMnTag) ||
         ThreadSafeMatch(tag_name, mathml_names::kMsTag) ||
         ThreadSafeMatch(tag_name, mathml_names::kMtextTag);
}

static bool TokenExitsInSelect(const CompactHTMLToken& token) {
  // https://html.spec.whatwg.org/C/#parsing-main-inselect
  const String& tag_name = token.Data();
  return ThreadSafeMatch(tag_name, kInputTag) ||
         ThreadSafeMatch(tag_name, kKeygenTag) ||
         ThreadSafeMatch(tag_name, kTextareaTag);
}

HTMLTreeBuilderSimulator::HTMLTreeBuilderSimulator(
    const HTMLParserOptions& options)
    : options_(options), in_select_insertion_mode_(false) {
  namespace_stack_.push_back(HTML);
}

HTMLTreeBuilderSimulator::State HTMLTreeBuilderSimulator::StateFor(
    HTMLTreeBuilder* tree_builder) {
  DCHECK(IsMainThread());
  State namespace_stack;
  for (HTMLElementStack::ElementRecord* record =
           tree_builder->OpenElements()->TopRecord();
       record; record = record->Next()) {
    Namespace current_namespace = HTML;
    if (record->NamespaceURI() == svg_names::kNamespaceURI)
      current_namespace = SVG;
    else if (record->NamespaceURI() == mathml_names::kNamespaceURI)
      current_namespace = kMathML;

    if (namespace_stack.IsEmpty() ||
        namespace_stack.back() != current_namespace)
      namespace_stack.push_back(current_namespace);
  }
  namespace_stack.Reverse();
  return namespace_stack;
}

HTMLTreeBuilderSimulator::SimulatedToken HTMLTreeBuilderSimulator::Simulate(
    const CompactHTMLToken& token,
    HTMLTokenizer* tokenizer) {
  SimulatedToken simulated_token = kOtherToken;

  if (token.GetType() == HTMLToken::kStartTag) {
    const String& tag_name = token.Data();
    if (ThreadSafeMatch(tag_name, svg_names::kSVGTag))
      namespace_stack_.push_back(SVG);
    if (ThreadSafeMatch(tag_name, mathml_names::kMathTag))
      namespace_stack_.push_back(kMathML);
    if (InForeignContent() && TokenExitsForeignContent(token))
      namespace_stack_.pop_back();
    if (IsHTMLIntegrationPointForStartTag(token) ||
        (namespace_stack_.back() == kMathML && TokenExitsMath(token))) {
      namespace_stack_.push_back(HTML);
    } else if (!InForeignContent()) {
      // FIXME: This is just a copy of Tokenizer::updateStateFor which uses
      // threadSafeMatches.
      if (ThreadSafeMatch(tag_name, kTextareaTag) ||
          ThreadSafeMatch(tag_name, kTitleTag)) {
        tokenizer->SetState(HTMLTokenizer::kRCDATAState);
      } else if (ThreadSafeMatch(tag_name, kScriptTag)) {
        tokenizer->SetState(HTMLTokenizer::kScriptDataState);

        String type_attribute_value;
        if (auto* item = token.GetAttributeItem(kTypeAttr)) {
          type_attribute_value = item->Value();
        }

        String language_attribute_value;
        if (auto* item = token.GetAttributeItem(kLanguageAttr)) {
          language_attribute_value = item->Value();
        }

        if (ScriptLoader::IsValidScriptTypeAndLanguage(
                type_attribute_value, language_attribute_value,
                ScriptLoader::kAllowLegacyTypeInTypeAttribute)) {
          simulated_token = kValidScriptStart;
        }
      } else if (ThreadSafeMatch(tag_name, kLinkTag)) {
        simulated_token = kLink;
      } else if (!in_select_insertion_mode_) {
        // If we're in the "in select" insertion mode, all of these tags are
        // ignored, so we shouldn't change the tokenizer state:
        // https://html.spec.whatwg.org/C/#parsing-main-inselect
        if (ThreadSafeMatch(tag_name, kPlaintextTag) &&
            !in_select_insertion_mode_) {
          tokenizer->SetState(HTMLTokenizer::kPLAINTEXTState);
        } else if (ThreadSafeMatch(tag_name, kStyleTag) ||
                   ThreadSafeMatch(tag_name, kIFrameTag) ||
                   ThreadSafeMatch(tag_name, kXmpTag) ||
                   ThreadSafeMatch(tag_name, kNoembedTag) ||
                   ThreadSafeMatch(tag_name, kNoframesTag) ||
                   (ThreadSafeMatch(tag_name, kNoscriptTag) &&
                    options_.script_enabled)) {
          tokenizer->SetState(HTMLTokenizer::kRAWTEXTState);
        }
      }

      // We need to track whether we're in the "in select" insertion mode
      // in order to determine whether '<plaintext>' will put the tokenizer
      // into PLAINTEXTState, and whether '<xmp>' and others will consume
      // textual content.
      //
      // https://html.spec.whatwg.org/C/#parsing-main-inselect
      if (ThreadSafeMatch(tag_name, kSelectTag)) {
        in_select_insertion_mode_ = true;
      } else if (in_select_insertion_mode_ && TokenExitsInSelect(token)) {
        in_select_insertion_mode_ = false;
      }
    }
  }

  if (token.GetType() == HTMLToken::kEndTag ||
      (token.GetType() == HTMLToken::kStartTag && token.SelfClosing() &&
       InForeignContent())) {
    const String& tag_name = token.Data();
    if ((namespace_stack_.back() == SVG &&
         ThreadSafeMatch(tag_name, svg_names::kSVGTag)) ||
        (namespace_stack_.back() == kMathML &&
         ThreadSafeMatch(tag_name, mathml_names::kMathTag)) ||
        IsHTMLIntegrationPointForEndTag(token) ||
        (namespace_stack_.Contains(kMathML) &&
         namespace_stack_.back() == HTML && TokenExitsMath(token))) {
      namespace_stack_.pop_back();
    }
    if (ThreadSafeMatch(tag_name, kScriptTag)) {
      if (!InForeignContent())
        tokenizer->SetState(HTMLTokenizer::kDataState);
      return kScriptEnd;
    }
    if (ThreadSafeMatch(tag_name, kSelectTag))
      in_select_insertion_mode_ = false;
    if (ThreadSafeMatch(tag_name, kStyleTag))
      simulated_token = kStyleEnd;
  }
  if (token.GetType() == HTMLToken::kStartTag &&
      simulated_token == kOtherToken) {
    const String& tag_name = token.Data();
    // Use the presence of a dash in the tag name as a proxy for
    // "is a custom element".
    if (tag_name.find('-') != kNotFound)
      simulated_token = kCustomElementBegin;
  }

  // FIXME: Also setForceNullCharacterReplacement when in text mode.
  tokenizer->SetForceNullCharacterReplacement(InForeignContent());
  tokenizer->SetShouldAllowCDATA(InForeignContent());
  return simulated_token;
}

// https://html.spec.whatwg.org/C/#html-integration-point
bool HTMLTreeBuilderSimulator::IsHTMLIntegrationPointForStartTag(
    const CompactHTMLToken& token) const {
  DCHECK(token.GetType() == HTMLToken::kStartTag) << token.GetType();

  Namespace tokens_ns = namespace_stack_.back();
  const String& tag_name = token.Data();
  if (tokens_ns == kMathML) {
    if (!ThreadSafeMatch(tag_name, mathml_names::kAnnotationXmlTag))
      return false;
    if (auto* encoding = token.GetAttributeItem(mathml_names::kEncodingAttr)) {
      return EqualIgnoringASCIICase(encoding->Value(), "text/html") ||
             EqualIgnoringASCIICase(encoding->Value(), "application/xhtml+xml");
    }
  } else if (tokens_ns == SVG) {
    // FIXME: It's very fragile that we special case foreignObject here to be
    // case-insensitive.
    if (DeprecatedEqualIgnoringCase(tag_name,
                                    svg_names::kForeignObjectTag.LocalName()))
      return true;
    return ThreadSafeMatch(tag_name, svg_names::kDescTag) ||
           ThreadSafeMatch(tag_name, svg_names::kTitleTag);
  }
  return false;
}

// https://html.spec.whatwg.org/C/#html-integration-point
bool HTMLTreeBuilderSimulator::IsHTMLIntegrationPointForEndTag(
    const CompactHTMLToken& token) const {
  if (token.GetType() != HTMLToken::kEndTag)
    return false;

  // If it's inside an HTML integration point, the top namespace is
  // HTML, and its next namespace is not HTML.
  if (namespace_stack_.back() != HTML)
    return false;
  if (namespace_stack_.size() < 2)
    return false;
  Namespace tokens_ns = namespace_stack_[namespace_stack_.size() - 2];

  const String& tag_name = token.Data();
  if (tokens_ns == kMathML)
    return ThreadSafeMatch(tag_name, mathml_names::kAnnotationXmlTag);
  if (tokens_ns == SVG) {
    // FIXME: It's very fragile that we special case foreignObject here to be
    // case-insensitive.
    if (DeprecatedEqualIgnoringCase(tag_name,
                                    svg_names::kForeignObjectTag.LocalName()))
      return true;
    return ThreadSafeMatch(tag_name, svg_names::kDescTag) ||
           ThreadSafeMatch(tag_name, svg_names::kTitleTag);
  }
  return false;
}

}  // namespace blink