/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "HTMLFormControlAccessible.h"

#include "CacheConstants.h"
#include "DocAccessible-inl.h"
#include "LocalAccessible-inl.h"
#include "nsAccUtils.h"
#include "nsEventShell.h"
#include "nsTextEquivUtils.h"
#include "Relation.h"
#include "mozilla/a11y/Role.h"
#include "States.h"
#include "TextLeafAccessible.h"

#include "nsContentList.h"
#include "mozilla/dom/HTMLInputElement.h"
#include "mozilla/dom/HTMLMeterElement.h"
#include "mozilla/dom/HTMLTextAreaElement.h"
#include "mozilla/dom/HTMLFormControlsCollection.h"
#include "nsIFormControl.h"

#include "mozilla/FloatingPoint.h"
#include "mozilla/Preferences.h"
#include "mozilla/TextEditor.h"

using namespace mozilla;
using namespace mozilla::dom;
using namespace mozilla::a11y;

////////////////////////////////////////////////////////////////////////////////
// HTMLFormAccessible
////////////////////////////////////////////////////////////////////////////////

role HTMLFormAccessible::NativeRole() const {
  return NameIsEmpty() ? roles::FORM : roles::FORM_LANDMARK;
}

void HTMLFormAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
                                             nsAtom* aAttribute,
                                             int32_t aModType,
                                             const nsAttrValue* aOldValue,
                                             uint64_t aOldState) {
  HyperTextAccessible::DOMAttributeChanged(aNameSpaceID, aAttribute, aModType,
                                           aOldValue, aOldState);
  if (aAttribute == nsGkAtoms::autocomplete) {
    dom::HTMLFormElement* formEl = dom::HTMLFormElement::FromNode(mContent);

    HTMLFormControlsCollection* controls = formEl->Elements();
    uint32_t length = controls->Length();
    for (uint32_t i = 0; i < length; i++) {
      if (LocalAccessible* acc = mDoc->GetAccessible(controls->Item(i))) {
        if (acc->IsTextField() && !acc->IsPassword()) {
          if (!acc->Elm()->HasAttr(nsGkAtoms::list) &&
              !acc->Elm()->AttrValueIs(kNameSpaceID_None,
                                       nsGkAtoms::autocomplete, nsGkAtoms::OFF,
                                       eIgnoreCase)) {
            RefPtr<AccEvent> stateChangeEvent =
                new AccStateChangeEvent(acc, states::SUPPORTS_AUTOCOMPLETION);
            mDoc->FireDelayedEvent(stateChangeEvent);
          }
        }
      }
    }
  }
}

////////////////////////////////////////////////////////////////////////////////
// HTMLRadioButtonAccessible
////////////////////////////////////////////////////////////////////////////////

uint64_t HTMLRadioButtonAccessible::NativeState() const {
  uint64_t state = AccessibleWrap::NativeState();

  state |= states::CHECKABLE;

  HTMLInputElement* input = HTMLInputElement::FromNode(mContent);
  if (input && input->Checked()) state |= states::CHECKED;

  return state;
}

void HTMLRadioButtonAccessible::GetPositionAndSetSize(int32_t* aPosInSet,
                                                      int32_t* aSetSize) {
  Unused << ComputeGroupAttributes(aPosInSet, aSetSize);
}

void HTMLRadioButtonAccessible::DOMAttributeChanged(
    int32_t aNameSpaceID, nsAtom* aAttribute, int32_t aModType,
    const nsAttrValue* aOldValue, uint64_t aOldState) {
  if (aAttribute == nsGkAtoms::name) {
    // If our name changed, it's possible our MEMBER_OF relation
    // also changed. Push a cache update for Relations.
    mDoc->QueueCacheUpdate(this, CacheDomain::Relations);
  } else {
    // Otherwise, handle this attribute change the way our parent
    // class wants us to handle it.
    RadioButtonAccessible::DOMAttributeChanged(aNameSpaceID, aAttribute,
                                               aModType, aOldValue, aOldState);
  }
}

