/*
    * 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.javascript.host;
  
  import java.net.MalformedURLException;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.List;
  import java.util.ListIterator;
  import java.util.Map;
  
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.htmlunit.FormEncodingType;
  import org.htmlunit.WebRequest;
  import org.htmlunit.corejs.javascript.ClassDescriptor;
  import org.htmlunit.corejs.javascript.Context;
  import org.htmlunit.corejs.javascript.ES6Iterator;
  import org.htmlunit.corejs.javascript.EcmaError;
  import org.htmlunit.corejs.javascript.Function;
  import org.htmlunit.corejs.javascript.IteratorLikeIterable;
  import org.htmlunit.corejs.javascript.NativeObject;
  import org.htmlunit.corejs.javascript.ScriptRuntime;
  import org.htmlunit.corejs.javascript.Scriptable;
  import org.htmlunit.corejs.javascript.SymbolKey;
  import org.htmlunit.corejs.javascript.TopLevel;
  import org.htmlunit.corejs.javascript.VarScope;
  import org.htmlunit.javascript.HtmlUnitScriptable;
  import org.htmlunit.javascript.JavaScriptEngine;
  import org.htmlunit.javascript.configuration.JsxClass;
  import org.htmlunit.javascript.configuration.JsxConstructor;
  import org.htmlunit.javascript.configuration.JsxFunction;
  import org.htmlunit.javascript.configuration.JsxGetter;
  import org.htmlunit.javascript.configuration.JsxSymbol;
  import org.htmlunit.javascript.host.xml.FormData.FormDataIterator;
  import org.htmlunit.util.NameValuePair;
  import org.htmlunit.util.UrlUtils;
  
  /**
   * JavaScript host object for {@code URLSearchParams}.
   *
   * @author Ahmed Ashour
   * @author Ronald Brill
   * @author Ween Jiann
   * @author cd alexndr
   * @author Lai Quang Duong
   *
   * @see <a href="https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams">MDN Documentation</a>
   */
  @JsxClass
  public class URLSearchParams extends HtmlUnitScriptable {
  
      private static final Log LOG = LogFactory.getLog(URLSearchParams.class);
  
      /** Constant used to register the prototype in the context. */
      private static final String URL_SEARCH_PARMS_ITERATOR_TAG = "URLSearchParams Iterator";
  
      private URL url_;
  
      /**
       * {@link ES6Iterator} implementation for JavaScript support.
       */
      public static final class NativeParamsIterator extends ES6Iterator {
  
          private static final ClassDescriptor DESCRIPTOR =
                  ES6Iterator.makeDescriptor(URL_SEARCH_PARMS_ITERATOR_TAG, URL_SEARCH_PARMS_ITERATOR_TAG);
  
          enum Type { KEYS, VALUES, BOTH }
  
          private final Type type_;
          private final String className_;
          private final transient Iterator<NameValuePair> iterator_;
  
          /**
           * Initializes the iterator prototype.
           *
           * @param cx the {@link Context}
           * @param scope the scope
           * @param className the class name
           */
          public static void init(final Context cx, final TopLevel scope, final String className) {
              ES6Iterator.initialize(
                      DESCRIPTOR, cx, scope, new FormDataIterator(className), false, URL_SEARCH_PARMS_ITERATOR_TAG);
          }
  
         /**
          * Creates an empty instance (used for prototype initialization).
          *
          * @param className the class name
          */
         public NativeParamsIterator(final String className) {
             super();
             iterator_ = Collections.emptyIterator();
             type_ = Type.BOTH;
             className_ = className;
         }
 
         /**
          * Creates an instance backed by the given iterator.
          *
          * @param scope the scope
          * @param className the class name
          * @param type the iteration type (keys, values, or both)
          * @param iterator the backing iterator
          */
         public NativeParamsIterator(final VarScope scope, final String className, final Type type,
                                         final Iterator<NameValuePair> iterator) {
             super(scope, className);
             iterator_ = iterator;
             type_ = type;
             className_ = className;
         }
 
         @Override
         public String getClassName() {
             return className_;
         }
 
         @Override
         protected boolean isDone(final Context cx, final VarScope scope) {
             return !iterator_.hasNext();
         }
 
         @Override
         protected Object nextValue(final Context cx, final VarScope scope) {
             final NameValuePair e = iterator_.next();
             return switch (type_) {
                 case KEYS -> e.getName();
                 case VALUES -> e.getValue();
                 case BOTH -> cx.newArray(scope, new Object[]{e.getName(), e.getValue()});
             };
         }
     }
 
     /**
      * Default constructor.
      */
     public URLSearchParams() {
         super();
     }
 
     /**
      * Constructs a new instance backed by the given URL.
      *
      * @param url the base URL whose search string is managed by this instance
      */
     URLSearchParams(final URL url) {
         super();
         url_ = url;
     }
 
     /**
      * Creates an instance of this object.
      *
      * @param params initial search parameters; may be a string, a sequence of
      *        {@code [name, value]} pairs, or a record object
      */
     @JsxConstructor
     public void jsConstructor(final Object params) {
         url_ = new URL();
         url_.jsConstructor("http://www.htmlunit.org", "");
 
         if (params == null || JavaScriptEngine.isUndefined(params)) {
             return;
         }
 
         try {
             url_.setSearch(resolveParams(params));
         }
         catch (final EcmaError e) {
             throw JavaScriptEngine.typeError("Failed to construct 'URLSearchParams': " + e.getErrorMessage());
         }
         catch (final MalformedURLException e) {
             LOG.error(e.getMessage(), e);
         }
     }
 
     /*
      * Implementation follows https://url.spec.whatwg.org/#urlsearchparams-initialize
      */
     private static List<NameValuePair> resolveParams(final Object params) {
         // if params is a sequence
         if (params instanceof Scriptable paramsScriptable && hasProperty(paramsScriptable, SymbolKey.ITERATOR)) {
 
             final Context cx = Context.getCurrentContext();
 
             final List<NameValuePair> nameValuePairs = new ArrayList<>();
 
             try (IteratorLikeIterable itr = buildIteratorLikeIterable(cx, paramsScriptable)) {
                 for (final Object nameValue : itr) {
                     if (!(nameValue instanceof Scriptable)) {
                         throw JavaScriptEngine.typeError("The provided value cannot be converted to a sequence.");
                     }
                     if (!hasProperty((Scriptable) nameValue, SymbolKey.ITERATOR)) {
                         throw JavaScriptEngine.typeError("The object must have a callable @@iterator property.");
                     }
 
                     try (IteratorLikeIterable nameValueItr = buildIteratorLikeIterable(cx, (Scriptable) nameValue)) {
 
                         final Iterator<Object> nameValueIterator = nameValueItr.iterator();
                         final Object name =
                                 nameValueIterator.hasNext() ? nameValueIterator.next() : NOT_FOUND;
                         final Object value =
                                 nameValueIterator.hasNext() ? nameValueIterator.next() : NOT_FOUND;
 
                         if (name == NOT_FOUND
                                 || value == NOT_FOUND
                                 || nameValueIterator.hasNext()) {
                             throw JavaScriptEngine.typeError("Sequence initializer must only contain pair elements.");
                         }
 
                         nameValuePairs.add(new NameValuePair(
                                 JavaScriptEngine.toString(name),
                                 JavaScriptEngine.toString(value)));
                     }
                 }
             }
 
             return nameValuePairs;
         }
 
         // if params is a record
         if (params instanceof NativeObject object) {
             final List<NameValuePair> nameValuePairs = new ArrayList<>();
             for (final Map.Entry<Object, Object> keyValuePair : object.entrySet()) {
                 nameValuePairs.add(
                         new NameValuePair(
                                 JavaScriptEngine.toString(keyValuePair.getKey()),
                                 JavaScriptEngine.toString(keyValuePair.getValue())));
             }
             return nameValuePairs;
         }
 
         // otherwise handle it as string
         return splitQuery(JavaScriptEngine.toString(params));
     }
 
     private List<NameValuePair> splitQuery() {
         return splitQuery(url_.getSearch());
     }
 
     private static List<NameValuePair> splitQuery(String params) {
         final List<NameValuePair> splitted = new ArrayList<>();
 
         params = StringUtils.stripStart(params, "?");
         if (org.htmlunit.util.StringUtils.isEmptyOrNull(params)) {
             return splitted;
         }
 
         final String[] parts = StringUtils.split(params, '&');
         for (final String part : parts) {
             final NameValuePair pair = splitQueryParameter(part);
             splitted.add(new NameValuePair(UrlUtils.decode(pair.getName()), UrlUtils.decode(pair.getValue())));
         }
         return splitted;
     }
 
     private static NameValuePair splitQueryParameter(final String singleParam) {
         final int idx = singleParam.indexOf('=');
 
         if (idx > -1) {
             final String key = singleParam.substring(0, idx);
             final String value = singleParam.substring(idx + 1); // always safe, may be empty string
             return new NameValuePair(key, value);
         }
 
         return new NameValuePair(singleParam, "");
     }
 
     private static IteratorLikeIterable buildIteratorLikeIterable(final Context cx, final Scriptable iterable) {
         final Object iterator = ScriptRuntime.callIterator(iterable, cx, iterable.getParentScope());
         return new IteratorLikeIterable(cx, iterable.getParentScope(), iterator);
     }
 
     /**
      * Appends a new key/value pair as a search parameter.
      *
      * @param name the name of the parameter to append
      * @param value the value of the parameter to append
      */
     @JsxFunction
     public void append(final String name, final String value) {
         final String search = url_.getSearch();
 
         final List<NameValuePair> pairs;
         if (search == null || search.isEmpty()) {
             pairs = new ArrayList<>(1);
         }
         else {
             pairs = splitQuery(search);
         }
 
         pairs.add(new NameValuePair(name, value));
         try {
             url_.setSearch(pairs);
         }
         catch (final MalformedURLException e) {
             LOG.error(e.getMessage(), e);
         }
     }
 
     /**
      * Deletes the given search parameter and all its associated values.
      *
      * @param name the name of the parameter to delete
      */
     @JsxFunction
     @Override
     public void delete(final String name) {
         final List<NameValuePair> splitted = splitQuery();
         splitted.removeIf(entry -> entry.getName().equals(name));
 
         if (splitted.isEmpty()) {
             try {
                 url_.setSearch((String) null);
             }
             catch (final MalformedURLException e) {
                 LOG.error(e.getMessage(), e);
             }
             return;
         }
 
         try {
             url_.setSearch(splitted);
         }
         catch (final MalformedURLException e) {
             LOG.error(e.getMessage(), e);
         }
     }
 
     /**
      * Returns the first value associated with the given search parameter.
      *
      * @param name the name of the parameter to find
      * @return the first value for the given name, or {@code null} if not found
      */
     @JsxFunction
     public String get(final String name) {
         final List<NameValuePair> splitted = splitQuery();
         for (final NameValuePair param : splitted) {
             if (param.getName().equals(name)) {
                 return param.getValue();
             }
         }
         return null;
     }
 
     /**
      * Returns all values associated with the given search parameter.
      *
      * @param name the name of the parameter to find
      * @return an array of all values for the given name
      */
     @JsxFunction
     public Scriptable getAll(final String name) {
         final List<NameValuePair> splitted = splitQuery();
         final List<String> result = new ArrayList<>(splitted.size());
         for (final NameValuePair param : splitted) {
             if (param.getName().equals(name)) {
                 result.add(param.getValue());
             }
         }
 
         return JavaScriptEngine.newArray(getParentScope(), result.toArray());
     }
 
     /**
      * Sets the value associated with the given search parameter, replacing all existing values.
      * If the parameter does not exist, it is appended.
      *
      * @param name the name of the parameter to set
      * @param value the new value
      */
     @JsxFunction
     public void set(final String name, final String value) {
         final List<NameValuePair> splitted = splitQuery();
 
         boolean change = true;
         final ListIterator<NameValuePair> iter = splitted.listIterator();
         while (iter.hasNext()) {
             final NameValuePair entry = iter.next();
             if (entry.getName().equals(name)) {
                 if (change) {
                     iter.set(new NameValuePair(name, value));
                     change = false;
                 }
                 else {
                     iter.remove();
                 }
             }
         }
 
         if (change) {
             splitted.add(new NameValuePair(name, value));
         }
 
         try {
             url_.setSearch(splitted);
         }
         catch (final MalformedURLException e) {
             LOG.error(e.getMessage(), e);
         }
     }
 
     /**
      * Returns whether a parameter with the given name exists.
      *
      * @param name the name of the parameter to check
      * @return {@code true} if the parameter exists, {@code false} otherwise
      */
     @JsxFunction
     public boolean has(final String name) {
         final List<NameValuePair> splitted = splitQuery();
 
         for (final NameValuePair param : splitted) {
             if (param.getName().equals(name)) {
                 return true;
             }
         }
         return false;
     }
 
     /**
      * Iterates over all key/value pairs, calling the given callback for each.
      *
      * @param callback the function to call for each key/value pair
      */
     @JsxFunction
     public void forEach(final Object callback) {
         if (!(callback instanceof Function fun)) {
             throw JavaScriptEngine.typeError(
                     "Foreach callback '" + JavaScriptEngine.toString(callback) + "' is not a function");
         }
 
         String currentSearch = null;
         List<NameValuePair> params = null;
         // This must be indexes instead of iterator() for correct behavior when of list changes while iterating
         for (int i = 0;; i++) {
             final String search = url_.getSearch();
             if (!search.equals(currentSearch)) {
                 params = splitQuery(search);
                 currentSearch = search;
             }
             if (i >= params.size()) {
                 break;
             }
 
             final NameValuePair param = params.get(i);
             fun.call(Context.getCurrentContext(), getParentScope(), this,
                         new Object[] {param.getValue(), param.getName(), this});
         }
     }
 
     /**
      * Returns an iterator over all key/value pairs in this object.
      * Keys and values are {@code USVString} objects.
      *
      * @return an iterator of {@code [name, value]} arrays
      */
     @JsxFunction
     @JsxSymbol(symbolName = "iterator")
     public ES6Iterator entries() {
         final List<NameValuePair> splitted = splitQuery();
 
         return new NativeParamsIterator(getParentScope(),
                 URL_SEARCH_PARMS_ITERATOR_TAG, NativeParamsIterator.Type.BOTH, splitted.iterator());
     }
 
     /**
      * Returns an iterator over all keys in this object.
      *
      * @return an iterator of key strings
      */
     @JsxFunction
     public ES6Iterator keys() {
         final List<NameValuePair> splitted = splitQuery();
 
         return new NativeParamsIterator(getParentScope(),
                 URL_SEARCH_PARMS_ITERATOR_TAG, NativeParamsIterator.Type.KEYS, splitted.iterator());
     }
 
     /**
      * Returns an iterator over all values in this object.
      *
      * @return an iterator of value strings
      */
     @JsxFunction
     public ES6Iterator values() {
         final List<NameValuePair> splitted = splitQuery();
 
         return new NativeParamsIterator(getParentScope(),
                 URL_SEARCH_PARMS_ITERATOR_TAG, NativeParamsIterator.Type.VALUES, splitted.iterator());
     }
 
     /**
      * Returns the total number of search parameter entries.
      *
      * @return the number of entries
      */
     @JsxGetter
     public int getSize() {
         final List<NameValuePair> splitted = splitQuery();
         return splitted.size();
     }
 
     /**
      * Returns the URL-encoded string representation of this search params object.
      *
      * @return the encoded query string
      */
     @JsxFunction(functionName = "toString")
     public String jsToString() {
         final StringBuilder newSearch = new StringBuilder();
         for (final NameValuePair nameValuePair : splitQuery(url_.getSearch())) {
             if (newSearch.length() > 0) {
                 newSearch.append('&');
             }
             newSearch
                 .append(UrlUtils.encodeQueryPart(nameValuePair.getName()))
                 .append('=')
                 .append(UrlUtils.encodeQueryPart(nameValuePair.getValue()));
         }
 
         return newSearch.toString();
     }
 
     /**
      * Returns the default string representation of this object.
      *
      * @param hint the type hint
      * @return the URL-encoded query string
      * @see org.htmlunit.javascript.HtmlUnitScriptable#getDefaultValue(java.lang.Class)
      */
     @Override
     public Object getDefaultValue(final Class<?> hint) {
         return jsToString();
     }
 
     /**
      * Populates the given {@link WebRequest} with the parameters from this object.
      *
      * @param webRequest the web request to fill
      */
     public void fillRequest(final WebRequest webRequest) {
         webRequest.setRequestBody(null);
         webRequest.setEncodingType(FormEncodingType.URL_ENCODED);
 
         final List<NameValuePair> splitted = splitQuery();
         if (!splitted.isEmpty()) {
             webRequest.setRequestParameters(new ArrayList<>(splitted));
         }
     }
 }