// Copyright 2014 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "cobalt/dom/named_node_map.h"

#include <algorithm>
#include <iterator>

#include "base/optional.h"
#include "cobalt/dom/attr.h"
#include "cobalt/dom/element.h"
#include "cobalt/dom/global_stats.h"
#include "nb/memory_scope.h"

namespace cobalt {
namespace dom {

NamedNodeMap::NamedNodeMap(const scoped_refptr<Element>& element)
    : element_(element) {
  DCHECK(element_);
  GlobalStats::GetInstance()->Add(this);
}

// The length attribute's getter must return the attribute list's size.
//  https://dom.spec.whatwg.org/#dom-namednodemap-length
unsigned int NamedNodeMap::length() const {
  return static_cast<unsigned int>(element_->attribute_map().size());
}

// Algorithm for Item:
//   https://dom.spec.whatwg.org/#dom-namednodemap-item
scoped_refptr<Attr> NamedNodeMap::Item(unsigned int item) {
  // 1. If index is equal to or greater than context object's attribute list's
  // size, then return null.
  if (item >= element_->attribute_map().size()) {
    return NULL;
  }

  // 2. Otherwise, return context object's attribute list[index].
  Element::AttributeMap::const_iterator iter =
      element_->attribute_map().begin();
  std::advance(iter, item);
  return GetOrCreateAttr(iter->first);
}

// The getNamedItem(qualifiedName) method, when invoked, must return the result
// of getting an attribute given qualifiedName and element.
//   https://dom.spec.whatwg.org/#dom-namednodemap-getnameditem
scoped_refptr<Attr> NamedNodeMap::GetNamedItem(const std::string& name) const {
  // 1. if element is in the HTML namespace and its node document is an HTML
  // document, then set qualifiedName to qualifiedName in ASCII lowercase.
  // 2. Return the first attribute in element's attribute list whose qualified
  // name is qualifiedName, and null otherwise.
  if (!element_->HasAttribute(name)) {
    return NULL;
  }
  return GetOrCreateAttr(name);
}

// The setNamedItem(attr) and setNamedItemNS(attr) methods, when invoked, must
// return the result of setting an attribute given attr and element.
//   https://dom.spec.whatwg.org/#dom-namednodemap-setnameditem
scoped_refptr<Attr> NamedNodeMap::SetNamedItem(
    const scoped_refptr<Attr>& attribute) {
  // Custom, not in any spec.
  if (!attribute) {
    // TODO: Throw JS NotFoundError.
    return NULL;
  }

  // To set an attribute given an attr and element, run these steps:
  //   https://dom.spec.whatwg.org/#concept-element-attributes-set

  // 1. If attr's element is neither null nor element, throw an
  // InUseAttributeError.
  if (attribute->container() && attribute->container() != this) {
    // TODO: Throw JS InUseAttributeError.
    return NULL;
  }

  // 2. Let oldAttr be the result of getting an attribute given attr's
  // namespace, attr's local name, and element.
  // 3. If oldAttr is attr, return attr.
  // 4. If oldAttr is non-null, replace it by attr in element.
  // 5. Otherwise, append attr to element.
  const std::string& name = attribute->name();
  scoped_refptr<Attr> old_attr;
  if (element_->HasAttribute(name)) {
    old_attr = GetOrCreateAttr(name);

    if (attribute->value() == old_attr->value()) {
      return old_attr;
    }
    old_attr->set_container(NULL);
  }
  attribute->set_container(this);
  proxy_attributes_[name] = attribute->AsWeakPtr();
  // Inform the element about the new attribute. This should trigger a call to
  // NamedNodeMap::SetAttributeInternal and continue the update there.
  element_->SetAttribute(name, attribute->value());

  // 6. Return oldAttr.
  return old_attr;
}

// Algorithm for RemoveNamedItem:
//  https://dom.spec.whatwg.org/#dom-namednodemap-removenameditem
scoped_refptr<Attr> NamedNodeMap::RemoveNamedItem(const std::string& name) {
  // 1. Let attr be the result of removing an attribute given qualifiedName and
  // element.
  // 2. If attr is null, then throw a NotFoundError.
  scoped_refptr<Attr> attr;
  if (element_->HasAttribute(name)) {
    // Get the previous attribute that was associated with 'name' and detach it
    // from NamedNodeMap.
    attr = GetOrCreateAttr(name);
    attr->set_container(NULL);
  } else {
    // TODO: Throw JS NotFoundError.
    return NULL;
  }
  // Inform the element about the removed attribute. This should trigger a call
  // to NamedNodeMap::RemoveAttributeInternal and continue the update there.
  element_->RemoveAttribute(name);

  // 3. Return attr.
  return attr;
}

bool NamedNodeMap::CanQueryNamedProperty(const std::string& name) const {
  return element_->HasAttribute(name);
}

void NamedNodeMap::EnumerateNamedProperties(
    script::PropertyEnumerator* enumerator) const {
  const Element::AttributeMap& attribute_map = element_->attribute_map();
  for (Element::AttributeMap::const_iterator iter = attribute_map.begin();
       iter != attribute_map.end(); ++iter) {
    enumerator->AddProperty(iter->first);
  }
}

void NamedNodeMap::SetAttributeInternal(const std::string& name,
                                        const std::string& value) {
  // Update the associated Attr object.
  NameToAttrMap::iterator attribute_iter = proxy_attributes_.find(name);
  if (attribute_iter != proxy_attributes_.end() && attribute_iter->second) {
    attribute_iter->second->SetValueInternal(value);
  }
}

void NamedNodeMap::RemoveAttributeInternal(const std::string& name) {
  // Make sure to detach the proxy attribute from NamedNodeMap.
  NameToAttrMap::iterator iter = proxy_attributes_.find(name);
  if (iter != proxy_attributes_.end()) {
    if (iter->second) {
      iter->second->set_container(NULL);
    }
    proxy_attributes_.erase(iter);
  }
}

scoped_refptr<Element> NamedNodeMap::element() const { return element_; }

void NamedNodeMap::TraceMembers(script::Tracer* tracer) {
  tracer->Trace(element_);
  tracer->TraceValues(proxy_attributes_);
}

NamedNodeMap::~NamedNodeMap() { GlobalStats::GetInstance()->Remove(this); }

scoped_refptr<Attr> NamedNodeMap::GetOrCreateAttr(
    const std::string& name) const {
  TRACK_MEMORY_SCOPE("DOM");
  NameToAttrMap::iterator iter = proxy_attributes_.find(name);
  if (iter != proxy_attributes_.end() && iter->second) {
    return iter->second.get();
  }

  // We don't have an existing Attr object so we create a new once instead.
  base::Optional<std::string> value = element_->GetAttribute(name);
  scoped_refptr<Attr> attribute = new Attr(name, value.value_or(""), this);
  proxy_attributes_[name] = attribute->AsWeakPtr();

  return attribute;
}

}  // namespace dom
}  // namespace cobalt