Relation HTMLRadioButtonAccessible::ComputeGroupAttributes(
    int32_t* aPosInSet, int32_t* aSetSize) const {
  Relation rel = Relation();
  int32_t namespaceId = mContent->NodeInfo()->NamespaceID();
  nsAutoString tagName;
  mContent->NodeInfo()->GetName(tagName);

  nsAutoString type;
  mContent->AsElement()->GetAttr(nsGkAtoms::type, type);
  nsAutoString name;
  mContent->AsElement()->GetAttr(nsGkAtoms::name, name);

  RefPtr<nsContentList> inputElms;

  if (dom::Element* formElm = nsIFormControl::FromNode(mContent)->GetForm()) {
    inputElms = NS_GetContentList(formElm, namespaceId, tagName);
  } else {
    inputElms = NS_GetContentList(mContent->OwnerDoc(), namespaceId, tagName);
  }
  NS_ENSURE_TRUE(inputElms, rel);

  uint32_t inputCount = inputElms->Length(false);

  // Compute posinset and setsize.
  int32_t indexOf = 0;
  int32_t count = 0;

  for (uint32_t index = 0; index < inputCount; index++) {
    nsIContent* inputElm = inputElms->Item(index, false);
    if (inputElm->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
                                           type, eCaseMatters) &&
        inputElm->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::name,
                                           name, eCaseMatters) &&
        mDoc->HasAccessible(inputElm)) {
      count++;
      rel.AppendTarget(mDoc->GetAccessible(inputElm));
      if (inputElm == mContent) indexOf = count;
    }
  }

  *aPosInSet = indexOf;
  *aSetSize = count;
  return rel;
}

Relation HTMLRadioButtonAccessible::RelationByType(RelationType aType) const {
  if (aType == RelationType::MEMBER_OF) {
    int32_t unusedPos, unusedSetSize;
    return ComputeGroupAttributes(&unusedPos, &unusedSetSize);
  }

  return LocalAccessible::RelationByType(aType);
}

////////////////////////////////////////////////////////////////////////////////
// HTMLButtonAccessible
////////////////////////////////////////////////////////////////////////////////

HTMLButtonAccessible::HTMLButtonAccessible(nsIContent* aContent,
                                           DocAccessible* aDoc)
    : HyperTextAccessible(aContent, aDoc) {
  mGenericTypes |= eButton;
}

bool HTMLButtonAccessible::HasPrimaryAction() const { return true; }

void HTMLButtonAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
  if (aIndex == eAction_Click) aName.AssignLiteral("press");
}

void HTMLButtonAccessible::Value(nsString& aValue) const {
  if (HTMLInputElement* input = HTMLInputElement::FromNode(mContent)) {
    if (input->IsInputColor()) {
      nsAutoString value;
      input->GetValue(value, CallerType::NonSystem);
      Maybe<nscolor> maybeColor = HTMLInputElement::ParseSimpleColor(value);
      if (maybeColor) {
        const nscolor& color = maybeColor.ref();
        Decimal r(static_cast<int>(NS_GET_R(color) / 2.55f)),
            g(static_cast<int>(NS_GET_G(color) / 2.55f)),
            b(static_cast<int>(NS_GET_B(color) / 2.55f));
        nsAutoString rs(NS_ConvertUTF8toUTF16(r.toString()));
        nsAutoString gs(NS_ConvertUTF8toUTF16(g.toString()));
        nsAutoString bs(NS_ConvertUTF8toUTF16(b.toString()));
        Accessible::TranslateString(u"inputColorValue"_ns, aValue,
                                    {rs, gs, bs});
        return;
      }
    }
  }

  HyperTextAccessible::Value(aValue);
}

uint64_t HTMLButtonAccessible::NativeState() const {
  uint64_t state = HyperTextAccessible::NativeState();

  dom::Element* elm = Elm();
  if (auto* popover = elm->GetEffectivePopoverTargetElement()) {
    LocalAccessible* popoverAcc = mDoc->GetAccessible(popover);
    if (!popoverAcc || !popoverAcc->IsAncestorOf(this)) {
      if (popover->IsPopoverOpen()) {
        state |= states::EXPANDED;
      } else {
        state |= states::COLLAPSED;
      }
    }
  }

  ElementState elmState = mContent->AsElement()->State();
  if (elmState.HasState(ElementState::DEFAULT)) state |= states::DEFAULT;

  return state;
}

role HTMLButtonAccessible::NativeRole() const { return roles::PUSHBUTTON; }

ENameValueFlag HTMLButtonAccessible::NativeName(nsString& aName) const {
  // No need to check @value attribute for buttons since this attribute results
  // in native anonymous text node and the name is calculated from subtree.
  // The same magic works for @alt and @value attributes in case of type="image"
  // element that has no valid @src (note if input@type="image" has an image
  // then neither @alt nor @value attributes are used to generate a visual label
  // and thus we need to obtain the accessible name directly from attribute
  // value). Also the same algorithm works in case of default labels for
  // type="submit"/"reset"/"image" elements.

  ENameValueFlag nameFlag = LocalAccessible::NativeName(aName);
  if (!aName.IsEmpty() || !mContent->IsHTMLElement(nsGkAtoms::input) ||
      !mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
                                          nsGkAtoms::image, eCaseMatters)) {
    return nameFlag;
  }

  if (!mContent->AsElement()->GetAttr(nsGkAtoms::alt, aName)) {
    mContent->AsElement()->GetAttr(nsGkAtoms::value, aName);
  }

  aName.CompressWhitespace();
  return eNameOK;
}

void HTMLButtonAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
                                               nsAtom* aAttribute,
                                               int32_t aModType,
                                               const nsAttrValue* aOldValue,
                                               uint64_t aOldState) {
  HyperTextAccessible::DOMAttributeChanged(aNameSpaceID, aAttribute, aModType,
                                           aOldValue, aOldState);

  if (aAttribute == nsGkAtoms::value) {
    dom::Element* elm = Elm();
    if (elm->IsHTMLElement(nsGkAtoms::input) ||
        (elm->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type, nsGkAtoms::image,
                          eCaseMatters) &&
         !elm->HasAttr(nsGkAtoms::alt))) {
      if (!nsAccUtils::HasARIAAttr(elm, nsGkAtoms::aria_labelledby) &&
          !nsAccUtils::HasARIAAttr(elm, nsGkAtoms::aria_label)) {
        mDoc->FireDelayedEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, this);
      }
    }
  }
}

////////////////////////////////////////////////////////////////////////////////
// HTMLButtonAccessible: Widgets

bool HTMLButtonAccessible::IsWidget() const { return true; }

////////////////////////////////////////////////////////////////////////////////
// HTMLTextFieldAccessible
////////////////////////////////////////////////////////////////////////////////

HTMLTextFieldAccessible::HTMLTextFieldAccessible(nsIContent* aContent,
                                                 DocAccessible* aDoc)
    : HyperTextAccessible(aContent, aDoc) {
  mType = mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
                                             nsGkAtoms::password, eIgnoreCase)
              ? eHTMLTextPasswordFieldType
              : eHTMLTextFieldType;
}

role HTMLTextFieldAccessible::NativeRole() const {
  if (mType == eHTMLTextPasswordFieldType) {
    return roles::PASSWORD_TEXT;
  }
  dom::Element* el = mContent->AsElement();
  if (el->HasAttr(nsGkAtoms::list)) {
    return roles::EDITCOMBOBOX;
  }
  if (const nsAttrValue* attr = el->GetParsedAttr(nsGkAtoms::type)) {
    RefPtr<nsAtom> inputType = attr->GetAsAtom();
    if (inputType == nsGkAtoms::search) {
      return roles::SEARCHBOX;
    }
  }
  return roles::ENTRY;
}

already_AddRefed<AccAttributes> HTMLTextFieldAccessible::NativeAttributes() {
  RefPtr<AccAttributes> attributes = HyperTextAccessible::NativeAttributes();

  // Expose type for text input elements as it gives some useful context,
  // especially for mobile.
  if (const nsAttrValue* attr =
          mContent->AsElement()->GetParsedAttr(nsGkAtoms::type)) {
    RefPtr<nsAtom> inputType = attr->GetAsAtom();
    if (inputType) {
      if (!ARIARoleMap() && inputType == nsGkAtoms::search) {
        attributes->SetAttribute(nsGkAtoms::xmlroles, nsGkAtoms::searchbox);
      }
      attributes->SetAttribute(nsGkAtoms::textInputType, inputType);
    }
  }
  // If this element  has the placeholder attribute set,
  // and if that is not identical to the name, expose it as an object attribute.
  nsString placeholderText;
  if (mContent->AsElement()->GetAttr(nsGkAtoms::placeholder, placeholderText)) {
    nsAutoString name;
    Name(name);
    if (!name.Equals(placeholderText)) {
      attributes->SetAttribute(nsGkAtoms::placeholder,
                               std::move(placeholderText));
    }
  }

  return attributes.forget();
}

ENameValueFlag HTMLTextFieldAccessible::Name(nsString& aName) const {
  ENameValueFlag nameFlag = LocalAccessible::Name(aName);
  if (!aName.IsEmpty()) return nameFlag;

  // text inputs and textareas might have useful placeholder text
  mContent->AsElement()->GetAttr(nsGkAtoms::placeholder, aName);
  return eNameOK;
}

void HTMLTextFieldAccessible::Value(nsString& aValue) const {
  aValue.Truncate();

  HTMLTextAreaElement* textArea = HTMLTextAreaElement::FromNode(mContent);
  if (textArea) {
    MOZ_ASSERT(!(NativeState() & states::PROTECTED));
    textArea->GetValue(aValue);
    return;
  }

  HTMLInputElement* input = HTMLInputElement::FromNode(mContent);
  if (input) {
    // Pass NonSystem as the caller type, to be safe.  We don't expect to have a
    // file input here.
    input->GetValue(aValue, CallerType::NonSystem);

    if (NativeState() & states::PROTECTED) {  // Don't return password text!
      const char16_t mask = TextEditor::PasswordMask();
      for (size_t i = 0; i < aValue.Length(); i++) {
        aValue.SetCharAt(mask, i);
      }
    }
  }
}

