/*
 * Copyright (C) Research In Motion Limited 2010. 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/layout/svg/SVGResources.h"

#include "core/SVGNames.h"
#include "core/layout/svg/LayoutSVGResourceClipper.h"
#include "core/layout/svg/LayoutSVGResourceFilter.h"
#include "core/layout/svg/LayoutSVGResourceMarker.h"
#include "core/layout/svg/LayoutSVGResourceMasker.h"
#include "core/layout/svg/LayoutSVGResourcePaintServer.h"
#include "core/style/ComputedStyle.h"
#include "core/svg/SVGFilterElement.h"
#include "core/svg/SVGGradientElement.h"
#include "core/svg/SVGPatternElement.h"
#include "core/svg/SVGURIReference.h"
#include "wtf/PtrUtil.h"
#include <memory>

#ifndef NDEBUG
#include <stdio.h>
#endif

namespace blink {

using namespace SVGNames;

SVGResources::SVGResources() : m_linkedResource(nullptr) {}

static HashSet<AtomicString>& clipperFilterMaskerTags() {
  DEFINE_STATIC_LOCAL(
      HashSet<AtomicString>, s_tagList,
      ({
          // "container elements":
          // http://www.w3.org/TR/SVG11/intro.html#TermContainerElement
          // "graphics elements" :
          // http://www.w3.org/TR/SVG11/intro.html#TermGraphicsElement
          aTag.localName(), circleTag.localName(), ellipseTag.localName(),
          gTag.localName(), imageTag.localName(), lineTag.localName(),
          markerTag.localName(), maskTag.localName(), pathTag.localName(),
          polygonTag.localName(), polylineTag.localName(), rectTag.localName(),
          svgTag.localName(), textTag.localName(), useTag.localName(),
          // Not listed in the definitions is the clipPath element, the SVG spec
          // says though:
          // The "clipPath" element or any of its children can specify property
          // "clip-path".
          // So we have to add clipPathTag here, otherwhise clip-path on
          // clipPath will fail. (Already mailed SVG WG, waiting for a solution)
          clipPathTag.localName(),
          // Not listed in the definitions are the text content elements, though
          // filter/clipper/masker on tspan/text/.. is allowed.
          // (Already mailed SVG WG, waiting for a solution)
          textPathTag.localName(), tspanTag.localName(),
          // Not listed in the definitions is the foreignObject element, but
          // clip-path is a supported attribute.
          foreignObjectTag.localName(),
          // Elements that we ignore, as it doesn't make any sense.
          // defs, pattern, switch (FIXME: Mail SVG WG about these)
          // symbol (is converted to a svg element, when referenced by use, we
          // can safely ignore it.)
      }));
  return s_tagList;
}

bool SVGResources::supportsMarkers(const SVGElement& element) {
  DEFINE_STATIC_LOCAL(HashSet<AtomicString>, s_tagList,
                      ({
                          lineTag.localName(), pathTag.localName(),
                          polygonTag.localName(), polylineTag.localName(),
                      }));
  return s_tagList.contains(element.localName());
}

static HashSet<AtomicString>& fillAndStrokeTags() {
  DEFINE_STATIC_LOCAL(
      HashSet<AtomicString>, s_tagList,
      ({
          circleTag.localName(), ellipseTag.localName(), lineTag.localName(),
          pathTag.localName(), polygonTag.localName(), polylineTag.localName(),
          rectTag.localName(), textTag.localName(), textPathTag.localName(),
          tspanTag.localName(),
      }));
  return s_tagList;
}

static HashSet<AtomicString>& chainableResourceTags() {
  DEFINE_STATIC_LOCAL(HashSet<AtomicString>, s_tagList,
                      ({
                          linearGradientTag.localName(), filterTag.localName(),
                          patternTag.localName(), radialGradientTag.localName(),
                      }));
  return s_tagList;
}

static inline AtomicString targetReferenceFromResource(SVGElement& element) {
  String target;
  if (isSVGPatternElement(element))
    target = toSVGPatternElement(element).href()->currentValue()->value();
  else if (isSVGGradientElement(element))
    target = toSVGGradientElement(element).href()->currentValue()->value();
  else if (isSVGFilterElement(element))
    target = toSVGFilterElement(element).href()->currentValue()->value();
  else
    ASSERT_NOT_REACHED();

  return SVGURIReference::fragmentIdentifierFromIRIString(target,
                                                          element.treeScope());
}

static inline bool svgPaintTypeHasURL(SVGPaintType paintType) {
  switch (paintType) {
    case SVG_PAINTTYPE_URI_NONE:
    case SVG_PAINTTYPE_URI_CURRENTCOLOR:
    case SVG_PAINTTYPE_URI_RGBCOLOR:
    case SVG_PAINTTYPE_URI:
      return true;
    default:
      break;
  }
  return false;
}

static inline LayoutSVGResourcePaintServer* paintingResourceFromSVGPaint(
    TreeScope& treeScope,
    const SVGPaintType& paintType,
    const String& paintUri,
    AtomicString& id,
    bool& hasPendingResource) {
  if (!svgPaintTypeHasURL(paintType))
    return nullptr;

  id = SVGURIReference::fragmentIdentifierFromIRIString(paintUri, treeScope);
  LayoutSVGResourceContainer* container =
      getLayoutSVGResourceContainerById(treeScope, id);
  if (!container) {
    hasPendingResource = true;
    return nullptr;
  }

  if (!container->isSVGPaintServer())
    return nullptr;

  return toLayoutSVGResourcePaintServer(container);
}

static inline void registerPendingResource(SVGDocumentExtensions& extensions,
                                           const AtomicString& id,
                                           SVGElement* element) {
  ASSERT(element);
  extensions.addPendingResource(id, element);
}

bool SVGResources::hasResourceData() const {
  return m_clipperFilterMaskerData || m_markerData || m_fillStrokeData ||
         m_linkedResource;
}

static inline SVGResources& ensureResources(
    std::unique_ptr<SVGResources>& resources) {
  if (!resources)
    resources = wrapUnique(new SVGResources);

  return *resources.get();
}

std::unique_ptr<SVGResources> SVGResources::buildResources(
    const LayoutObject* object,
    const ComputedStyle& computedStyle) {
  ASSERT(object);

  Node* node = object->node();
  ASSERT(node);
  ASSERT_WITH_SECURITY_IMPLICATION(node->isSVGElement());

  SVGElement* element = toSVGElement(node);
  ASSERT(element);

  const AtomicString& tagName = element->localName();
  ASSERT(!tagName.isNull());

  TreeScope& treeScope = element->treeScope();
  SVGDocumentExtensions& extensions = element->document().accessSVGExtensions();

  const SVGComputedStyle& style = computedStyle.svgStyle();

  std::unique_ptr<SVGResources> resources;
  if (clipperFilterMaskerTags().contains(tagName)) {
    if (computedStyle.clipPath() && !object->isSVGRoot()) {
      ClipPathOperation* clipPathOperation = computedStyle.clipPath();
      if (clipPathOperation->type() == ClipPathOperation::REFERENCE) {
        const ReferenceClipPathOperation& clipPathReference =
            toReferenceClipPathOperation(*clipPathOperation);
        AtomicString id = SVGURIReference::fragmentIdentifierFromIRIString(
            clipPathReference.url(), treeScope);
        if (!ensureResources(resources).setClipper(
                getLayoutSVGResourceById<LayoutSVGResourceClipper>(treeScope,
                                                                   id)))
          registerPendingResource(extensions, id, element);
      }
    }

    if (computedStyle.hasFilter() && !object->isSVGRoot()) {
      const FilterOperations& filterOperations = computedStyle.filter();
      if (filterOperations.size() == 1) {
        const FilterOperation& filterOperation = *filterOperations.at(0);
        if (filterOperation.type() == FilterOperation::REFERENCE) {
          const auto& referenceFilterOperation =
              toReferenceFilterOperation(filterOperation);
          AtomicString id = SVGURIReference::fragmentIdentifierFromIRIString(
              referenceFilterOperation.url(), treeScope);
          if (!ensureResources(resources).setFilter(
                  getLayoutSVGResourceById<LayoutSVGResourceFilter>(treeScope,
                                                                    id)))
            registerPendingResource(extensions, id, element);
        }
      }
    }

    if (style.hasMasker()) {
      AtomicString id = style.maskerResource();
      if (!ensureResources(resources).setMasker(
              getLayoutSVGResourceById<LayoutSVGResourceMasker>(treeScope, id)))
        registerPendingResource(extensions, id, element);
    }
  }

  if (style.hasMarkers() && supportsMarkers(*element)) {
    const AtomicString& markerStartId = style.markerStartResource();
    if (!ensureResources(resources).setMarkerStart(
            getLayoutSVGResourceById<LayoutSVGResourceMarker>(treeScope,
                                                              markerStartId)))
      registerPendingResource(extensions, markerStartId, element);

    const AtomicString& markerMidId = style.markerMidResource();
    if (!ensureResources(resources).setMarkerMid(
            getLayoutSVGResourceById<LayoutSVGResourceMarker>(treeScope,
                                                              markerMidId)))
      registerPendingResource(extensions, markerMidId, element);

    const AtomicString& markerEndId = style.markerEndResource();
    if (!ensureResources(resources).setMarkerEnd(
            getLayoutSVGResourceById<LayoutSVGResourceMarker>(
                treeScope, style.markerEndResource())))
      registerPendingResource(extensions, markerEndId, element);
  }

  if (fillAndStrokeTags().contains(tagName)) {
    if (style.hasFill()) {
      bool hasPendingResource = false;
      AtomicString id;
      LayoutSVGResourcePaintServer* resource = paintingResourceFromSVGPaint(
          treeScope, style.fillPaintType(), style.fillPaintUri(), id,
          hasPendingResource);
      if (!ensureResources(resources).setFill(resource) && hasPendingResource)
        registerPendingResource(extensions, id, element);
    }

    if (style.hasStroke()) {
      bool hasPendingResource = false;
      AtomicString id;
      LayoutSVGResourcePaintServer* resource = paintingResourceFromSVGPaint(
          treeScope, style.strokePaintType(), style.strokePaintUri(), id,
          hasPendingResource);
      if (!ensureResources(resources).setStroke(resource) && hasPendingResource)
        registerPendingResource(extensions, id, element);
    }
  }

  if (chainableResourceTags().contains(tagName)) {
    AtomicString id = targetReferenceFromResource(*element);
    if (!ensureResources(resources).setLinkedResource(
            getLayoutSVGResourceContainerById(treeScope, id)))
      registerPendingResource(extensions, id, element);
  }

  return (!resources || !resources->hasResourceData()) ? nullptr
                                                       : std::move(resources);
}

void SVGResources::layoutIfNeeded() {
  if (m_clipperFilterMaskerData) {
    if (LayoutSVGResourceClipper* clipper = m_clipperFilterMaskerData->clipper)
      clipper->layoutIfNeeded();
    if (LayoutSVGResourceMasker* masker = m_clipperFilterMaskerData->masker)
      masker->layoutIfNeeded();
    if (LayoutSVGResourceFilter* filter = m_clipperFilterMaskerData->filter)
      filter->layoutIfNeeded();
  }

  if (m_markerData) {
    if (LayoutSVGResourceMarker* marker = m_markerData->markerStart)
      marker->layoutIfNeeded();
    if (LayoutSVGResourceMarker* marker = m_markerData->markerMid)
      marker->layoutIfNeeded();
    if (LayoutSVGResourceMarker* marker = m_markerData->markerEnd)
      marker->layoutIfNeeded();
  }

  if (m_fillStrokeData) {
    if (LayoutSVGResourcePaintServer* fill = m_fillStrokeData->fill)
      fill->layoutIfNeeded();
    if (LayoutSVGResourcePaintServer* stroke = m_fillStrokeData->stroke)
      stroke->layoutIfNeeded();
  }

  if (m_linkedResource)
    m_linkedResource->layoutIfNeeded();
}

void SVGResources::removeClientFromCache(LayoutObject* object,
                                         bool markForInvalidation) const {
  if (!hasResourceData())
    return;

  if (m_linkedResource) {
    ASSERT(!m_clipperFilterMaskerData);
    ASSERT(!m_markerData);
    ASSERT(!m_fillStrokeData);
    m_linkedResource->removeClientFromCache(object, markForInvalidation);
    return;
  }

  if (m_clipperFilterMaskerData) {
    if (m_clipperFilterMaskerData->clipper)
      m_clipperFilterMaskerData->clipper->removeClientFromCache(
          object, markForInvalidation);
    if (m_clipperFilterMaskerData->filter)
      m_clipperFilterMaskerData->filter->removeClientFromCache(
          object, markForInvalidation);
    if (m_clipperFilterMaskerData->masker)
      m_clipperFilterMaskerData->masker->removeClientFromCache(
          object, markForInvalidation);
  }

  if (m_markerData) {
    if (m_markerData->markerStart)
      m_markerData->markerStart->removeClientFromCache(object,
                                                       markForInvalidation);
    if (m_markerData->markerMid)
      m_markerData->markerMid->removeClientFromCache(object,
                                                     markForInvalidation);
    if (m_markerData->markerEnd)
      m_markerData->markerEnd->removeClientFromCache(object,
                                                     markForInvalidation);
  }

  if (m_fillStrokeData) {
    if (m_fillStrokeData->fill)
      m_fillStrokeData->fill->removeClientFromCache(object,
                                                    markForInvalidation);
    if (m_fillStrokeData->stroke)
      m_fillStrokeData->stroke->removeClientFromCache(object,
                                                      markForInvalidation);
  }
}

void SVGResources::resourceDestroyed(LayoutSVGResourceContainer* resource) {
  ASSERT(resource);
  if (!hasResourceData())
    return;

  if (m_linkedResource == resource) {
    ASSERT(!m_clipperFilterMaskerData);
    ASSERT(!m_markerData);
    ASSERT(!m_fillStrokeData);
    m_linkedResource->removeAllClientsFromCache();
    m_linkedResource = nullptr;
    return;
  }

  switch (resource->resourceType()) {
    case MaskerResourceType:
      if (!m_clipperFilterMaskerData)
        break;
      if (m_clipperFilterMaskerData->masker == resource)
        m_clipperFilterMaskerData->masker = nullptr;
      break;
    case MarkerResourceType:
      if (!m_markerData)
        break;
      if (m_markerData->markerStart == resource)
        m_markerData->markerStart = nullptr;
      if (m_markerData->markerMid == resource)
        m_markerData->markerMid = nullptr;
      if (m_markerData->markerEnd == resource)
        m_markerData->markerEnd = nullptr;
      break;
    case PatternResourceType:
    case LinearGradientResourceType:
    case RadialGradientResourceType:
      if (!m_fillStrokeData)
        break;
      if (m_fillStrokeData->fill == resource)
        m_fillStrokeData->fill = nullptr;
      if (m_fillStrokeData->stroke == resource)
        m_fillStrokeData->stroke = nullptr;
      break;
    case FilterResourceType:
      if (!m_clipperFilterMaskerData)
        break;
      if (m_clipperFilterMaskerData->filter == resource)
        m_clipperFilterMaskerData->filter = nullptr;
      break;
    case ClipperResourceType:
      if (!m_clipperFilterMaskerData)
        break;
      if (m_clipperFilterMaskerData->clipper == resource)
        m_clipperFilterMaskerData->clipper = nullptr;
      break;
    default:
      ASSERT_NOT_REACHED();
  }
}

void SVGResources::buildSetOfResources(
    HashSet<LayoutSVGResourceContainer*>& set) {
  if (!hasResourceData())
    return;

  if (m_linkedResource) {
    ASSERT(!m_clipperFilterMaskerData);
    ASSERT(!m_markerData);
    ASSERT(!m_fillStrokeData);
    set.add(m_linkedResource);
    return;
  }

  if (m_clipperFilterMaskerData) {
    if (m_clipperFilterMaskerData->clipper)
      set.add(m_clipperFilterMaskerData->clipper);
    if (m_clipperFilterMaskerData->filter)
      set.add(m_clipperFilterMaskerData->filter);
    if (m_clipperFilterMaskerData->masker)
      set.add(m_clipperFilterMaskerData->masker);
  }

  if (m_markerData) {
    if (m_markerData->markerStart)
      set.add(m_markerData->markerStart);
    if (m_markerData->markerMid)
      set.add(m_markerData->markerMid);
    if (m_markerData->markerEnd)
      set.add(m_markerData->markerEnd);
  }

  if (m_fillStrokeData) {
    if (m_fillStrokeData->fill)
      set.add(m_fillStrokeData->fill);
    if (m_fillStrokeData->stroke)
      set.add(m_fillStrokeData->stroke);
  }
}

bool SVGResources::setClipper(LayoutSVGResourceClipper* clipper) {
  if (!clipper)
    return false;

  ASSERT(clipper->resourceType() == ClipperResourceType);

  if (!m_clipperFilterMaskerData)
    m_clipperFilterMaskerData = ClipperFilterMaskerData::create();

  m_clipperFilterMaskerData->clipper = clipper;
  return true;
}

void SVGResources::resetClipper() {
  ASSERT(m_clipperFilterMaskerData);
  ASSERT(m_clipperFilterMaskerData->clipper);
  m_clipperFilterMaskerData->clipper = nullptr;
}

bool SVGResources::setFilter(LayoutSVGResourceFilter* filter) {
  if (!filter)
    return false;

  ASSERT(filter->resourceType() == FilterResourceType);

  if (!m_clipperFilterMaskerData)
    m_clipperFilterMaskerData = ClipperFilterMaskerData::create();

  m_clipperFilterMaskerData->filter = filter;
  return true;
}

void SVGResources::resetFilter() {
  ASSERT(m_clipperFilterMaskerData);
  ASSERT(m_clipperFilterMaskerData->filter);
  m_clipperFilterMaskerData->filter = nullptr;
}

bool SVGResources::setMarkerStart(LayoutSVGResourceMarker* markerStart) {
  if (!markerStart)
    return false;

  ASSERT(markerStart->resourceType() == MarkerResourceType);

  if (!m_markerData)
    m_markerData = MarkerData::create();

  m_markerData->markerStart = markerStart;
  return true;
}

void SVGResources::resetMarkerStart() {
  ASSERT(m_markerData);
  ASSERT(m_markerData->markerStart);
  m_markerData->markerStart = nullptr;
}

bool SVGResources::setMarkerMid(LayoutSVGResourceMarker* markerMid) {
  if (!markerMid)
    return false;

  ASSERT(markerMid->resourceType() == MarkerResourceType);

  if (!m_markerData)
    m_markerData = MarkerData::create();

  m_markerData->markerMid = markerMid;
  return true;
}

void SVGResources::resetMarkerMid() {
  ASSERT(m_markerData);
  ASSERT(m_markerData->markerMid);
  m_markerData->markerMid = nullptr;
}

bool SVGResources::setMarkerEnd(LayoutSVGResourceMarker* markerEnd) {
  if (!markerEnd)
    return false;

  ASSERT(markerEnd->resourceType() == MarkerResourceType);

  if (!m_markerData)
    m_markerData = MarkerData::create();

  m_markerData->markerEnd = markerEnd;
  return true;
}

void SVGResources::resetMarkerEnd() {
  ASSERT(m_markerData);
  ASSERT(m_markerData->markerEnd);
  m_markerData->markerEnd = nullptr;
}

bool SVGResources::setMasker(LayoutSVGResourceMasker* masker) {
  if (!masker)
    return false;

  ASSERT(masker->resourceType() == MaskerResourceType);

  if (!m_clipperFilterMaskerData)
    m_clipperFilterMaskerData = ClipperFilterMaskerData::create();

  m_clipperFilterMaskerData->masker = masker;
  return true;
}

void SVGResources::resetMasker() {
  ASSERT(m_clipperFilterMaskerData);
  ASSERT(m_clipperFilterMaskerData->masker);
  m_clipperFilterMaskerData->masker = nullptr;
}

bool SVGResources::setFill(LayoutSVGResourcePaintServer* fill) {
  if (!fill)
    return false;

  if (!m_fillStrokeData)
    m_fillStrokeData = FillStrokeData::create();

  m_fillStrokeData->fill = fill;
  return true;
}

void SVGResources::resetFill() {
  ASSERT(m_fillStrokeData);
  ASSERT(m_fillStrokeData->fill);
  m_fillStrokeData->fill = nullptr;
}

bool SVGResources::setStroke(LayoutSVGResourcePaintServer* stroke) {
  if (!stroke)
    return false;

  if (!m_fillStrokeData)
    m_fillStrokeData = FillStrokeData::create();

  m_fillStrokeData->stroke = stroke;
  return true;
}

void SVGResources::resetStroke() {
  ASSERT(m_fillStrokeData);
  ASSERT(m_fillStrokeData->stroke);
  m_fillStrokeData->stroke = nullptr;
}

bool SVGResources::setLinkedResource(
    LayoutSVGResourceContainer* linkedResource) {
  if (!linkedResource)
    return false;

  m_linkedResource = linkedResource;
  return true;
}

void SVGResources::resetLinkedResource() {
  ASSERT(m_linkedResource);
  m_linkedResource = nullptr;
}

#ifndef NDEBUG
void SVGResources::dump(const LayoutObject* object) {
  ASSERT(object);
  ASSERT(object->node());

  fprintf(stderr, "-> this=%p, SVGResources(layoutObject=%p, node=%p)\n", this,
          object, object->node());
  fprintf(stderr, " | DOM Tree:\n");
  fprintf(stderr, "%s", object->node()->toTreeStringForThis().utf8().data());

  fprintf(stderr, "\n | List of resources:\n");
  if (m_clipperFilterMaskerData) {
    if (LayoutSVGResourceClipper* clipper = m_clipperFilterMaskerData->clipper)
      fprintf(stderr, " |-> Clipper    : %p (node=%p)\n", clipper,
              clipper->element());
    if (LayoutSVGResourceFilter* filter = m_clipperFilterMaskerData->filter)
      fprintf(stderr, " |-> Filter     : %p (node=%p)\n", filter,
              filter->element());
    if (LayoutSVGResourceMasker* masker = m_clipperFilterMaskerData->masker)
      fprintf(stderr, " |-> Masker     : %p (node=%p)\n", masker,
              masker->element());
  }

  if (m_markerData) {
    if (LayoutSVGResourceMarker* markerStart = m_markerData->markerStart)
      fprintf(stderr, " |-> MarkerStart: %p (node=%p)\n", markerStart,
              markerStart->element());
    if (LayoutSVGResourceMarker* markerMid = m_markerData->markerMid)
      fprintf(stderr, " |-> MarkerMid  : %p (node=%p)\n", markerMid,
              markerMid->element());
    if (LayoutSVGResourceMarker* markerEnd = m_markerData->markerEnd)
      fprintf(stderr, " |-> MarkerEnd  : %p (node=%p)\n", markerEnd,
              markerEnd->element());
  }

  if (m_fillStrokeData) {
    if (LayoutSVGResourcePaintServer* fill = m_fillStrokeData->fill)
      fprintf(stderr, " |-> Fill       : %p (node=%p)\n", fill,
              fill->element());
    if (LayoutSVGResourcePaintServer* stroke = m_fillStrokeData->stroke)
      fprintf(stderr, " |-> Stroke     : %p (node=%p)\n", stroke,
              stroke->element());
  }

  if (m_linkedResource)
    fprintf(stderr, " |-> xlink:href : %p (node=%p)\n", m_linkedResource,
            m_linkedResource->element());
}
#endif

}  // namespace blink