/*
 * Copyright (C) 2000 Peter Kelly (pmk@post.com)
 * Copyright (C) 2005, 2006, 2007 Apple Inc. All rights reserved.
 * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)
 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
 * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
 * (http://www.torchmobile.com/)
 *
 * 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.
 *
 */

#ifndef XMLDocumentParser_h
#define XMLDocumentParser_h

#include "core/dom/ParserContentPolicy.h"
#include "core/dom/ScriptableDocumentParser.h"
#include "core/fetch/ResourceClient.h"
#include "core/fetch/ScriptResource.h"
#include "core/xml/parser/XMLErrors.h"
#include "platform/heap/Handle.h"
#include "platform/text/SegmentedString.h"
#include "wtf/HashMap.h"
#include "wtf/RefCounted.h"
#include "wtf/text/CString.h"
#include "wtf/text/StringHash.h"
#include <libxml/tree.h>
#include <memory>

namespace blink {

class ContainerNode;
class ResourceFetcher;
class DocumentFragment;
class Document;
class Element;
class FrameView;
class Text;

class XMLParserContext : public RefCounted<XMLParserContext> {
 public:
  static PassRefPtr<XMLParserContext> createMemoryParser(xmlSAXHandlerPtr,
                                                         void* userData,
                                                         const CString& chunk);
  static PassRefPtr<XMLParserContext> createStringParser(xmlSAXHandlerPtr,
                                                         void* userData);
  ~XMLParserContext();
  xmlParserCtxtPtr context() const { return m_context; }

 private:
  XMLParserContext(xmlParserCtxtPtr context) : m_context(context) {}

  xmlParserCtxtPtr m_context;
};

class XMLDocumentParser final : public ScriptableDocumentParser,
                                public ScriptResourceClient {
  USING_GARBAGE_COLLECTED_MIXIN(XMLDocumentParser);

 public:
  static XMLDocumentParser* create(Document& document, FrameView* view) {
    return new XMLDocumentParser(document, view);
  }
  static XMLDocumentParser* create(DocumentFragment* fragment,
                                   Element* element,
                                   ParserContentPolicy parserContentPolicy) {
    return new XMLDocumentParser(fragment, element, parserContentPolicy);
  }
  ~XMLDocumentParser() override;
  DECLARE_VIRTUAL_TRACE();

  // Exposed for callbacks:
  void handleError(XMLErrors::ErrorType, const char* message, TextPosition);

  void setIsXHTMLDocument(bool isXHTML) { m_isXHTMLDocument = isXHTML; }
  bool isXHTMLDocument() const { return m_isXHTMLDocument; }

  bool isCurrentlyParsing8BitChunk() { return m_isCurrentlyParsing8BitChunk; }

  static bool parseDocumentFragment(
      const String&,
      DocumentFragment*,
      Element* parent = 0,
      ParserContentPolicy = AllowScriptingContent);

  // Used by the XMLHttpRequest to check if the responseXML was well formed.
  bool wellFormed() const override { return !m_sawError; }

  TextPosition textPosition() const override;

  static bool supportsXMLVersion(const String&);

  class PendingCallback {
    USING_FAST_MALLOC(PendingCallback);

   public:
    virtual ~PendingCallback() {}
    virtual void call(XMLDocumentParser*) = 0;
  };

  void setScriptStartPosition(TextPosition);

 private:
  explicit XMLDocumentParser(Document&, FrameView* = 0);
  XMLDocumentParser(DocumentFragment*, Element*, ParserContentPolicy);

  // From DocumentParser
  void insert(const SegmentedString&) override;
  void append(const String&) override;
  void finish() override;
  bool isWaitingForScripts() const override;
  void stopParsing() override;
  void detach() override;
  OrdinalNumber lineNumber() const override;
  OrdinalNumber columnNumber() const;

  // from ResourceClient
  void notifyFinished(Resource*) override;
  String debugName() const override { return "XMLDocumentParser"; }

  void end();

  void pauseParsing();
  void resumeParsing();

  bool appendFragmentSource(const String&);

 public:
  // Callbacks from parser SAX
  void error(XMLErrors::ErrorType, const char* message, va_list args)
      WTF_ATTRIBUTE_PRINTF(3, 0);
  void startElementNs(const AtomicString& localName,
                      const AtomicString& prefix,
                      const AtomicString& uri,
                      int namespaceCount,
                      const xmlChar** namespaces,
                      int attributeCount,
                      int defaultedCount,
                      const xmlChar** libxmlAttributes);
  void endElementNs();
  void characters(const xmlChar* chars, int length);
  void processingInstruction(const String& target, const String& data);
  void cdataBlock(const String&);
  void comment(const String&);
  void startDocument(const String& version,
                     const String& encoding,
                     int standalone);
  void internalSubset(const String& name,
                      const String& externalID,
                      const String& systemID);
  void endDocument();

 private:
  void initializeParserContext(const CString& chunk = CString());

  void pushCurrentNode(ContainerNode*);
  void popCurrentNode();
  void clearCurrentNodeStack();

  void insertErrorMessageBlock();

  void createLeafTextNodeIfNeeded();
  bool updateLeafTextNode();

  void doWrite(const String&);
  void doEnd();

  bool m_hasView;

  SegmentedString m_originalSourceForTransform;

  xmlParserCtxtPtr context() const {
    return m_context ? m_context->context() : 0;
  }
  RefPtr<XMLParserContext> m_context;
  Deque<std::unique_ptr<PendingCallback>> m_pendingCallbacks;
  Vector<xmlChar> m_bufferedText;

  Member<ContainerNode> m_currentNode;
  HeapVector<Member<ContainerNode>> m_currentNodeStack;

  Member<Text> m_leafTextNode;

  bool m_isCurrentlyParsing8BitChunk;
  bool m_sawError;
  bool m_sawCSS;
  bool m_sawXSLTransform;
  bool m_sawFirstElement;
  bool m_isXHTMLDocument;
  bool m_parserPaused;
  bool m_requestingScript;
  bool m_finishCalled;

  XMLErrors m_xmlErrors;

  Member<ScriptResource> m_pendingScript;
  Member<Element> m_scriptElement;
  TextPosition m_scriptStartPosition;
  double m_parserBlockingPendingScriptLoadStartTime;

  bool m_parsingFragment;
  AtomicString m_defaultNamespaceURI;

  typedef HashMap<AtomicString, AtomicString> PrefixForNamespaceMap;
  PrefixForNamespaceMap m_prefixToNamespaceMap;
  SegmentedString m_pendingSrc;
};

xmlDocPtr xmlDocPtrForString(Document*,
                             const String& source,
                             const String& url);
HashMap<String, String> parseAttributes(const String&, bool& attrsOK);

}  // namespace blink

#endif  // XMLDocumentParser_h