bool HTMLTextFieldAccessible::AttributeChangesState(nsAtom* aAttribute) {
  if (aAttribute == nsGkAtoms::readonly || aAttribute == nsGkAtoms::list ||
      aAttribute == nsGkAtoms::autocomplete) {
    return true;
  }

  return LocalAccessible::AttributeChangesState(aAttribute);
}

void HTMLTextFieldAccessible::ApplyARIAState(uint64_t* aState) const {
  HyperTextAccessible::ApplyARIAState(aState);
  aria::MapToState(aria::eARIAAutoComplete, mContent->AsElement(), aState);
}

uint64_t HTMLTextFieldAccessible::NativeState() const {
  uint64_t state = HyperTextAccessible::NativeState();

  // Text fields are always editable, even if they are also read only or
  // disabled.
  state |= states::EDITABLE;

  // can be focusable, focused, protected. readonly, unavailable, selected
  if (mContent->IsHTMLElement(nsGkAtoms::input) &&
      mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
                                         nsGkAtoms::password, eIgnoreCase)) {
    state |= states::PROTECTED;
  }

  if (mContent->AsElement()->HasAttr(nsGkAtoms::readonly)) {
    state |= states::READONLY;
  }

  // Is it an <input> or a <textarea> ?
  HTMLInputElement* input = HTMLInputElement::FromNode(mContent);
  state |= input && input->IsSingleLineTextControl() ? states::SINGLE_LINE
                                                     : states::MULTI_LINE;

  if (state & (states::PROTECTED | states::MULTI_LINE | states::READONLY |
               states::UNAVAILABLE)) {
    return state;
  }

  // Expose autocomplete state if it has associated autocomplete list.
  if (mContent->AsElement()->HasAttr(nsGkAtoms::list)) {
    return state | states::SUPPORTS_AUTOCOMPLETION | states::HASPOPUP;
  }

  if (Preferences::GetBool("browser.formfill.enable")) {
    // Check to see if autocompletion is allowed on this input. We don't expose
    // it for password fields even though the entire password can be remembered
    // for a page if the user asks it to be. However, the kind of autocomplete
    // we're talking here is based on what the user types, where a popup of
    // possible choices comes up.
    nsAutoString autocomplete;
    mContent->AsElement()->GetAttr(nsGkAtoms::autocomplete, autocomplete);

    if (!autocomplete.LowerCaseEqualsLiteral("off")) {
      Element* formElement = input->GetForm();
      if (formElement) {
        formElement->GetAttr(nsGkAtoms::autocomplete, autocomplete);
      }

      if (!formElement || !autocomplete.LowerCaseEqualsLiteral("off")) {
        state |= states::SUPPORTS_AUTOCOMPLETION;
      }
    }
  }

  return state;
}

bool HTMLTextFieldAccessible::HasPrimaryAction() const { return true; }

void HTMLTextFieldAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
  if (aIndex == eAction_Click) aName.AssignLiteral("activate");
}

bool HTMLTextFieldAccessible::DoAction(uint8_t aIndex) const {
  if (aIndex != 0) return false;

  if (FocusMgr()->IsFocused(this)) {
    // This already has focus, so TakeFocus()will do nothing. However, the user
    // might be activating this element because they dismissed a touch keyboard
    // and want to bring it back.
    DoCommand();
  } else {
    TakeFocus();
  }
  return true;
}

already_AddRefed<EditorBase> HTMLTextFieldAccessible::GetEditor() const {
  RefPtr<TextControlElement> textControlElement =
      TextControlElement::FromNodeOrNull(mContent);
  if (!textControlElement) {
    return nullptr;
  }
  RefPtr<TextEditor> textEditor = textControlElement->GetTextEditor();
  return textEditor.forget();
}

void HTMLTextFieldAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
                                                  nsAtom* aAttribute,
                                                  int32_t aModType,
                                                  const nsAttrValue* aOldValue,
                                                  uint64_t aOldState) {
  if (aAttribute == nsGkAtoms::placeholder) {
    mDoc->QueueCacheUpdate(this, CacheDomain::NameAndDescription);
    return;
  }
  HyperTextAccessible::DOMAttributeChanged(aNameSpaceID, aAttribute, aModType,
                                           aOldValue, aOldState);
}

////////////////////////////////////////////////////////////////////////////////
// HTMLTextFieldAccessible: Widgets

bool HTMLTextFieldAccessible::IsWidget() const { return true; }

LocalAccessible* HTMLTextFieldAccessible::ContainerWidget() const {
  return nullptr;
}

////////////////////////////////////////////////////////////////////////////////
// HTMLFileInputAccessible
////////////////////////////////////////////////////////////////////////////////

