/*
    * 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.List;
  import java.util.UUID;
  
  import org.apache.commons.lang3.StringUtils;
  import org.htmlunit.Page;
  import org.htmlunit.WebWindow;
  import org.htmlunit.corejs.javascript.Scriptable;
  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.JsxConstructorAlias;
  import org.htmlunit.javascript.configuration.JsxFunction;
  import org.htmlunit.javascript.configuration.JsxGetter;
  import org.htmlunit.javascript.configuration.JsxSetter;
  import org.htmlunit.javascript.configuration.JsxStaticFunction;
  import org.htmlunit.javascript.host.file.Blob;
  import org.htmlunit.javascript.host.file.File;
  import org.htmlunit.util.NameValuePair;
  import org.htmlunit.util.UrlUtils;
  
  /**
   * JavaScript host object for {@code URL}.
   *
   * @author Ahmed Ashour
   * @author Ronald Brill
   * @author cd alexndr
   * @author Lai Quang Duong
   *
   * @see <a href="https://developer.mozilla.org/en-US/docs/Web/API/URL">MDN Documentation</a>
   */
  @JsxClass
  public class URL extends HtmlUnitScriptable {
  
      private java.net.URL url_;
  
      /**
       * Creates an instance of this object.
       *
       * @param url a string representing an absolute or relative URL.
       *        If {@code url} is a relative URL, {@code base} is required and will be used
       *        as the base URL. If {@code url} is an absolute URL, a given {@code base} will be ignored.
       * @param base a string representing the base URL to use when {@code url}
       *        is a relative URL. If not specified, it defaults to {@code ''}.
       */
      @JsxConstructor
      @JsxConstructorAlias(alias = "webkitURL")
      public void jsConstructor(final String url, final Object base) {
          String baseStr = null;
          if (!JavaScriptEngine.isUndefined(base)) {
              baseStr = JavaScriptEngine.toString(base);
          }
  
          try {
              if (org.htmlunit.util.StringUtils.isBlank(baseStr)) {
                  url_ = UrlUtils.toUrlUnsafe(url);
              }
              else {
                  final java.net.URL baseUrl = UrlUtils.toUrlUnsafe(baseStr);
                  url_ = UrlUtils.toUrlUnsafe(UrlUtils.resolveUrl(baseUrl, url));
              }
              url_ = UrlUtils.removeRedundantPort(url_);
          }
          catch (final MalformedURLException e) {
              throw JavaScriptEngine.typeError(e.toString());
          }
      }
  
      /**
       * The URL.createObjectURL() static method creates a {@code DOMString} containing a URL
       * representing the object given as parameter.
       * The new object URL represents the specified {@link File} object or {@link Blob} object
       * and is registered in the {@link org.htmlunit.BlobUrlStore user-agent-wide blob URL store},
       * so it can be resolved from any document of the same client.
       *
       * @param fileOrBlob the {@link File} or {@link Blob} to create an object URL for
       * @return the object URL, or {@code null} if the argument is not a supported type
       * @see <a href="https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL_static">MDN Documentation</a>
       */
      @JsxStaticFunction
      public static String createObjectURL(final Object fileOrBlob) {
          if (!(fileOrBlob instanceof Blob blob)) {
             throw JavaScriptEngine.typeError("URL.createObjectURL: argument 1 is not a Blob.");
         }
 
         final WebWindow webWindow = getWindow(blob).getWebWindow();
         final Page page = webWindow.getEnclosedPage();
         final java.net.URL pageUrl = page.getUrl();
 
         String origin = "null";
         if (pageUrl != UrlUtils.URL_ABOUT_BLANK) {
             final int port = pageUrl.getPort();
             if (port < 0 || port == pageUrl.getDefaultPort()) {
                 origin = pageUrl.getProtocol() + "://" + pageUrl.getHost();
             }
             else {
                 origin = pageUrl.getProtocol() + "://" + pageUrl.getHost() + ':' + port;
             }
         }
 
         final String blobUrl = "blob:" + origin + "/" + UUID.randomUUID();
         webWindow.getWebClient().getBlobUrlStore().put(blobUrl, blob, page);
         return blobUrl;
     }
 
     /**
      * Revokes a {@code blob:} URL, removing its entry from the blob URL store.
      *
      * @param objectURL the object URL previously returned by {@link #createObjectURL(Object)}
      *
      * @see <a href="https://developer.mozilla.org/en-US/docs/Web/API/URL/revokeObjectURL_static">MDN Documentation</a>
      */
     @JsxStaticFunction
     public static void revokeObjectURL(final Scriptable objectURL) {
         final String url = JavaScriptEngine.toString(objectURL);
         if (!url.startsWith("blob:")) {
             return;
         }
         getWindow(objectURL).getWebWindow().getWebClient().getBlobUrlStore().remove(url);
     }
 
     /**
      * Returns the hash portion of the URL, containing a {@code #} followed by the fragment identifier.
      *
      * @return the hash portion of the URL, or an empty string if there is no fragment
      */
     @JsxGetter
     public String getHash() {
         if (url_ == null) {
             return null;
         }
         final String ref = url_.getRef();
         return ref == null ? "" : "#" + ref;
     }
 
     /**
      * Sets the {@code hash} property.
      *
      * @param fragment the new hash value
      * @throws MalformedURLException if the resulting URL is malformed
      */
     @JsxSetter
     public void setHash(final String fragment) throws MalformedURLException {
         if (url_ == null) {
             return;
         }
         url_ = UrlUtils.getUrlWithNewRef(url_, org.htmlunit.util.StringUtils.isEmptyOrNull(fragment) ? null : fragment);
     }
 
     /**
      * Returns the host portion of the URL, consisting of the hostname and, if the port is non-empty,
      * a {@code :} followed by the port.
      *
      * @return the host
      */
     @JsxGetter
     public String getHost() {
         if (url_ == null) {
             return null;
         }
         final int port = url_.getPort();
         return url_.getHost() + (port > 0 ? ":" + port : "");
     }
 
     /**
      * Sets the {@code host} property.
      *
      * @param host the new host value
      * @throws MalformedURLException if the resulting URL is malformed
      */
     @JsxSetter
     public void setHost(final String host) throws MalformedURLException {
         if (url_ == null) {
             return;
         }
 
         String newHost = StringUtils.substringBefore(host, ':');
         if (org.htmlunit.util.StringUtils.isEmptyOrNull(newHost)) {
             return;
         }
 
         try {
             int ip = Integer.parseInt(newHost);
             final StringBuilder ipString = new StringBuilder();
             ipString.insert(0, ip % 256);
             ipString.insert(0, '.');
 
             ip = ip / 256;
             ipString.insert(0, ip % 256);
             ipString.insert(0, '.');
 
             ip = ip / 256;
             ipString.insert(0, ip % 256);
             ipString.insert(0, '.');
             ip = ip / 256;
             ipString.insert(0, ip % 256);
 
             newHost = ipString.toString();
         }
         catch (final Exception expected) {
             // back to string
         }
 
         url_ = UrlUtils.getUrlWithNewHost(url_, newHost);
 
         final String newPort = StringUtils.substringAfter(host, ':');
         if (org.htmlunit.util.StringUtils.isNotBlank(newHost)) {
             try {
                 url_ = UrlUtils.getUrlWithNewHostAndPort(url_, newHost, Integer.parseInt(newPort));
             }
             catch (final Exception expected) {
                 // back to string
             }
         }
         else {
             url_ = UrlUtils.getUrlWithNewHost(url_, newHost);
         }
 
         url_ = UrlUtils.removeRedundantPort(url_);
     }
 
     /**
      * Returns the hostname portion of the URL.
      *
      * @return the hostname
      */
     @JsxGetter
     public String getHostname() {
         if (url_ == null) {
             return null;
         }
 
         return UrlUtils.encodeAnchor(url_.getHost());
     }
 
     /**
      * Sets the {@code hostname} property.
      *
      * @param hostname the new hostname value
      */
     @JsxSetter
     public void setHostname(String hostname) {
         if (hostname != null) {
             if (hostname.indexOf(' ') > -1) {
                 return;
             }
 
             final int idx = hostname.indexOf('#');
             if (idx > -1) {
                 hostname = hostname.substring(0, idx);
             }
         }
 
         if (org.htmlunit.util.StringUtils.isEmptyOrNull(hostname)) {
             return;
         }
 
         try {
             url_ = UrlUtils.getUrlWithNewHost(url_, hostname);
         }
         catch (final MalformedURLException  e) {
             // do nothing
         }
     }
 
     /**
      * Returns the full URL as a string.
      *
      * @return the full URL
      */
     @JsxGetter
     public String getHref() {
         if (url_ == null) {
             return null;
         }
 
         return jsToString();
     }
 
     /**
      * Sets the {@code href} property, navigating to the new URL.
      *
      * @param href the new URL string
      * @throws MalformedURLException if the URL is malformed
      */
     @JsxSetter
     public void setHref(final String href) throws MalformedURLException {
         if (url_ == null) {
             return;
         }
 
         url_ = UrlUtils.toUrlUnsafe(href);
         url_ = UrlUtils.removeRedundantPort(url_);
     }
 
     /**
      * Returns the origin of the URL.
      *
      * @return the origin
      */
     @JsxGetter
     public Object getOrigin() {
         if (url_ == null) {
             return null;
         }
 
         if (url_.getPort() < 0 || url_.getPort() == url_.getDefaultPort()) {
             return url_.getProtocol() + "://" + url_.getHost();
         }
 
         return url_.getProtocol() + "://" + url_.getHost() + ':' + url_.getPort();
     }
 
     /**
      * Returns a {@link URLSearchParams} object providing access to the decoded query arguments of the URL.
      *
      * @return the search params
      */
     @JsxGetter
     public URLSearchParams getSearchParams() {
         if (url_ == null) {
             return null;
         }
 
         final URLSearchParams searchParams = new URLSearchParams(this);
         searchParams.setParentScope(getParentScope());
         searchParams.setPrototype(getPrototype(searchParams.getClass()));
         return searchParams;
     }
 
     /**
      * Returns the password specified before the domain name.
      *
      * @return the password, or an empty string if none is specified
      */
     @JsxGetter
     public String getPassword() {
         if (url_ == null) {
             return null;
         }
 
         final String userInfo = url_.getUserInfo();
         if (userInfo != null) {
             final int idx = userInfo.indexOf(':');
             if (idx > -1) {
                 return userInfo.substring(idx + 1);
             }
         }
 
         return "";
     }
 
     /**
      * Sets the {@code password} property.
      *
      * @param password the new password value
      * @throws MalformedURLException if the resulting URL is malformed
      */
     @JsxSetter
     public void setPassword(final String password) throws MalformedURLException {
         if (url_ == null) {
             return;
         }
 
         url_ = UrlUtils.getUrlWithNewUserPassword(url_, password.isEmpty() ? null : password);
     }
 
     /**
      * Returns the pathname portion of the URL.
      *
      * @return the pathname
      */
     @JsxGetter
     public String getPathname() {
         if (url_ == null) {
             return null;
         }
 
         final String path = url_.getPath();
         return path.isEmpty() ? "/" : path;
     }
 
     /**
      * Sets the {@code pathname} property.
      *
      * @param path the new pathname value
      * @throws MalformedURLException if the resulting URL is malformed
      */
     @JsxSetter
     public void setPathname(final String path) throws MalformedURLException {
         if (url_ == null) {
             return;
         }
 
         url_ = UrlUtils.getUrlWithNewPath(url_, path.startsWith("/") ? path : "/" + path);
     }
 
     /**
      * Returns the port number of the URL, or an empty string if no explicit port is specified.
      *
      * @return the port, or an empty string
      */
     @JsxGetter
     public String getPort() {
         if (url_ == null) {
             return null;
         }
 
         final int port = url_.getPort();
         return port == -1 ? "" : Integer.toString(port);
     }
 
     /**
      * Sets the {@code port} property.
      *
      * @param port the new port value, or an empty string to remove the port
      * @throws MalformedURLException if the resulting URL is malformed
      */
     @JsxSetter
     public void setPort(final String port) throws MalformedURLException {
         if (url_ == null) {
             return;
         }
         final int portInt = port.isEmpty() ? -1 : Integer.parseInt(port);
         url_ = UrlUtils.getUrlWithNewPort(url_, portInt);
         url_ = UrlUtils.removeRedundantPort(url_);
     }
 
     /**
      * Returns the protocol scheme of the URL, including the trailing {@code :}.
      *
      * @return the protocol
      */
     @JsxGetter
     public String getProtocol() {
         if (url_ == null) {
             return null;
         }
         final String protocol = url_.getProtocol();
         return protocol.isEmpty() ? "" : (protocol + ":");
     }
 
     /**
      * Sets the {@code protocol} property.
      *
      * @param protocol the new protocol value
      * @throws MalformedURLException if the resulting URL is malformed
      */
     @JsxSetter
     public void setProtocol(final String protocol) throws MalformedURLException {
         if (url_ == null || protocol.isEmpty()) {
             return;
         }
 
         final String bareProtocol = org.htmlunit.util.StringUtils.substringBefore(protocol, ":").trim();
         if (!UrlUtils.isValidScheme(bareProtocol)) {
             return;
         }
         if (!UrlUtils.isSpecialScheme(bareProtocol)) {
             return;
         }
 
         try {
             url_ = UrlUtils.getUrlWithNewProtocol(url_, bareProtocol);
             url_ = UrlUtils.removeRedundantPort(url_);
         }
         catch (final MalformedURLException ignored) {
             // ignore
         }
     }
 
     /**
      * Returns the query string, containing a {@code ?} followed by the URL's parameters.
      *
      * @return the search string, or an empty string if none
      */
     @JsxGetter
     public String getSearch() {
         if (url_ == null) {
             return null;
         }
         final String search = url_.getQuery();
         return search == null ? "" : "?" + search;
     }
 
     /**
      * Sets the {@code search} property.
      *
      * @param search the new search string
      * @throws MalformedURLException if the resulting URL is malformed
      */
     @JsxSetter
     public void setSearch(final String search) throws MalformedURLException {
         if (url_ == null) {
             return;
         }
 
         String query;
         if (search == null
                 || org.htmlunit.util.StringUtils.equalsChar('?', search)
                 || org.htmlunit.util.StringUtils.isEmptyString(search)) {
             query = null;
         }
         else {
             if (search.charAt(0) == '?') {
                 query = search.substring(1);
             }
             else {
                 query = search;
             }
             query = UrlUtils.encodeQuery(query);
         }
 
         url_ = UrlUtils.getUrlWithNewQuery(url_, query);
     }
 
     /**
      * Sets the {@code search} property from a list of {@link NameValuePair}s.
      *
      * @param nameValuePairs the pairs to encode as the query string
      * @throws MalformedURLException if the resulting URL is malformed
      */
     public void setSearch(final List<NameValuePair> nameValuePairs) throws MalformedURLException {
         final StringBuilder newSearch = new StringBuilder();
         for (final NameValuePair nameValuePair : nameValuePairs) {
             if (newSearch.length() > 0) {
                 newSearch.append('&');
             }
             newSearch
                 .append(UrlUtils.encodeQueryPart(nameValuePair.getName()))
                 .append('=')
                 .append(UrlUtils.encodeQueryPart(nameValuePair.getValue()));
         }
 
         url_ = UrlUtils.getUrlWithNewQuery(url_, newSearch.toString());
     }
 
     /**
      * Returns the username specified before the domain name.
      *
      * @return the username, or an empty string if none is specified
      */
     @JsxGetter
     public String getUsername() {
         if (url_ == null) {
             return null;
         }
 
         final String userInfo = url_.getUserInfo();
         if (userInfo == null) {
             return "";
         }
 
         return StringUtils.substringBefore(userInfo, ':');
     }
 
     /**
      * Sets the {@code username} property.
      *
      * @param username the new username value
      * @throws MalformedURLException if the resulting URL is malformed
      */
     @JsxSetter
     public void setUsername(final String username) throws MalformedURLException {
         if (url_ == null) {
             return;
         }
         url_ = UrlUtils.getUrlWithNewUserName(url_, username.isEmpty() ? null : username);
     }
 
     /**
      * Returns the default string representation of this URL.
      *
      * @param hint the type hint
      * @return the URL as a string
      * @see org.htmlunit.javascript.HtmlUnitScriptable#getDefaultValue(java.lang.Class)
      */
     @Override
     public Object getDefaultValue(final Class<?> hint) {
         if (url_ == null) {
             return super.getDefaultValue(hint);
         }
 
         if (org.htmlunit.util.StringUtils.isEmptyOrNull(url_.getPath())) {
             return url_.toExternalForm() + "/";
         }
         return url_.toExternalForm();
     }
 
     /**
      * Returns a serialized version of the URL. In practice this is equivalent to {@link #jsToString()}.
      *
      * @return the serialized URL string
      */
     @JsxFunction
     public String toJSON() {
         return jsToString();
     }
 
     /**
      * Returns the URL as a string.
      *
      * @return the URL string
      */
     @JsxFunction(functionName = "toString")
     public String jsToString() {
         if (org.htmlunit.util.StringUtils.isEmptyOrNull(url_.getPath())) {
             try {
                 return UrlUtils.getUrlWithNewPath(url_, "/").toExternalForm();
             }
             catch (final MalformedURLException e) {
                 return url_.toExternalForm();
             }
         }
         return url_.toExternalForm();
     }
 }