/*
    * 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.io.IOException;
  import java.net.MalformedURLException;
  import java.net.URI;
  import java.net.URL;
  import java.nio.ByteBuffer;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.htmlunit.Page;
  import org.htmlunit.WebClient;
  import org.htmlunit.WebWindow;
  import org.htmlunit.corejs.javascript.Context;
  import org.htmlunit.corejs.javascript.Function;
  import org.htmlunit.corejs.javascript.Scriptable;
  import org.htmlunit.corejs.javascript.ScriptableObject;
  import org.htmlunit.corejs.javascript.VarScope;
  import org.htmlunit.corejs.javascript.typedarrays.NativeArrayBuffer;
  import org.htmlunit.html.HtmlPage;
  import org.htmlunit.javascript.AbstractJavaScriptEngine;
  import org.htmlunit.javascript.JavaScriptEngine;
  import org.htmlunit.javascript.configuration.JsxClass;
  import org.htmlunit.javascript.configuration.JsxConstant;
  import org.htmlunit.javascript.configuration.JsxConstructor;
  import org.htmlunit.javascript.configuration.JsxFunction;
  import org.htmlunit.javascript.configuration.JsxGetter;
  import org.htmlunit.javascript.configuration.JsxSetter;
  import org.htmlunit.javascript.host.dom.DOMException;
  import org.htmlunit.javascript.host.event.CloseEvent;
  import org.htmlunit.javascript.host.event.Event;
  import org.htmlunit.javascript.host.event.EventTarget;
  import org.htmlunit.javascript.host.event.MessageEvent;
  import org.htmlunit.util.UrlUtils;
  import org.htmlunit.websocket.WebSocketAdapter;
  import org.htmlunit.websocket.WebSocketListener;
  
  /**
   * JavaScript host object for {@code WebSocket}.
   *
   * @author Ahmed Ashour
   * @author Ronald Brill
   * @author Madis Pärn
   *
   * @see <a href="https://developer.mozilla.org/en-US/docs/Web/API/WebSocket">MDN Documentation</a>
   */
  @JsxClass
  public class WebSocket extends EventTarget implements AutoCloseable {
  
      private static final Log LOG = LogFactory.getLog(WebSocket.class);
  
      /** The connection has not yet been established. */
      @JsxConstant
      public static final int CONNECTING = 0;
      /** The WebSocket connection is established and communication is possible. */
      @JsxConstant
      public static final int OPEN = 1;
      /** The connection is going through the closing handshake. */
      @JsxConstant
      public static final int CLOSING = 2;
      /** The connection has been closed or could not be opened. */
      @JsxConstant
      public static final int CLOSED = 3;
  
      private Function closeHandler_;
      private Function errorHandler_;
      private Function messageHandler_;
      private Function openHandler_;
      private URI url_;
      private int readyState_ = CONNECTING;
      private String binaryType_ = "blob";
  
      private HtmlPage containingPage_;
      private WebSocketAdapter webSocketImpl_;
      private boolean originSet_;
  
      /**
       * Creates a new instance.
       */
      public WebSocket() {
          super();
      }
  
      /**
       * Creates a new instance connected to the given URL.
      *
      * @param url the URL to connect to
      * @param scope the scope
      * @param window the top-level window
      */
     private WebSocket(final String url, final VarScope scope, final Window window) {
         super();
         try {
             final WebWindow webWindow = window.getWebWindow();
             containingPage_ = (HtmlPage) webWindow.getEnclosedPage();
 
             setParentScope(scope);
             setDomNode(containingPage_.getDocumentElement(), false);
 
             final WebClient webClient = webWindow.getWebClient();
             originSet_ = true;
 
             final WebSocketListener webSocketListener = new WebSocketListener() {
 
                 @Override
                 public void onWebSocketConnecting() {
                     setReadyState(CONNECTING);
                 }
 
                 @Override
                 public void onWebSocketOpen() {
                     setReadyState(OPEN);
 
                     final Event openEvent = new Event(Event.TYPE_OPEN);
                     openEvent.setParentScope(scope);
                     openEvent.setPrototype(getPrototype(openEvent.getClass()));
                     openEvent.setSrcElement(WebSocket.this);
                     fire(openEvent);
                     callFunction(openHandler_, new Object[] {openEvent});
                 }
 
                 @Override
                 public void onWebSocketClose(final int statusCode, final String reason) {
                     setReadyState(CLOSED);
 
                     final CloseEvent closeEvent = new CloseEvent();
                     closeEvent.setParentScope(scope);
                     closeEvent.setPrototype(getPrototype(closeEvent.getClass()));
                     closeEvent.setCode(statusCode);
                     closeEvent.setReason(reason);
                     closeEvent.setWasClean(statusCode == 1000);
                     fire(closeEvent);
                     callFunction(closeHandler_, new Object[] {closeEvent});
                 }
 
                 @Override
                 public void onWebSocketText(final String message) {
                     final MessageEvent msgEvent = new MessageEvent(message);
                     msgEvent.setParentScope(scope);
                     msgEvent.setPrototype(getPrototype(msgEvent.getClass()));
                     if (originSet_) {
                         try {
                             URL originUrl = UrlUtils.toUrlUnsafe(getUrl());
                             originUrl = UrlUtils.getUrlWithoutPathRefQuery(originUrl);
                             msgEvent.setOrigin(originUrl.toExternalForm());
                         }
                         catch (final MalformedURLException e) {
                             // ignore
                         }
                     }
                     msgEvent.setSrcElement(WebSocket.this);
                     fire(msgEvent);
                     callFunction(messageHandler_, new Object[] {msgEvent});
                 }
 
                 @Override
                 public void onWebSocketBinary(final ByteBuffer payload) {
                     final NativeArrayBuffer buffer = new NativeArrayBuffer(payload.remaining());
                     payload.get(buffer.getBuffer());
 
                     buffer.setParentScope(getParentScope());
                     buffer.setPrototype(ScriptableObject.getClassPrototype(getParentScope(), buffer.getClassName()));
 
                     final MessageEvent msgEvent = new MessageEvent(buffer);
                     msgEvent.setParentScope(scope);
                     msgEvent.setPrototype(getPrototype(msgEvent.getClass()));
                     if (originSet_) {
                         try {
                             URL originUrl = UrlUtils.toUrlUnsafe(getUrl());
                             originUrl = UrlUtils.getUrlWithoutPathRefQuery(originUrl);
                             msgEvent.setOrigin(originUrl.toExternalForm());
                         }
                         catch (final MalformedURLException e) {
                             // ignore
                         }
                     }
                     msgEvent.setSrcElement(WebSocket.this);
                     fire(msgEvent);
                     callFunction(messageHandler_, new Object[] {msgEvent});
                 }
 
                 @Override
                 public void onWebSocketConnectError(final Throwable cause) {
                     if (LOG.isErrorEnabled()) {
                         LOG.error("WS connect error for url '" + url + "':", cause);
                     }
                     onWebSocketError(cause);
                 }
 
                 @Override
                 public void onWebSocketError(final Throwable cause) {
                     if (CLOSED == getReadyState()) {
                         return;
                     }
 
                     setReadyState(CLOSED);
 
                     final Event errorEvent = new Event(Event.TYPE_ERROR);
                     errorEvent.setParentScope(scope);
                     errorEvent.setPrototype(getPrototype(errorEvent.getClass()));
                     errorEvent.setSrcElement(WebSocket.this);
                     fire(errorEvent);
                     callFunction(errorHandler_, new Object[] {errorEvent});
 
                     final CloseEvent closeEvent = new CloseEvent();
                     closeEvent.setParentScope(scope);
                     closeEvent.setPrototype(getPrototype(closeEvent.getClass()));
                     closeEvent.setCode(1006);
                     closeEvent.setReason(cause.getMessage());
                     closeEvent.setWasClean(false);
                     fire(closeEvent);
                     callFunction(closeHandler_, new Object[] {closeEvent});
                 }
             };
 
             webSocketImpl_ = webClient.buildWebSocketAdapter(webSocketListener);
 
             webSocketImpl_.start();
             containingPage_.addAutoCloseable(this);
             url_ = new URI(url);
 
             webSocketImpl_.connect(url_);
         }
         catch (final Exception e) {
             if (LOG.isErrorEnabled()) {
                 LOG.error("WebSocket Error: 'url' parameter '" + url + "' is invalid.", e);
             }
             throw JavaScriptEngine.reportRuntimeError("WebSocket Error: 'url' parameter '" + url + "' is invalid.");
         }
     }
 
     /**
      * Creates an instance of this object.
      *
      * @param cx the current context
      * @param scope the scope
      * @param args the constructor arguments
      * @param ctorObj the function object
      * @param inNewExpr whether invoked via {@code new}
      * @return the new {@code WebSocket} instance
      */
     @JsxConstructor
     public static Scriptable jsConstructor(final Context cx, final VarScope scope, final Object[] args,
             final Function ctorObj, final boolean inNewExpr) {
         if (args.length < 1 || args.length > 2) {
             throw JavaScriptEngine
                     .typeError("WebSocket Error: constructor must have one or two String parameters.");
         }
 
         final Window win = getWindow(ctorObj);
         String urlString = JavaScriptEngine.toString(args[0]);
         try {
             final Page page = win.getWebWindow().getEnclosedPage();
             if (page instanceof HtmlPage htmlPage) {
                 URL url = htmlPage.getFullyQualifiedUrl(urlString);
 
                 if (url.getRef() != null) {
                     throw JavaScriptEngine.asJavaScriptException(
                             win,
                             "WebSocket Error: 'url' parameter '" + urlString + "' contains a fragment identifier.",
                             DOMException.SYNTAX_ERR);
                 }
 
                 // Per spec: only ws/wss are valid; convert http/https (relative resolution), reject everything else
                 final String scheme = url.getProtocol();
                 if ("http".equals(scheme)) {
                     url = UrlUtils.getUrlWithNewProtocol(url, "ws");
                 }
                 else if ("https".equals(scheme)) {
                     url = UrlUtils.getUrlWithNewProtocol(url, "wss");
                 }
                 else if (!"ws".equals(scheme) && !"wss".equals(scheme)) {
                     throw JavaScriptEngine.asJavaScriptException(
                             win,
                             "WebSocket Error: 'url' parameter '" + urlString + "' is not a valid url.",
                             DOMException.SYNTAX_ERR);
                 }
 
                 urlString = url.toExternalForm();
             }
         }
         catch (final MalformedURLException e) {
             throw JavaScriptEngine.asJavaScriptException(
                     win,
                     "WebSocket Error: 'url' parameter '" + urlString + "' is not a valid url.",
                     DOMException.SYNTAX_ERR);
         }
         return new WebSocket(urlString, getTopLevelScope(scope), win);
     }
 
     /**
      * Returns the event handler that fires on close.
      *
      * @return the event handler that fires on close
      */
     @JsxGetter
     public Function getOnclose() {
         return closeHandler_;
     }
 
     /**
      * Sets the event handler that fires on close.
      *
      * @param closeHandler the event handler that fires on close
      */
     @JsxSetter
     public void setOnclose(final Function closeHandler) {
         closeHandler_ = closeHandler;
     }
 
     /**
      * Returns the event handler that fires on error.
      *
      * @return the event handler that fires on error
      */
     @JsxGetter
     public Function getOnerror() {
         return errorHandler_;
     }
 
     /**
      * Sets the event handler that fires on error.
      *
      * @param errorHandler the event handler that fires on error
      */
     @JsxSetter
     public void setOnerror(final Function errorHandler) {
         errorHandler_ = errorHandler;
     }
 
     /**
      * Returns the event handler that fires on message.
      *
      * @return the event handler that fires on message
      */
     @JsxGetter
     public Function getOnmessage() {
         return messageHandler_;
     }
 
     /**
      * Sets the event handler that fires on message.
      *
      * @param messageHandler the event handler that fires on message
      */
     @JsxSetter
     public void setOnmessage(final Function messageHandler) {
         messageHandler_ = messageHandler;
     }
 
     /**
      * Returns the event handler that fires on open.
      *
      * @return the event handler that fires on open
      */
     @JsxGetter
     public Function getOnopen() {
         return openHandler_;
     }
 
     /**
      * Sets the event handler that fires on open.
      *
      * @param openHandler the event handler that fires on open
      */
     @JsxSetter
     public void setOnopen(final Function openHandler) {
         openHandler_ = openHandler;
     }
 
     /**
      * Returns the current state of the connection.
      * Possible values are {@link #CONNECTING}, {@link #OPEN}, {@link #CLOSING}, or {@link #CLOSED}.
      *
      * @return the current ready state
      */
     @JsxGetter
     public int getReadyState() {
         return readyState_;
     }
 
     void setReadyState(final int readyState) {
         readyState_ = readyState;
     }
 
     /**
      * Returns the URL of the WebSocket connection.
      *
      * @return the URL string
      */
     @JsxGetter
     public String getUrl() {
         if (url_ == null) {
             throw JavaScriptEngine.typeError("invalid call");
         }
         return url_.toString();
     }
 
     /**
      * Returns the sub-protocol in use, or an empty string if no sub-protocol was selected.
      *
      * @return the sub-protocol
      */
     @JsxGetter
     public String getProtocol() {
         return "";
     }
 
     /**
      * Returns the number of bytes of data that have been queued but not yet transmitted.
      *
      * @return the buffered amount in bytes
      */
     @JsxGetter
     public long getBufferedAmount() {
         return 0L;
     }
 
     /**
      * Returns the binary data type used when receiving binary messages.
      *
      * @return the binary type ({@code "blob"} or {@code "arraybuffer"})
      */
     @JsxGetter
     public String getBinaryType() {
         return binaryType_;
     }
 
     /**
      * Sets the binary data type used when receiving binary messages.
      *
      * @param type the new binary type; must be {@code "blob"} or {@code "arraybuffer"}
      */
     @JsxSetter
     public void setBinaryType(final String type) {
         if ("arraybuffer".equals(type) || "blob".equals(type)) {
             binaryType_ = type;
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void close() throws IOException {
         close(null, null);
     }
 
     /**
      * Closes the WebSocket connection or connection attempt, if any.
      * If the connection is already {@link #CLOSED}, this method does nothing.
      *
      * @param code a numeric value indicating the status code explaining why the connection is being closed
      * @param reason a human-readable string explaining why the connection is closing
      */
     @JsxFunction
     public void close(final Object code, final Object reason) {
         if (webSocketImpl_ == null) {
             return;
         }
 
         if (readyState_ != CLOSED) {
             try {
                 webSocketImpl_.closeIncomingSession();
             }
             catch (final Throwable e) {
                 LOG.error("WS close error - incomingSession_.close() failed", e);
             }
 
             try {
                 webSocketImpl_.closeOutgoingSession();
             }
             catch (final Throwable e) {
                 LOG.error("WS close error - outgoingSession_.close() failed", e);
             }
         }
 
         try {
             webSocketImpl_.closeClient();
         }
         catch (final Exception e) {
             throw new RuntimeException(e);
         }
     }
 
     /**
      * Transmits data to the server over the WebSocket connection.
      *
      * @param content the data to send
      */
     @JsxFunction
     public void send(final Object content) {
         try {
             if (content instanceof NativeArrayBuffer buffer1) {
                 final byte[] bytes = buffer1.getBuffer();
                 final ByteBuffer buffer = ByteBuffer.wrap(bytes);
                 webSocketImpl_.send(buffer);
                 return;
             }
             webSocketImpl_.send(content);
         }
         catch (final IOException e) {
             LOG.error("WS send error", e);
         }
     }
 
     void fire(final Event evt) {
         evt.setTarget(this);
         evt.setParentScope(getParentScope());
         evt.setPrototype(getPrototype(evt.getClass()));
 
         final AbstractJavaScriptEngine<?> engine = containingPage_.getWebClient().getJavaScriptEngine();
         if (engine != null) {
             engine.getContextFactory().call(cx -> {
                 executeEventLocally(evt);
                 return null;
             });
         }
     }
 
     void callFunction(final Function function, final Object[] args) {
         if (function == null) {
             return;
         }
         final VarScope scope = function.getParentScope();
         final JavaScriptEngine engine = (JavaScriptEngine) containingPage_.getWebClient().getJavaScriptEngine();
         if (engine != null) {
             engine.callFunction(containingPage_, function, scope, this, args);
         }
     }
 }