HTMLFileInputAccessible::HTMLFileInputAccessible(nsIContent* aContent,
                                                 DocAccessible* aDoc)
    : HyperTextAccessible(aContent, aDoc) {
  mType = eHTMLFileInputType;
  mGenericTypes |= eButton;
}

role HTMLFileInputAccessible::NativeRole() const { return roles::PUSHBUTTON; }

bool HTMLFileInputAccessible::IsAcceptableChild(nsIContent* aEl) const {
  // File inputs are rendered using native anonymous children. However, we
  // want to expose this as a button Accessible so that clients can pick up the
  // name and description from the button they activate, rather than a
  // container. We still expose the text leaf descendants so we can get the
  // name of the Browse button and the file name.
  return aEl->IsText();
}

ENameValueFlag HTMLFileInputAccessible::Name(nsString& aName) const {
  ENameValueFlag flag = HyperTextAccessible::Name(aName);
  if (flag == eNameFromSubtree) {
    // The author didn't provide a name. We'll compute the name from our subtree
    // below.
    aName.Truncate();
  } else {
    // The author provided a name. We do use that, but we also append our
    // subtree text so the user knows this is a file chooser button and what
    // file has been chosen.
    if (aName.IsEmpty()) {
      // Name computation is recursing, perhaps due to a wrapping <label>. Don't
      // append the subtree text. Return " " to prevent
      // nsTextEquivUtils::AppendFromAccessible walking the subtree itself.
      aName += ' ';
      return flag;
    }
  }
  // Unfortunately, GetNameFromSubtree doesn't separate the button text from the
  // file name text. Compute the text ourselves.
  uint32_t count = ChildCount();
  for (uint32_t c = 0; c < count; ++c) {
    TextLeafAccessible* leaf = LocalChildAt(c)->AsTextLeaf();
    MOZ_ASSERT(leaf);
    if (!aName.IsEmpty()) {
      aName += ' ';
    }
    aName += leaf->Text();
  }
  return flag;
}

bool HTMLFileInputAccessible::HasPrimaryAction() const { return true; }

void HTMLFileInputAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
  if (aIndex == 0) {
    aName.AssignLiteral("press");
  }
}

bool HTMLFileInputAccessible::IsWidget() const { return true; }

////////////////////////////////////////////////////////////////////////////////
// HTMLSpinnerAccessible
////////////////////////////////////////////////////////////////////////////////

role HTMLSpinnerAccessible::NativeRole() const { return roles::SPINBUTTON; }

void HTMLSpinnerAccessible::Value(nsString& aValue) const {
  HTMLTextFieldAccessible::Value(aValue);
  if (!aValue.IsEmpty()) return;

  // Pass NonSystem as the caller type, to be safe.  We don't expect to have a
  // file input here.
  HTMLInputElement::FromNode(mContent)->GetValue(aValue, CallerType::NonSystem);
}

double HTMLSpinnerAccessible::MaxValue() const {
  double value = HTMLTextFieldAccessible::MaxValue();
  if (!std::isnan(value)) return value;

  return HTMLInputElement::FromNode(mContent)->GetMaximum().toDouble();
}

double HTMLSpinnerAccessible::MinValue() const {
  double value = HTMLTextFieldAccessible::MinValue();
  if (!std::isnan(value)) return value;

  return HTMLInputElement::FromNode(mContent)->GetMinimum().toDouble();
}

double HTMLSpinnerAccessible::Step() const {
  double value = HTMLTextFieldAccessible::Step();
  if (!std::isnan(value)) return value;

  return HTMLInputElement::FromNode(mContent)->GetStep().toDouble();
}

double HTMLSpinnerAccessible::CurValue() const {
  double value = HTMLTextFieldAccessible::CurValue();
  if (!std::isnan(value)) return value;

  return HTMLInputElement::FromNode(mContent)->GetValueAsDecimal().toDouble();
}

bool HTMLSpinnerAccessible::SetCurValue(double aValue) {
  ErrorResult er;
  HTMLInputElement::FromNode(mContent)->SetValueAsNumber(aValue, er);
  return !er.Failed();
}

////////////////////////////////////////////////////////////////////////////////
// HTMLRangeAccessible
////////////////////////////////////////////////////////////////////////////////

role HTMLRangeAccessible::NativeRole() const { return roles::SLIDER; }

bool HTMLRangeAccessible::IsWidget() const { return true; }

void HTMLRangeAccessible::Value(nsString& aValue) const {
  LeafAccessible::Value(aValue);
  if (!aValue.IsEmpty()) return;

  // Pass NonSystem as the caller type, to be safe.  We don't expect to have a
  // file input here.
  HTMLInputElement::FromNode(mContent)->GetValue(aValue, CallerType::NonSystem);
}

