/*
    * Copyright (c) 2002-2026 Gargoyle Software Inc.
    *
    * 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
    * https://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.
   */
  package org.htmlunit.html;
  
  import static org.htmlunit.BrowserVersionFeatures.HTMLINPUT_TYPE_MONTH_SUPPORTED;
  import static org.htmlunit.BrowserVersionFeatures.HTMLINPUT_TYPE_WEEK_SUPPORTED;
  import static org.htmlunit.html.HtmlForm.ATTRIBUTE_FORMNOVALIDATE;
  
  import java.net.MalformedURLException;
  import java.util.Map;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.htmlunit.BrowserVersion;
  import org.htmlunit.HttpHeader;
  import org.htmlunit.Page;
  import org.htmlunit.ScriptResult;
  import org.htmlunit.SgmlPage;
  import org.htmlunit.WebClient;
  import org.htmlunit.corejs.javascript.Context;
  import org.htmlunit.corejs.javascript.regexp.RegExpEngineAccess;
  import org.htmlunit.javascript.AbstractJavaScriptEngine;
  import org.htmlunit.javascript.HtmlUnitContextFactory;
  import org.htmlunit.javascript.host.event.Event;
  import org.htmlunit.javascript.host.event.MouseEvent;
  import org.htmlunit.javascript.host.html.HTMLInputElement;
  import org.htmlunit.util.NameValuePair;
  import org.htmlunit.util.StringUtils;
  import org.xml.sax.helpers.AttributesImpl;
  
  /**
   * Wrapper for the HTML element "input".
   *
   * @author Mike Bowler
   * @author David K. Taylor
   * @author Christian Sell
   * @author David D. Kilzer
   * @author Marc Guillemot
   * @author Daniel Gredler
   * @author Ahmed Ashour
   * @author Ronald Brill
   * @author Frank Danek
   * @author Anton Demydenko
   * @author Ronny Shapiro
   * @author Lai Quang Duong
   */
  public abstract class HtmlInput extends HtmlElement implements DisabledElement, SubmittableElement,
      ValidatableHtmlElement  {
  
      private static final Log LOG = LogFactory.getLog(HtmlInput.class);
  
      /** The HTML tag represented by this element. */
      public static final String TAG_NAME = "input";
  
      /**
       * The element's raw value (spec term), decoupled from the DOM child nodes
       * once {@link #isValueDirty_} is {@code true}. Mirrors {@code HtmlInput}'s
       * dirty-value-flag model rather than reading/writing child text nodes directly.
       */
      private String rawValue_;
  
      /**
       * The dirty value flag (spec term). While {@code false}, the raw value tracks
       * the element's child text content automatically. Once {@code true} (set by
       * the {@code value} setter, or by a user edit/type), child mutations no
       * longer affect the raw value until {@link #reset()} clears the flag again.
       */
      private boolean isValueDirty_;
  
      private boolean valueModifiedByJavascript_;
      private Object valueAtFocus_;
      private String customValidity_;
  
      /**
       * Creates an instance.
       *
       * @param page the page that contains this element
       * @param attributes the initial attributes
       */
      public HtmlInput(final SgmlPage page, final Map<String, DomAttr> attributes) {
          this(TAG_NAME, page, attributes);
      }
  
      /**
       * Creates an instance.
       *
       * @param qualifiedName the qualified name of the element type to instantiate
      * @param page the page that contains this element
      * @param attributes the initial attributes
      */
     public HtmlInput(final String qualifiedName, final SgmlPage page,
             final Map<String, DomAttr> attributes) {
         super(qualifiedName, page, attributes);
         rawValue_ = getValueAttribute();
     }
 
     /**
      * Sets the content of the {@code value} attribute.
      *
      * @param newValue the new value
      */
     public void setValueAttribute(final String newValue) {
         super.setAttribute(VALUE_ATTRIBUTE, newValue);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public NameValuePair[] getSubmitNameValuePairs() {
         return new NameValuePair[]{new NameValuePair(getNameAttribute(), getValue())};
     }
 
     /**
      * Returns the value of the attribute {@code type}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code type} or an empty string if that attribute isn't defined
      */
     public final String getTypeAttribute() {
         final String type = getAttributeDirect(TYPE_ATTRIBUTE);
         if (ATTRIBUTE_NOT_DEFINED == type) {
             return "text";
         }
         return type;
     }
 
     /**
      * Returns the value of the attribute {@code name}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code name} or an empty string if that attribute isn't defined
      */
     public final String getNameAttribute() {
         return getAttributeDirect(NAME_ATTRIBUTE);
     }
 
     /**
      * <p>Return the value of the attribute "value". Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.</p>
      *
      * @return the value of the attribute {@code value} or an empty string if that attribute isn't defined
      */
     public final String getValueAttribute() {
         return getAttributeDirect(VALUE_ATTRIBUTE);
     }
 
     /**
      * Returns the value.
      *
      * @return the value
      */
     public String getValue() {
         return getRawValue();
     }
 
     /**
      * Sets the value.
      *
      * @param newValue the new value
      */
     public void setValue(final String newValue) {
         setRawValue(newValue);
         isValueDirty_ = true;
     }
 
     protected void valueAttributeChanged(final String attributeValue, final boolean isValueDirty) {
         if (!isValueDirty) {
             setRawValue(attributeValue);
         }
     }
 
     /**
      * Returns the value of the attribute {@code checked}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code checked} or an empty string if that attribute isn't defined
      */
     public final String getCheckedAttribute() {
         return getAttributeDirect(ATTRIBUTE_CHECKED);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public final String getDisabledAttribute() {
         return getAttributeDirect(ATTRIBUTE_DISABLED);
     }
 
     /**
      * Returns the value of the attribute {@code readonly}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code readonly}
      *         or an empty string if that attribute isn't defined.
      */
     public final String getReadOnlyAttribute() {
         return getAttributeDirect(ATTRIBUTE_READONLY);
     }
 
     /**
      * Returns the value of the attribute {@code size}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code size}
      *         or an empty string if that attribute isn't defined.
      */
     public final String getSizeAttribute() {
         return getAttributeDirect("size");
     }
 
     /**
      * Returns the value of the attribute {@code maxlength}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code maxlength}
      *         or an empty string if that attribute isn't defined.
      */
     public final String getMaxLengthAttribute() {
         return getAttributeDirect("maxlength");
     }
 
     /**
      * Gets the max length if defined, Integer.MAX_VALUE if none.
      * @return the max length
      */
     protected int getMaxLength() {
         final String maxLength = getMaxLengthAttribute();
         if (maxLength.isEmpty()) {
             return Integer.MAX_VALUE;
         }
 
         try {
             return Integer.parseInt(maxLength.trim());
         }
         catch (final NumberFormatException e) {
             return Integer.MAX_VALUE;
         }
     }
 
     /**
      * Returns the value of the attribute {@code minlength}. Refer to the
      * <a href="https://www.w3.org/TR/html5/sec-forms.html">HTML 5</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code minlength}
      *         or an empty string if that attribute isn't defined.
      */
     public final String getMinLengthAttribute() {
         return getAttributeDirect("minlength");
     }
 
     /**
      * Gets the min length if defined, Integer.MIN_VALUE if none.
      * @return the min length
      */
     protected int getMinLength() {
         final String minLength = getMinLengthAttribute();
         if (minLength.isEmpty()) {
             return Integer.MIN_VALUE;
         }
 
         try {
             return Integer.parseInt(minLength.trim());
         }
         catch (final NumberFormatException e) {
             return Integer.MIN_VALUE;
         }
     }
 
     /**
      * Returns the value of the attribute {@code src}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code src}
      *         or an empty string if that attribute isn't defined.
      */
     public String getSrcAttribute() {
         return getSrcAttributeNormalized();
     }
 
     /**
      * Returns the value of the {@code src} value.
      * @return the value of the {@code src} value
      */
     public String getSrc() {
         final String src = getSrcAttributeNormalized();
         if (ATTRIBUTE_NOT_DEFINED == src) {
             return src;
         }
 
         final HtmlPage page = getHtmlPageOrNull();
         if (page != null) {
             try {
                 return page.getFullyQualifiedUrl(src).toExternalForm();
             }
             catch (final MalformedURLException e) {
                 // Log the error and fall through to the return values below.
                 if (LOG.isWarnEnabled()) {
                     LOG.warn(e.getMessage(), e);
                 }
             }
         }
         return src;
     }
 
     /**
      * Sets the {@code src} attribute.
      *
      * @param src the {@code src} attribute
      */
     public void setSrcAttribute(final String src) {
         setAttribute(SRC_ATTRIBUTE, src);
     }
 
     /**
      * Returns the value of the attribute {@code alt}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code alt}
      *         or an empty string if that attribute isn't defined.
      */
     public final String getAltAttribute() {
         return getAttributeDirect("alt");
     }
 
     /**
      * Returns the value of the attribute {@code usemap}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code usemap}
      *         or an empty string if that attribute isn't defined.
      */
     public final String getUseMapAttribute() {
         return getAttributeDirect("usemap");
     }
 
     /**
      * Returns the value of the attribute {@code tabindex}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code tabindex}
      *        or an empty string if that attribute isn't defined.
      */
     public final String getTabIndexAttribute() {
         return getAttributeDirect("tabindex");
     }
 
     /**
      * Returns the value of the attribute {@code accesskey}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code accesskey}
      *         or an empty string if that attribute isn't defined.
      */
     public final String getAccessKeyAttribute() {
         return getAttributeDirect("accesskey");
     }
 
     /**
      * Returns the value of the attribute {@code onfocus}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code onfocus}
      *         or an empty string if that attribute isn't defined.
      */
     public final String getOnFocusAttribute() {
         return getAttributeDirect("onfocus");
     }
 
     /**
      * Returns the value of the attribute {@code onblur}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code onblur}
      *         or an empty string if that attribute isn't defined.
      */
     public final String getOnBlurAttribute() {
         return getAttributeDirect("onblur");
     }
 
     /**
      * Returns the value of the attribute {@code onselect}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code onselect}
      *         or an empty string if that attribute isn't defined.
      */
     public final String getOnSelectAttribute() {
         return getAttributeDirect("onselect");
     }
 
     /**
      * Returns the value of the attribute {@code onchange}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code onchange}
      *         or an empty string if that attribute isn't defined.
      */
     public final String getOnChangeAttribute() {
         return getAttributeDirect("onchange");
     }
 
     /**
      * Returns the value of the attribute {@code accept}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code accept}
      *         or an empty string if that attribute isn't defined.
      */
     public final String getAcceptAttribute() {
         return getAttribute(HttpHeader.ACCEPT_LC);
     }
 
     /**
      * Returns the value of the attribute {@code align}. Refer to the
      * <a href="http://www.w3.org/TR/html401/">HTML 4.01</a>
      * documentation for details on the use of this attribute.
      *
      * @return the value of the attribute {@code align}
      *         or an empty string if that attribute isn't defined.
      */
     public final String getAlignAttribute() {
         return getAttributeDirect("align");
     }
 
     /**
      * {@inheritDoc}
      * @see SubmittableElement#reset()
      */
     @Override
     public void reset() {
         setValue(getDefaultValue());
         isValueDirty_ = false;
     }
 
     /**
      * {@inheritDoc}
      *
      * @see SubmittableElement#setDefaultValue(String)
      */
     @Override
     public void setDefaultValue(final String defaultValue) {
         setValueAttribute(defaultValue);
     }
 
     /**
      * {@inheritDoc}
      * @see SubmittableElement#getDefaultValue()
      */
     @Override
     public String getDefaultValue() {
         return getValueAttribute();
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * @return the raw value
      */
     public String getRawValue() {
         return rawValue_;
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Update the raw value.
      * @param rawValue the new raw value
      */
     public void setRawValue(final String rawValue) {
         rawValue_ = rawValue;
     }
 
     /**
      * {@inheritDoc} The default implementation returns {@code false}; only checkboxes and
      * radio buttons really care what the default checked value is.
      * @see SubmittableElement#isDefaultChecked()
      * @see HtmlRadioButtonInput#isDefaultChecked()
      * @see HtmlCheckBoxInput#isDefaultChecked()
      */
     @Override
     public boolean isDefaultChecked() {
         return false;
     }
 
     /**
      * Sets the {@code checked} attribute, returning the page that occupies this input's window after setting
      * the attribute. Note that the returned page may or may not be the original page, depending on
      * the presence of JavaScript event handlers, etc.
      *
      * @param isChecked {@code true} if this element is to be selected
      * @return the page that occupies this input's window after setting the attribute
      */
     public Page setChecked(final boolean isChecked) {
         // By default, this returns the current page. Derived classes will override.
         return getPage();
     }
 
     /**
      * Sets the {@code readOnly} attribute.
      *
      * @param isReadOnly {@code true} if this element is read only
      */
     public void setReadOnly(final boolean isReadOnly) {
         if (isReadOnly) {
             setAttribute(ATTRIBUTE_READONLY, "");
         }
         else {
             removeAttribute(ATTRIBUTE_READONLY);
         }
     }
 
     /**
      * Returns {@code true} if this element is currently selected.
      * @return {@code true} if this element is currently selected
      */
     public boolean isChecked() {
         return hasAttribute(ATTRIBUTE_CHECKED);
     }
 
     /**
      * Returns {@code true} if this element is read only.
      * @return {@code true} if this element is read only
      */
     public boolean isReadOnly() {
         return hasAttribute(ATTRIBUTE_READONLY);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     protected boolean propagateClickStateUpdateToParent() {
         return true;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean handles(final Event event) {
         if (event instanceof MouseEvent) {
             return true;
         }
 
         return super.handles(event);
     }
 
     /**
      * Executes the onchange script code for this element if this is appropriate.
      * This means that the element must have an onchange script, script must be enabled
      * and the change in the element must not have been triggered by a script.
      *
      * @param htmlElement the element that contains the onchange attribute
      * @return the page that occupies this window after this method completes (may or
      *         may not be the same as the original page)
      */
     static Page executeOnChangeHandlerIfAppropriate(final HtmlElement htmlElement) {
         final SgmlPage page = htmlElement.getPage();
         final WebClient webClient = page.getWebClient();
 
         if (!webClient.isJavaScriptEngineEnabled()) {
             return page;
         }
 
         final AbstractJavaScriptEngine<?> engine = webClient.getJavaScriptEngine();
         if (engine.isScriptRunning()) {
             return page;
         }
         final ScriptResult scriptResult = htmlElement.fireEvent(Event.TYPE_CHANGE);
 
         if (webClient.containsWebWindow(page.getEnclosingWindow())) {
             // may be itself or a newly loaded one
             return page.getEnclosingWindow().getEnclosedPage();
         }
 
         if (scriptResult != null) {
             // current window doesn't exist anymore
             return webClient.getCurrentWindow().getEnclosedPage();
         }
 
         return page;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     protected void setAttributeNS(final String namespaceURI, final String qualifiedName, final String attributeValue,
             final boolean notifyAttributeChangeListeners, final boolean notifyMutationObservers) {
         final String qualifiedNameLC = StringUtils.toRootLowerCase(qualifiedName);
 
         if (TYPE_ATTRIBUTE.equals(qualifiedNameLC)) {
             changeType(attributeValue, true);
             return;
         }
 
         if (VALUE_ATTRIBUTE.equals(qualifiedNameLC)) {
             super.setAttributeNS(namespaceURI, qualifiedNameLC, attributeValue, notifyAttributeChangeListeners,
                     notifyMutationObservers);
 
             valueAttributeChanged(attributeValue, isValueDirty_);
             return;
         }
 
         super.setAttributeNS(namespaceURI, qualifiedNameLC, attributeValue, notifyAttributeChangeListeners,
                 notifyMutationObservers);
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Marks this element as modified (value) by javascript. This is needed
      * to support maxlength/minlength validation.
      */
     public void valueModifiedByJavascript() {
         valueModifiedByJavascript_ = true;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public final void focus() {
         super.focus();
         // store current value to trigger onchange when needed at focus lost
         valueAtFocus_ = getInternalValue();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public final void removeFocus() {
         super.removeFocus();
 
         if (valueAtFocus_ != null && !valueAtFocus_.equals(getInternalValue())) {
             handleFocusLostValueChanged();
         }
         valueAtFocus_ = null;
     }
 
     void handleFocusLostValueChanged() {
         executeOnChangeHandlerIfAppropriate(this);
     }
 
     /**
      * Returns returns the raw value.
      *
      * @return returns the raw value
      */
     protected Object getInternalValue() {
         return getRawValue();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public DisplayStyle getDefaultStyleDisplay() {
         return DisplayStyle.INLINE_BLOCK;
     }
 
     /**
      * Returns the value of the {@code size} attribute.
      *
      * @return the value of the {@code size} attribute
      */
     public String getSize() {
         return getAttributeDirect("size");
     }
 
     /**
      * Sets the {@code size} attribute.
      *
      * @param size the {@code size} attribute
      */
     public void setSize(final String size) {
         setAttribute("size", size);
     }
 
     /**
      * Sets the {@code maxLength} attribute.
      *
      * @param maxLength the {@code maxLength} attribute
      */
     public void setMaxLength(final int maxLength) {
         setAttribute("maxLength", String.valueOf(maxLength));
     }
 
     /**
      * Sets the {@code minLength} attribute.
      *
      * @param minLength the {@code minLength} attribute
      */
     public void setMinLength(final int minLength) {
         setAttribute("minLength", String.valueOf(minLength));
     }
 
     /**
      * Returns the value of the {@code accept} attribute.
      *
      * @return the value of the {@code accept} attribute
      */
     public String getAccept() {
         return getAttribute(HttpHeader.ACCEPT_LC);
     }
 
     /**
      * Sets the {@code accept} attribute.
      *
      * @param accept the {@code accept} attribute
      */
     public void setAccept(final String accept) {
         setAttribute(HttpHeader.ACCEPT_LC, accept);
     }
 
     /**
      * Returns the value of the {@code autocomplete} attribute.
      *
      * @return the value of the {@code autocomplete} attribute
      */
     public String getAutocomplete() {
         return getAttributeDirect("autocomplete");
     }
 
     /**
      * Sets the {@code autocomplete} attribute.
      *
      * @param autocomplete the {@code autocomplete} attribute
      */
     public void setAutocomplete(final String autocomplete) {
         setAttribute("autocomplete", autocomplete);
     }
 
     /**
      * Returns the value of the {@code placeholder} attribute.
      *
      * @return the value of the {@code placeholder} attribute
      */
     public String getPlaceholder() {
         return getAttributeDirect("placeholder");
     }
 
     /**
      * Sets the {@code placeholder} attribute.
      *
      * @param placeholder the {@code placeholder} attribute
      */
     public void setPlaceholder(final String placeholder) {
         setAttribute("placeholder", placeholder);
     }
 
     /**
      * Returns the value of the {@code pattern} attribute.
      *
      * @return the value of the {@code pattern} attribute
      */
     public String getPattern() {
         return getAttributeDirect("pattern");
     }
 
     /**
      * Sets the {@code pattern} attribute.
      *
      * @param pattern the {@code pattern} attribute
      */
     public void setPattern(final String pattern) {
         setAttribute("pattern", pattern);
     }
 
     /**
      * Returns the value of the {@code min} attribute.
      *
      * @return the value of the {@code min} attribute
      */
     public String getMin() {
         return getAttributeDirect("min");
     }
 
     /**
      * Sets the {@code min} attribute.
      *
      * @param min the {@code min} attribute
      */
     public void setMin(final String min) {
         setAttribute("min", min);
     }
 
     /**
      * Returns the value of the {@code max} attribute.
      *
      * @return the value of the {@code max} attribute
      */
     public String getMax() {
         return getAttributeDirect("max");
     }
 
     /**
      * Sets the {@code max} attribute.
      *
      * @param max the {@code max} attribute
      */
     public void setMax(final String max) {
         setAttribute("max", max);
     }
 
     /**
      * Returns the value of the {@code step} attribute.
      *
      * @return the value of the {@code step} attribute
      */
     public String getStep() {
         return getAttributeDirect("step");
     }
 
     /**
      * Sets the {@code step} attribute.
      *
      * @param step the {@code step} attribute
      */
     public void setStep(final String step) {
         setAttribute("step", step);
     }
 
     @Override
     public boolean isValid() {
         return !isValueMissingValidityState()
                 && isCustomValidityValid()
                 && isMaxLengthValid() && isMinLengthValid()
                 && !hasPatternMismatchValidityState()
                 && !hasTypeMismatchValidityState()
                 && !hasRangeOverflowValidityState()
                 && !hasRangeUnderflowValidityState()
                 && !isStepMismatchValidityState()
                 && !hasBadInputValidityState();
     }
 
     protected boolean isCustomValidityValid() {
         return !isCustomErrorValidityState();
     }
 
     @Override
     protected boolean isRequiredSupported() {
         return true;
     }
 
     /**
      * Returns if the input element supports pattern validation. Refer to the
      * <a href="https://www.w3.org/TR/html5/sec-forms.html">HTML 5</a> documentation
      * for details.
      * @return if the input element supports pattern validation
      */
     protected boolean isPatternSupported() {
         return false;
     }
 
     /**
      * Returns if the element executes pattern validation on blank strings.
      *
      * @return if the element executes pattern validation on blank strings
      */
     protected boolean isBlankPatternValidated() {
         return true;
     }
 
     /**
      * Returns if the input element supports maxlength minlength validation. Refer to the
      * <a href="https://www.w3.org/TR/html5/sec-forms.html">HTML 5</a> documentation
      * for details.
      * @return if the input element supports pattern validation
      */
     protected boolean isMinMaxLengthSupported() {
         return false;
     }
 
     /**
      * Returns if the input element has a maximum allowed value length. Refer to the
      * <a href="https://www.w3.org/TR/html5/sec-forms.html">HTML 5</a>
      * documentation for details.
      *
      * @return if the input element has a maximum allowed value length
      */
     private boolean isMaxLengthValid() {
         if (!isMinMaxLengthSupported()
                 || valueModifiedByJavascript_
                 || getMaxLength() == Integer.MAX_VALUE
                 || getDefaultValue().equals(getValue())) {
             return true;
         }
 
         return getValue().length() <= getMaxLength();
     }
 
     /**
      * Returns if the input element has a minimum allowed value length. Refer to the
      * <a href="https://www.w3.org/TR/html5/sec-forms.html">HTML 5</a>
      * documentation for details.
      *
      * @return if the input element has a minimum allowed value length
      */
     private boolean isMinLengthValid() {
         if (!isMinMaxLengthSupported()
                 || valueModifiedByJavascript_
                 || getMinLength() == Integer.MIN_VALUE
                 || getDefaultValue().equals(getValue())) {
             return true;
         }
 
         return getValue().length() >= getMinLength();
     }
 
     /**
      * Returns if the input element has a valid value pattern. Refer to the
      * <a href="https://www.w3.org/TR/html5/sec-forms.html">HTML 5</a> documentation
      * for details.
      *
      * @return if the input element has a valid value pattern
      */
     private boolean isPatternValid() {
         if (!isPatternSupported()) {
             return true;
         }
 
         final String pattern = getPattern();
         if (StringUtils.isEmptyOrNull(pattern)) {
             return true;
         }
 
         final String value = getValue();
         if (StringUtils.isEmptyOrNull(value)) {
             return true;
         }
         if (!isBlankPatternValidated() && StringUtils.isBlank(value)) {
             return true;
         }
 
         try (Context cx = HtmlUnitContextFactory.getGlobal().enterContext()) {
             // compile the raw pattern first: this is a validity check only (result discarded).
             // Wrapping with "^(?:...)$ " cannot mask a genuinely invalid pattern -- the wrapper
             // contributes a balanced open/close pair, so any unmatched parent/bracket or other
             // structural defect in the raw pattern persists identically once wrapped.
             RegExpEngineAccess.compile(cx, pattern, "");
 
             final RegExpEngineAccess.CompiledRegExp compiled
                     = RegExpEngineAccess.compile(cx, "^(?:" + pattern + ")$", "");
 
             return RegExpEngineAccess.matches(cx, value, compiled);
         }
         catch (final Exception ignored) {
             // ignore if regex invalid
         }
         return true;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean willValidate() {
         return !isDisabled() && !isReadOnly();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public String getCustomValidity() {
         return customValidity_;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void setCustomValidity(final String message) {
         customValidity_ = message;
     }
 
     /**
      * Returns whether this is a checkbox or a radio button.
      *
      * @return whether this is a checkbox or a radio button
      */
     public boolean isCheckable() {
         final String type = getAttributeDirect(TYPE_ATTRIBUTE);
         return "radio".equalsIgnoreCase(type) || "checkbox".equalsIgnoreCase(type);
     }
 
     /**
      * Returns false for type submit/reset/image/button otherwise true.
      *
      * @return false for type submit/reset/image/button otherwise true
      */
     public boolean isSubmitable() {
         final String type = getAttributeDirect(TYPE_ATTRIBUTE);
         return !"submit".equalsIgnoreCase(type)
                 && !"image".equalsIgnoreCase(type)
                 && !"reset".equalsIgnoreCase(type)
                 && !"button".equalsIgnoreCase(type);
     }
 
     @Override
     public boolean isCustomErrorValidityState() {
         return !StringUtils.isEmptyOrNull(customValidity_);
     }
 
     @Override
     public boolean hasPatternMismatchValidityState() {
         return !isPatternValid();
     }
 
     @Override
     public boolean isTooShortValidityState() {
         if (!isMinMaxLengthSupported()
                 || valueModifiedByJavascript_
                 || getMinLength() == Integer.MIN_VALUE
                 || getDefaultValue().equals(getValue())) {
             return false;
         }
 
         return getValue().length() < getMinLength();
     }
 
     // no need to override isTooLongValidityState()
     // The HTML spec (§4.10.18.5) has a deliberate rule: tooLong only fires
     // if the user has interacted with the field ("the element has a dirty value flag").
     // A value set via JS (elem.value = '...') that was never touched by the user does
     // not set the dirty flag, so tooLong stays false regardless of the value length.
     // see HtmlTextInputTest
     // maxLengthValidationInvalid()/maxLengthValidationInvalidInitial()/maxLengthValidationValid()
     //    @Override
     //    public boolean isTooLongValidityState() {
     //        return false;
     //    }
 
     @Override
     public boolean isValidValidityState() {
         return !isCustomErrorValidityState()
                 && !isValueMissingValidityState()
                 && !isTooLongValidityState()
                 && !isTooShortValidityState()
                 && !hasPatternMismatchValidityState()
                 && !hasTypeMismatchValidityState()
                 && !hasRangeOverflowValidityState()
                 && !hasRangeUnderflowValidityState()
                 && !isStepMismatchValidityState()
                 && !hasBadInputValidityState();
     }
 
     @Override
     public boolean isValueMissingValidityState() {
         return isRequiredSupported()
                 && ATTRIBUTE_NOT_DEFINED != getAttributeDirect(ATTRIBUTE_REQUIRED)
                 && getValue().isEmpty();
     }
 
     /**
      * Returns the value of the attribute {@code formnovalidate} or an empty string if that attribute isn't defined.
      *
      * @return the value of the attribute {@code formnovalidate} or an empty string if that attribute isn't defined
      */
     public final boolean isFormNoValidate() {
         return hasAttribute(ATTRIBUTE_FORMNOVALIDATE);
     }
 
     /**
      * Sets the value of the attribute {@code formnovalidate}.
      *
      * @param noValidate the value of the attribute {@code formnovalidate}
      */
     public final void setFormNoValidate(final boolean noValidate) {
         if (noValidate) {
             setAttribute(ATTRIBUTE_FORMNOVALIDATE, ATTRIBUTE_FORMNOVALIDATE);
         }
         else {
             removeAttribute(ATTRIBUTE_FORMNOVALIDATE);
         }
     }
 
     /**
      * Returns the {@code type} property.
      *
      * @return the {@code type} property
      */
     public final String getType() {
         final BrowserVersion browserVersion = getPage().getWebClient().getBrowserVersion();
         String type = getTypeAttribute();
         type = StringUtils.toRootLowerCase(type);
         return isSupported(type, browserVersion) ? type : "text";
     }
 
     /**
      * <span style="color:red">INTERNAL API - SUBJECT TO CHANGE AT ANY TIME - USE AT YOUR OWN RISK.</span><br>
      *
      * Changes the type of the current HtmlInput. Because there are several subclasses of HtmlInput,
      * changing the type attribute is not sufficient, this will replace the HtmlInput element in the
      * DOM tree with a new one (at least of the newType is different from the old one).<br>
      * The js peer object is still the same (there is only a HTMLInputElement without any sublcasses).<br>
      * This returns the new (or the old) HtmlInput element to ease the use of this method.
      * @param newType the new type to set
      * @param setThroughAttribute set type value through setAttribute()
      * @return the new or the old HtmlInput element
      */
     public HtmlInput changeType(String newType, final boolean setThroughAttribute) {
         final String currentType = getAttributeDirect(TYPE_ATTRIBUTE);
 
         final SgmlPage page = getPage();
         final WebClient webClient = page.getWebClient();
         final BrowserVersion browser = webClient.getBrowserVersion();
         if (!currentType.equalsIgnoreCase(newType)) {
             if (!isSupported(StringUtils.toRootLowerCase(newType), browser)) {
                 if (setThroughAttribute) {
                     newType = "text";
                 }
             }
 
             final AttributesImpl attributes = new AttributesImpl();
             boolean typeFound = false;
             for (final DomAttr entry : getAttributesMap().values()) {
                 final String name = entry.getName();
                 final String value = entry.getValue();
 
                 if (TYPE_ATTRIBUTE.equals(name)) {
                     attributes.addAttribute(null, name, name, null, newType);
                     typeFound = true;
                 }
                 else {
                     attributes.addAttribute(null, name, name, null, value);
                 }
             }
 
             if (!typeFound) {
                 attributes.addAttribute(null, TYPE_ATTRIBUTE, TYPE_ATTRIBUTE, null, newType);
             }
 
             // create a new one only if we have a new type
             if (ATTRIBUTE_NOT_DEFINED != currentType || !"text".equalsIgnoreCase(newType)) {
                 final HtmlInput newInput = (HtmlInput) webClient.getPageCreator().getHtmlParser()
                         .getFactory(TAG_NAME)
                         .createElement(page, TAG_NAME, attributes);
 
                 newInput.adjustValueAfterTypeChange(this, browser);
 
                 // the input hasn't yet been inserted into the DOM tree (likely has been
                 // created via document.createElement()), so simply replace it with the
                 // new Input instance created in the code above
                 if (getParentNode() != null) {
                     getParentNode().replaceChild(newInput, this);
                 }
 
                 final WebClient client = page.getWebClient();
                 if (client.isJavaScriptEngineEnabled()) {
                     final HTMLInputElement scriptable = getScriptableObject();
                     setScriptableObject(null);
                     scriptable.setDomNode(newInput, true);
                 }
 
                 return newInput;
             }
             super.setAttributeNS(null, TYPE_ATTRIBUTE, newType, true, true);
         }
         return this;
     }
 
     protected void adjustValueAfterTypeChange(final HtmlInput oldInput, final BrowserVersion browserVersion) {
         final String originalValue = oldInput.getValue();
         if (ATTRIBUTE_NOT_DEFINED != originalValue) {
             setValue(originalValue);
         }
     }
 
     /**
      * Returns whether the specified type is supported or not.
      * @param type the input type
      * @param browserVersion the browser version
      * @return whether the specified type is supported or not
      */
     private static boolean isSupported(final String type, final BrowserVersion browserVersion) {
         boolean supported = false;
         switch (type) {
             case "month":
                 supported = browserVersion.hasFeature(HTMLINPUT_TYPE_MONTH_SUPPORTED);
                 break;
             case "week":
                 supported = browserVersion.hasFeature(HTMLINPUT_TYPE_WEEK_SUPPORTED);
                 break;
             case "color":
             case "date":
             case "datetime-local":
             case "time":
             case "email":
             case "text":
             case "submit":
             case "checkbox":
             case "radio":
             case "hidden":
             case "password":
             case "image":
             case "reset":
             case "button":
             case "file":
             case "number":
             case "range":
             case "search":
             case "tel":
             case "url":
                 supported = true;
                 break;
 
             default:
         }
         return supported;
     }
 
     protected void unmarkValueDirty() {
         isValueDirty_ = false;
     }
 
     protected void markValueDirty() {
         isValueDirty_ = true;
     }
 }