/*
    * 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;
  
  import static java.nio.charset.StandardCharsets.ISO_8859_1;
  
  import java.net.URL;
  import java.nio.charset.Charset;
  import java.time.Duration;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.eclipse.jetty.server.Server;
  import org.htmlunit.WebDriverTestCase.MockWebConnectionServlet;
  import org.htmlunit.html.HtmlPage;
  import org.htmlunit.util.JettyServerUtils;
  import org.htmlunit.util.MimeType;
  import org.junit.jupiter.api.AfterEach;
  
  import jakarta.servlet.Servlet;
  
  /**
   * A WebTestCase which starts a local server, and doesn't use WebDriver.
   * <p>
   * <b>Note that {@link WebDriverTestCase} should be used unless HtmlUnit-specific feature
   * is needed and Selenium does not support it.</b>
   *
   * @author Ahmed Ashour
   * @author Marc Guillemot
   * @author Ronald Brill
   */
  public abstract class WebServerTestCase extends WebTestCase {
  
      public enum SSLVariant {
          NONE,
          INSECURE,
          SELF_SIGNED
      }
  
      /** Timeout used when waiting for successful bind. */
      public static final int BIND_TIMEOUT = 1000;
  
      private Server server_;
      private static Server STATIC_SERVER_;
      private WebClient webClient_;
      private CollectingAlertHandler alertHandler_ = new CollectingAlertHandler();
  
      /**
       * Starts the web server on the default {@link #PORT}.
       * The given resourceBase is used to be the ROOT directory that serves the default context.
       * <p><b>Don't forget to stop the returned HttpServer after the test</b>
       *
       * @param resourceBase the base of resources for the default context
       * @throws Exception if the test fails
       */
      protected void startWebServer(final String resourceBase) throws Exception {
          if (server_ != null) {
              throw new IllegalStateException("startWebServer() can not be called twice");
          }
  
          server_ =  JettyServerUtils.startWebServer(PORT, resourceBase, null, null, isBasicAuthentication(), getSSLVariant());
      }
  
      /**
       * Starts the web server on the default {@link #PORT}.
       * The given resourceBase is used to be the ROOT directory that serves the default context.
       * <p><b>Don't forget to stop the returned HttpServer after the test</b>
       *
       * @param resourceBase the base of resources for the default context
       * @param servlets map of {String, Class} pairs: String is the path spec, while class is the class
       * @throws Exception if the test fails
       */
      protected void startWebServer(final String resourceBase,
              final Map<String, Class<? extends Servlet>> servlets) throws Exception {
          if (server_ != null) {
              throw new IllegalStateException("startWebServer() can not be called twice");
          }
  
          server_ = JettyServerUtils.startWebServer(PORT, resourceBase, servlets, null, false, SSLVariant.NONE);
      }
  
      /**
       * Performs post-test deconstruction.
       * @throws Exception if an error occurs
       */
      @AfterEach
     public void tearDown() throws Exception {
         JettyServerUtils.stopServer(server_);
         server_ = null;
 
         stopWebServer();
     }
 
     /**
      * Defines the provided string as response for the provided URL and loads it using the currently
      * configured browser version. Finally it extracts the captured alerts and verifies them.
      * @param html the HTML to use
      * @param url the URL to use to load the page
      * @return the page
      * @throws Exception if something goes wrong
      */
     protected final HtmlPage loadPageWithAlerts(final String html, final URL url)
         throws Exception {
         return loadPageWithAlerts(html, url, Duration.ofSeconds(0));
     }
 
     /**
      * Same as {@link #loadPageWithAlerts(String, URL)}, but configuring the max wait time.
      * @param html the HTML to use
      * @param url the URL to use to load the page
      * @param maxWaitTime to wait to get the alerts (in ms)
      * @return the page
      * @throws Exception if something goes wrong
      */
     protected final HtmlPage loadPageWithAlerts(final String html, final URL url, final Duration maxWaitTime)
         throws Exception {
         alertHandler_.clear();
         expandExpectedAlertsVariables(URL_FIRST);
 
         final String[] expectedAlerts = getExpectedAlerts();
         final HtmlPage page = loadPage(html, url);
 
         List<String> actualAlerts = getCollectedAlerts(page);
         final long maxWait = System.currentTimeMillis() + maxWaitTime.toMillis();
         while (actualAlerts.size() < expectedAlerts.length && System.currentTimeMillis() < maxWait) {
             Thread.sleep(30);
             actualAlerts = getCollectedAlerts(page);
         }
 
         assertEquals(expectedAlerts, getCollectedAlerts(page));
         return page;
     }
 
     /**
      * Defines the provided string as response for the default URL and loads it using the currently
      * configured browser version.
      * @param html the HTML to use
      * @return the page
      * @throws Exception if something goes wrong
      */
     protected final HtmlPage loadPage(final String html) throws Exception {
         return loadPage(html, URL_FIRST);
     }
 
     /**
      * Same as {@link #loadPage(String)}... but defining the default URL.
      * @param html the HTML to use
      * @param url the url to use to load the page
      * @return the page
      * @throws Exception if something goes wrong
      */
     protected final HtmlPage loadPage(final String html, final URL url) throws Exception {
         return loadPage(html, url, MimeType.TEXT_HTML, ISO_8859_1);
     }
 
     /**
      * Same as {@link #loadPage(String, URL)}... but defining content type and charset as well.
      * @param html the HTML to use
      * @param url the url to use to load the page
      * @param contentType the content type to return
      * @param charset the charset
      * @return the page
      * @throws Exception if something goes wrong
      */
     private HtmlPage loadPage(final String html, final URL url,
             final String contentType, final Charset charset) throws Exception {
         final MockWebConnection mockWebConnection = getMockWebConnection();
         mockWebConnection.setResponse(url, html, contentType, charset);
         startWebServer(mockWebConnection);
 
         return getWebClient().getPage(url);
     }
 
     /**
      * Starts the web server delivering response from the provided connection.
      * @param mockConnection the sources for responses
      * @throws Exception if a problem occurs
      */
     protected void startWebServer(final MockWebConnection mockConnection) throws Exception {
         if (STATIC_SERVER_ == null) {
             final Map<String, Class<? extends Servlet>> servlets = new HashMap<>();
             servlets.put("/*", MockWebConnectionServlet.class);
 
             STATIC_SERVER_ = JettyServerUtils.startWebServer(PORT, "./", servlets, null, isBasicAuthentication(), getSSLVariant());
         }
         MockWebConnectionServlet.setMockconnection(mockConnection);
     }
 
     /**
      * Stops the WebServer.
      * @throws Exception if it fails
      */
     protected static void stopWebServer() throws Exception {
         JettyServerUtils.stopServer(STATIC_SERVER_);
         STATIC_SERVER_ = null;
     }
 
     /**
      * Loads the provided URL serving responses from {@link #getMockWebConnection()}
      * and verifies that the captured alerts are correct.
      * @param url the URL to use to load the page
      * @return the web driver
      * @throws Exception if something goes wrong
      */
     protected final HtmlPage loadPageWithAlerts(final URL url) throws Exception {
         alertHandler_.clear();
         expandExpectedAlertsVariables(url);
         final String[] expectedAlerts = getExpectedAlerts();
 
         startWebServer(getMockWebConnection());
 
         final HtmlPage page = getWebClient().getPage(url);
 
         assertEquals(expectedAlerts, getCollectedAlerts(page));
         return page;
     }
 
     /**
      * Returns the collected alerts.
      * @param page the page
      * @return the alerts
      */
     protected List<String> getCollectedAlerts(final HtmlPage page) {
         return alertHandler_.getCollectedAlerts();
     }
 
     /**
      * Returns whether to use basic authentication for all resources or not.
      * The default implementation returns false.
      * @return whether to use basic authentication or not
      */
     protected boolean isBasicAuthentication() {
         return false;
     }
 
     /**
      * @return the {@link SSLVariant} to be used
      */
     public SSLVariant getSSLVariant() {
         return SSLVariant.NONE;
     }
 
     /**
      * Returns the WebClient instance for the current test with the current {@link BrowserVersion}.
      * @return a WebClient with the current {@link BrowserVersion}
      */
     protected WebClient getWebClient() {
         if (webClient_ == null) {
             webClient_ = new WebClient(getBrowserVersion());
             webClient_.setAlertHandler(alertHandler_);
         }
         return webClient_;
     }
 
     /**
      * Cleanup after a test.
      */
     @Override
     @AfterEach
     public void releaseResources() {
         super.releaseResources();
         if (webClient_ != null) {
             webClient_.close();
             webClient_.getCookieManager().clearCookies();
         }
         webClient_ = null;
         alertHandler_ = null;
     }
 }