double HTMLRangeAccessible::MaxValue() const {
  double value = LeafAccessible::MaxValue();
  if (!std::isnan(value)) return value;

  return HTMLInputElement::FromNode(mContent)->GetMaximum().toDouble();
}

double HTMLRangeAccessible::MinValue() const {
  double value = LeafAccessible::MinValue();
  if (!std::isnan(value)) return value;

  return HTMLInputElement::FromNode(mContent)->GetMinimum().toDouble();
}

double HTMLRangeAccessible::Step() const {
  double value = LeafAccessible::Step();
  if (!std::isnan(value)) return value;

  return HTMLInputElement::FromNode(mContent)->GetStep().toDouble();
}

double HTMLRangeAccessible::CurValue() const {
  double value = LeafAccessible::CurValue();
  if (!std::isnan(value)) return value;

  return HTMLInputElement::FromNode(mContent)->GetValueAsDecimal().toDouble();
}

bool HTMLRangeAccessible::SetCurValue(double aValue) {
  nsAutoString strValue;
  strValue.AppendFloat(aValue);
  HTMLInputElement::FromNode(mContent)->SetUserInput(
      strValue, *nsContentUtils::GetSystemPrincipal());
  return true;
}

////////////////////////////////////////////////////////////////////////////////
// HTMLGroupboxAccessible
////////////////////////////////////////////////////////////////////////////////

HTMLGroupboxAccessible::HTMLGroupboxAccessible(nsIContent* aContent,
                                               DocAccessible* aDoc)
    : HyperTextAccessible(aContent, aDoc) {}

role HTMLGroupboxAccessible::NativeRole() const { return roles::GROUPING; }

nsIContent* HTMLGroupboxAccessible::GetLegend() const {
  for (nsIContent* legendContent = mContent->GetFirstChild(); legendContent;
       legendContent = legendContent->GetNextSibling()) {
    if (legendContent->NodeInfo()->Equals(nsGkAtoms::legend,
                                          mContent->GetNameSpaceID())) {
      // Either XHTML namespace or no namespace
      return legendContent;
    }
  }

  return nullptr;
}

ENameValueFlag HTMLGroupboxAccessible::NativeName(nsString& aName) const {
  ENameValueFlag nameFlag = LocalAccessible::NativeName(aName);
  if (!aName.IsEmpty()) return nameFlag;

  nsIContent* legendContent = GetLegend();
  if (legendContent) {
    nsTextEquivUtils::AppendTextEquivFromContent(this, legendContent, &aName);
  }

  aName.CompressWhitespace();
  return eNameOK;
}

Relation HTMLGroupboxAccessible::RelationByType(RelationType aType) const {
  Relation rel = HyperTextAccessible::RelationByType(aType);
  // No override for label, so use <legend> for this <fieldset>
  if (aType == RelationType::LABELLED_BY) rel.AppendTarget(mDoc, GetLegend());

  return rel;
}

////////////////////////////////////////////////////////////////////////////////
// HTMLLegendAccessible
////////////////////////////////////////////////////////////////////////////////

HTMLLegendAccessible::HTMLLegendAccessible(nsIContent* aContent,
                                           DocAccessible* aDoc)
    : HyperTextAccessible(aContent, aDoc) {}

Relation HTMLLegendAccessible::RelationByType(RelationType aType) const {
  Relation rel = HyperTextAccessible::RelationByType(aType);
  if (aType != RelationType::LABEL_FOR) return rel;

  LocalAccessible* groupbox = LocalParent();
  if (groupbox && groupbox->Role() == roles::GROUPING) {
    rel.AppendTarget(groupbox);
  }

  return rel;
}

////////////////////////////////////////////////////////////////////////////////
// HTMLFigureAccessible
////////////////////////////////////////////////////////////////////////////////

HTMLFigureAccessible::HTMLFigureAccessible(nsIContent* aContent,
                                           DocAccessible* aDoc)
    : HyperTextAccessible(aContent, aDoc) {}

ENameValueFlag HTMLFigureAccessible::NativeName(nsString& aName) const {
  ENameValueFlag nameFlag = HyperTextAccessible::NativeName(aName);
  if (!aName.IsEmpty()) return nameFlag;

  nsIContent* captionContent = Caption();
  if (captionContent) {
    nsTextEquivUtils::AppendTextEquivFromContent(this, captionContent, &aName);
  }

  aName.CompressWhitespace();
  return eNameOK;
}

Relation HTMLFigureAccessible::RelationByType(RelationType aType) const {
  Relation rel = HyperTextAccessible::RelationByType(aType);
  if (aType == RelationType::LABELLED_BY) rel.AppendTarget(mDoc, Caption());

  return rel;
}

nsIContent* HTMLFigureAccessible::Caption() const {
  for (nsIContent* childContent = mContent->GetFirstChild(); childContent;
       childContent = childContent->GetNextSibling()) {
    if (childContent->NodeInfo()->Equals(nsGkAtoms::figcaption,
                                         mContent->GetNameSpaceID())) {
      return childContent;
    }
  }

  return nullptr;
}

////////////////////////////////////////////////////////////////////////////////
// HTMLFigcaptionAccessible
////////////////////////////////////////////////////////////////////////////////

HTMLFigcaptionAccessible::HTMLFigcaptionAccessible(nsIContent* aContent,
                                                   DocAccessible* aDoc)
    : HyperTextAccessible(aContent, aDoc) {}

Relation HTMLFigcaptionAccessible::RelationByType(RelationType aType) const {
  Relation rel = HyperTextAccessible::RelationByType(aType);
  if (aType != RelationType::LABEL_FOR) return rel;

  LocalAccessible* figure = LocalParent();
  if (figure && figure->GetContent()->NodeInfo()->Equals(
                    nsGkAtoms::figure, mContent->GetNameSpaceID())) {
    rel.AppendTarget(figure);
  }

  return rel;
}

////////////////////////////////////////////////////////////////////////////////
// HTMLProgressAccessible
////////////////////////////////////////////////////////////////////////////////

role HTMLProgressAccessible::NativeRole() const { return roles::PROGRESSBAR; }

uint64_t HTMLProgressAccessible::NativeState() const {
  uint64_t state = LeafAccessible::NativeState();
  // Progress bars are always readonly.
  state |= states::READONLY;

  // An undetermined progressbar (i.e. without a value) has a mixed state.
  nsAutoString attrValue;
  mContent->AsElement()->GetAttr(nsGkAtoms::value, attrValue);
  if (attrValue.IsEmpty()) {
    state |= states::MIXED;
  }

  return state;
}

bool HTMLProgressAccessible::IsWidget() const { return true; }

void HTMLProgressAccessible::Value(nsString& aValue) const {
  LeafAccessible::Value(aValue);
  if (!aValue.IsEmpty()) {
    return;
  }

  double maxValue = MaxValue();
  if (std::isnan(maxValue) || maxValue == 0) {
    return;
  }

  double curValue = CurValue();
  if (std::isnan(curValue)) {
    return;
  }

  // Treat the current value bigger than maximum as 100%.
  double percentValue =
      (curValue < maxValue) ? (curValue / maxValue) * 100 : 100;

  aValue.AppendFloat(percentValue);
  aValue.Append('%');
}

double HTMLProgressAccessible::MaxValue() const {
  double value = LeafAccessible::MaxValue();
  if (!std::isnan(value)) {
    return value;
  }

  nsAutoString strValue;
  if (mContent->AsElement()->GetAttr(nsGkAtoms::max, strValue)) {
    nsresult result = NS_OK;
    value = strValue.ToDouble(&result);
    if (NS_SUCCEEDED(result)) {
      return value;
    }
  }

  return 1;
}

double HTMLProgressAccessible::MinValue() const {
  double value = LeafAccessible::MinValue();
  return std::isnan(value) ? 0 : value;
}

double HTMLProgressAccessible::Step() const {
  double value = LeafAccessible::Step();
  return std::isnan(value) ? 0 : value;
}

double HTMLProgressAccessible::CurValue() const {
  double value = LeafAccessible::CurValue();
  if (!std::isnan(value)) {
    return value;
  }

  nsAutoString attrValue;
  if (!mContent->AsElement()->GetAttr(nsGkAtoms::value, attrValue)) {
    return UnspecifiedNaN<double>();
  }

  nsresult error = NS_OK;
  value = attrValue.ToDouble(&error);
  return NS_FAILED(error) ? UnspecifiedNaN<double>() : value;
}

bool HTMLProgressAccessible::SetCurValue(double aValue) {
  return false;  // progress meters are readonly.
}

void HTMLProgressAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
                                                 nsAtom* aAttribute,
                                                 int32_t aModType,
                                                 const nsAttrValue* aOldValue,
                                                 uint64_t aOldState) {
  LeafAccessible::DOMAttributeChanged(aNameSpaceID, aAttribute, aModType,
                                      aOldValue, aOldState);

  if (aAttribute == nsGkAtoms::value) {
    mDoc->FireDelayedEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE, this);

    uint64_t currState = NativeState();
    if ((aOldState ^ currState) & states::MIXED) {
      RefPtr<AccEvent> stateChangeEvent = new AccStateChangeEvent(
          this, states::MIXED, (currState & states::MIXED));
      mDoc->FireDelayedEvent(stateChangeEvent);
    }
  }
}

////////////////////////////////////////////////////////////////////////////////
// HTMLMeterAccessible
////////////////////////////////////////////////////////////////////////////////

role HTMLMeterAccessible::NativeRole() const { return roles::METER; }

bool HTMLMeterAccessible::IsWidget() const { return true; }

void HTMLMeterAccessible::Value(nsString& aValue) const {
  LeafAccessible::Value(aValue);
  if (!aValue.IsEmpty()) {
    return;
  }

  // If we did not get a value from the above LeafAccessible call,
  // we should check to see if the meter has inner text.
  // If it does, we'll use that as our value.
  nsTextEquivUtils::AppendFromDOMChildren(mContent, &aValue);
  aValue.CompressWhitespace();
  if (!aValue.IsEmpty()) {
    return;
  }

  // If no inner text is found, use curValue
  double curValue = CurValue();
  if (std::isnan(curValue)) {
    return;
  }

  aValue.AppendFloat(curValue);
}

double HTMLMeterAccessible::MaxValue() const {
  double max = LeafAccessible::MaxValue();
  double min = MinValue();

  if (!std::isnan(max)) {
    return max > min ? max : min;
  }

  // If we didn't find a max value, check for the max attribute
  nsAutoString strValue;
  if (mContent->AsElement()->GetAttr(nsGkAtoms::max, strValue)) {
    nsresult result = NS_OK;
    max = strValue.ToDouble(&result);
    if (NS_SUCCEEDED(result)) {
      return max > min ? max : min;
    }
  }

  return 1 > min ? 1 : min;
}

double HTMLMeterAccessible::MinValue() const {
  double min = LeafAccessible::MinValue();
  if (!std::isnan(min)) {
    return min;
  }

  nsAutoString strValue;
  if (mContent->AsElement()->GetAttr(nsGkAtoms::min, strValue)) {
    nsresult result = NS_OK;
    min = strValue.ToDouble(&result);
    if (NS_SUCCEEDED(result)) {
      return min;
    }
  }

  return 0;
}

double HTMLMeterAccessible::CurValue() const {
  double value = LeafAccessible::CurValue();
  double minValue = MinValue();

  if (std::isnan(value)) {
    /* If we didn't find a value from the LeafAccessible call above, check
     * for a value attribute */
    nsAutoString attrValue;
    if (!mContent->AsElement()->GetAttr(nsGkAtoms::value, attrValue)) {
      return minValue;
    }

    // If we find a value attribute, attempt to convert it to a double
    nsresult error = NS_OK;
    value = attrValue.ToDouble(&error);
    if (NS_FAILED(error)) {
      return minValue;
    }
  }

  /* If we end up with a defined value, verify it falls between
   * our established min/max. Otherwise, snap it to the nearest boundary. */
  double maxValue = MaxValue();
  if (value > maxValue) {
    value = maxValue;
  } else if (value < minValue) {
    value = minValue;
  }

  return value;
}

bool HTMLMeterAccessible::SetCurValue(double aValue) {
  return false;  // meters are readonly.
}

int32_t HTMLMeterAccessible::ValueRegion() const {
  dom::HTMLMeterElement* elm = dom::HTMLMeterElement::FromNode(mContent);
  if (!elm) {
    return -1;
  }
  double high = elm->High();
  double low = elm->Low();
  double optimum = elm->Optimum();
  double value = elm->Value();
  // For more information on how these regions are defined, see
  // "UA requirements for regions of the gauge"
  // https://html.spec.whatwg.org/multipage/form-elements.html#the-meter-element
  if (optimum > high) {
    if (value > high) {
      return 1;
    }
    return value > low ? 0 : -1;
  }
  if (optimum < low) {
    if (value < low) {
      return 1;
    }
    return value < high ? 0 : -1;
  }
  // optimum is between low and high, inclusive
  if (value >= low && value <= high) {
    return 1;
  }
  // Both upper and lower regions are considered equally
  // non-optimal.
  return 0;
}

void HTMLMeterAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
                                              nsAtom* aAttribute,
                                              int32_t aModType,
                                              const nsAttrValue* aOldValue,
                                              uint64_t aOldState) {
  LeafAccessible::DOMAttributeChanged(aNameSpaceID, aAttribute, aModType,
                                      aOldValue, aOldState);

  if (aAttribute == nsGkAtoms::value) {
    mDoc->FireDelayedEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE, this);
  }

  if (aAttribute == nsGkAtoms::high || aAttribute == nsGkAtoms::low ||
      aAttribute == nsGkAtoms::optimum) {
    // Our meter's value region may have changed, queue an update for
    // the value domain.
    mDoc->QueueCacheUpdate(this, CacheDomain::Value);
    return;
  }
}
