/*
 * Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * @test
 * @library /test/lib
 * @bug 8291226 8291638 8330523
 * @modules java.base/sun.net.www.http:+open
 *          java.base/sun.net.www.protocol.http:+open
 * @run main/othervm KeepAliveTest
 * @run main/othervm -Dhttp.keepAlive.time.server=100 KeepAliveTest
 * @run main/othervm -Dhttp.keepAlive.time.proxy=200 KeepAliveTest
 * @run main/othervm -Dhttp.keepAlive.time.server=100 -Dhttp.keepAlive.time.proxy=200 KeepAliveTest
 * @run main/othervm -Dhttp.keepAlive.time.server=-100 KeepAliveTest
 * @run main/othervm -Dhttp.keepAlive.time.proxy=-200 KeepAliveTest
 * @run main/othervm -Dhttp.keepAlive.time.server=-100 -Dhttp.keepAlive.time.proxy=-200 KeepAliveTest
 * @run main/othervm -Dhttp.keepAlive.time.server=0 KeepAliveTest
 * @run main/othervm -Dhttp.keepAlive.time.proxy=0 KeepAliveTest
 * @run main/othervm -Dhttp.keepAlive.time.server=0 -Dhttp.keepAlive.time.proxy=0 KeepAliveTest
 * @run main/othervm -Dhttp.keepAlive.time.server=0 -Dhttp.keepAlive.time.proxy=-200 KeepAliveTest
 * @run main/othervm -Dhttp.keepAlive.time.server=-100 -Dhttp.keepAlive.time.proxy=0 KeepAliveTest
 * @run main/othervm -Dhttp.keepAlive.time.server=100 -Dhttp.keepAlive.time.proxy=0 KeepAliveTest
 * @run main/othervm -Dhttp.keepAlive.time.server=0 -Dhttp.keepAlive.time.proxy=200 KeepAliveTest
 * @run main/othervm -Dhttp.keepAlive.time.server=100 -Dhttp.keepAlive.time.proxy=-200 KeepAliveTest
 * @run main/othervm -Dhttp.keepAlive.time.server=-100 -Dhttp.keepAlive.time.proxy=200 KeepAliveTest
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.Proxy.Type;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map.Entry;
import java.util.concurrent.Phaser;
import java.util.logging.ConsoleHandler;
import java.util.logging.Level;
import java.util.logging.Logger;

import jdk.test.lib.net.URIBuilder;

import sun.net.www.http.HttpClient;
import sun.net.www.http.KeepAliveCache;
import sun.net.www.protocol.http.HttpURLConnection;

public class KeepAliveTest {

    /*
     * This test covers a matrix of 10 server scenarios and 16 client scenarios.
     */
    private static final Logger logger = Logger.getLogger("sun.net.www.protocol.http.HttpURLConnection");

    private static final String NEW_LINE = "\r\n";

    private static final String CONNECTION_KEEP_ALIVE_ONLY = "Connection: keep-alive";
    private static final String PROXY_CONNECTION_KEEP_ALIVE_ONLY = "Proxy-Connection: keep-alive";
    private static final String KEEP_ALIVE_TIMEOUT_NEG = "Keep-alive: timeout=-20";
    private static final String KEEP_ALIVE_TIMEOUT_ZERO = "Keep-alive: timeout=0";
    private static final String KEEP_ALIVE_TIMEOUT = "Keep-alive: timeout=20";
    private static final String KEEP_ALIVE_PROXY_TIMEOUT = "Keep-alive: timeout=120";
    private static final String CONNECTION_KEEP_ALIVE_WITH_TIMEOUT = CONNECTION_KEEP_ALIVE_ONLY + NEW_LINE + KEEP_ALIVE_TIMEOUT;

    private static final String[] serverHeaders = {
        null,
        CONNECTION_KEEP_ALIVE_ONLY + NEW_LINE,
        CONNECTION_KEEP_ALIVE_WITH_TIMEOUT + NEW_LINE,
        PROXY_CONNECTION_KEEP_ALIVE_ONLY + NEW_LINE,
        PROXY_CONNECTION_KEEP_ALIVE_ONLY + NEW_LINE + CONNECTION_KEEP_ALIVE_ONLY + NEW_LINE,
        PROXY_CONNECTION_KEEP_ALIVE_ONLY + NEW_LINE + KEEP_ALIVE_PROXY_TIMEOUT + NEW_LINE,
        CONNECTION_KEEP_ALIVE_ONLY + NEW_LINE + KEEP_ALIVE_TIMEOUT_NEG + NEW_LINE,
        CONNECTION_KEEP_ALIVE_ONLY + NEW_LINE + KEEP_ALIVE_TIMEOUT_ZERO + NEW_LINE,
        PROXY_CONNECTION_KEEP_ALIVE_ONLY + NEW_LINE + KEEP_ALIVE_TIMEOUT_NEG + NEW_LINE,
        PROXY_CONNECTION_KEEP_ALIVE_ONLY + NEW_LINE + KEEP_ALIVE_TIMEOUT_ZERO + NEW_LINE
    };

    private static KeepAliveCache keepAliveCache;

    private static Constructor<?> keepAliveKeyClassconstructor;

    // variables set by server thread
    private volatile int serverPort;
    private volatile boolean isProxySet;

    private static final Phaser serverGate = new Phaser(2);

    private void readAll(Socket s) throws IOException {
        byte[] buf = new byte[128];
        int c;
        String request = "";
        InputStream is = s.getInputStream();
        while ((c = is.read(buf)) > 0) {
            request += new String(buf, 0, c, StandardCharsets.US_ASCII);
            if (request.contains("\r\n\r\n")) {
                return;
            }
        }
        if (c == -1) {
            throw new IOException("Socket closed");
        }
    }

    private void executeServer(int scenarioNumber) {
        String scenarioHeaders = serverHeaders[scenarioNumber];
        if (scenarioHeaders != null) {
            // isProxySet should be set before Server is moved to Listen State.
            isProxySet = scenarioHeaders.contains("Proxy");
        }
        try (ServerSocket serverSocket = new ServerSocket()) {
            serverSocket.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0));
            serverPort = serverSocket.getLocalPort();
            serverGate.arrive();

            // Server will be waiting for clients to connect.
            try (Socket socket = serverSocket.accept()) {
                readAll(socket);
                try (OutputStreamWriter out = new OutputStreamWriter(socket.getOutputStream())) {
                    String BODY = "SERVER REPLY: Hello world";
                    String CLEN = "Content-Length: " + BODY.length() + NEW_LINE;

                    // send common headers
                    out.write("HTTP/1.1 200 OK\r\n");
                    out.write("Content-Type: text/plain; charset=iso-8859-1\r\n");

                    // set scenario headers
                    if (scenarioHeaders != null) {
                        out.write(scenarioHeaders);
                    }

                    // send content
                    out.write(CLEN);
                    out.write(NEW_LINE);
                    out.write(BODY);
                }
            }
        } catch (IOException ioe) {
            throw new RuntimeException("IOException in server thread", ioe);
        }
    }

    private void fetchInfo(int expectedValue, HttpURLConnection httpUrlConnection) throws Exception {
        Object expectedKeepAliveKey = keepAliveKeyClassconstructor.newInstance(httpUrlConnection.getURL(), null);
        Object clientVectorObjectInMap = keepAliveCache.get(expectedKeepAliveKey);
        System.out.println("ClientVector for KeepAliveKey:" + clientVectorObjectInMap);
        HttpClient httpClientCached = keepAliveCache.get(httpUrlConnection.getURL(), null);
        System.out.println("HttpClient in Cache:" + httpClientCached);

        if (httpClientCached != null) {
            System.out.println("KeepingAlive:" + httpClientCached.isKeepingAlive());
            System.out.println("UsingProxy:" + httpClientCached.getUsingProxy());
            System.out.println("ProxiedHost:" + httpClientCached.getProxyHostUsed());
            System.out.println("ProxiedPort:" + httpClientCached.getProxyPortUsed());
            Class<?> clientVectorClass = Class.forName("sun.net.www.http.KeepAliveCache$ClientVector");
            Field napField = clientVectorClass.getDeclaredField("nap");
            napField.setAccessible(true);
            int napValue = (int) napField.get(clientVectorObjectInMap);
            int actualValue = napValue / 1000;
            if (expectedValue == actualValue) {
                System.out.printf("Cache time:%d\n", actualValue);
            } else {
                throw new RuntimeException("Sleep time of " + actualValue + " not expected (" + expectedValue + ")");
            }
        } else {
            if (expectedValue == 0) {
                System.out.println("Connection not cached.");
            } else {
                throw new RuntimeException("Connection was not cached although expected with sleep time of:" + expectedValue);
            }
        }
    }

    private void connectToServerURL(int expectedValue) throws Exception {
        // wait until ServerSocket moves to listening state.
        serverGate.arriveAndAwaitAdvance();
        URL url = URIBuilder.newBuilder().scheme("http").loopback().port(serverPort).toURL();
        System.out.println("connecting to server URL: " + url + ", isProxySet: " + isProxySet);
        HttpURLConnection httpUrlConnection = null;

        // isProxySet is set to true when Expected Server Response contains Proxy-Connection header.
        if (isProxySet) {
            httpUrlConnection = (HttpURLConnection) url
                .openConnection(new Proxy(Type.HTTP, new InetSocketAddress("localhost", serverPort)));
        } else {
            httpUrlConnection = (HttpURLConnection) url.openConnection();
        }

        try (InputStreamReader inputStreamReader = new InputStreamReader(httpUrlConnection.getInputStream());
             BufferedReader bufferedReader = new BufferedReader(inputStreamReader)) {
            while (true) {
                String line = bufferedReader.readLine();
                if (line == null) {
                    break;
                }
                System.out.println(line);
            }
        }
        for (Entry<String, List<String>> header : httpUrlConnection.getHeaderFields().entrySet()) {
            System.out.println(header.getKey() + "=" + header.getValue());
        }
        fetchInfo(expectedValue, httpUrlConnection);
    }

    private int getExpectedCachingValue(int serverScenario) {
        if (serverScenario == 2) {
            // Connection: keep-alive && Keep-alive: timeout=20
            //
            // server side keep-alive timeout is what counts here
            return 20;
        } else if (serverScenario == 3 || serverScenario == 4 || serverScenario == 8) {
            // Proxy-Connection: keep-alive
            // Connection:keep-alive && Proxy-connection:keep-alive
            // Proxy-Connection:keep-alive && Keep-alive:timeout=-20
            //
            // Proxy-connection:keep-alive is set, timeout could be invalid -> value of http.keepAlive.time.proxy or default of 60
            int httpKeepAliveTimeProxy;
            try {
                httpKeepAliveTimeProxy = Integer.valueOf(System.getProperty("http.keepAlive.time.proxy"));
            } catch (NumberFormatException e) {
                httpKeepAliveTimeProxy = -1;
            }
            return httpKeepAliveTimeProxy < 0 ? 60 : httpKeepAliveTimeProxy;
        } else if (serverScenario == 5) {
            // Proxy-connection:keep-alive && Keep-alive:timeout=120
            //
            // server side keep-alive timeout is what counts here
            return 120;
        } else if (serverScenario == 7 || serverScenario == 9) {
            // Connection: keep-alive && Keep-alive: timeout=0
            // Proxy-Connection:keep-alive && Keep-alive:timeout=0
            //
            // no caching
            return 0;
        } else {
            // No server parameters
            // Connection: keep-alive
            // Connection: keep-alive && Keep-alive: timeout=-20
            //
            // Nothing or Connection:keep-alive is set, timeout could be invalid -> value of http.keepAlive.time.server or default of 5
            int httpKeepAliveTimeServer;
            try {
                httpKeepAliveTimeServer = Integer.valueOf(System.getProperty("http.keepAlive.time.server"));
            } catch (NumberFormatException e) {
                httpKeepAliveTimeServer = -1;
            }
            return httpKeepAliveTimeServer < 0 ? 5 : httpKeepAliveTimeServer;
        }
    }

    private void runScenario(int scenarioNumber) throws Exception {
        int expectedValue = getExpectedCachingValue(scenarioNumber);
        System.out.println("Expecting Cache Time of " + expectedValue + " for server headers:");
        if (serverHeaders[scenarioNumber] == null) {
            System.out.println();
        } else {
            System.out.print(serverHeaders[scenarioNumber]);
        }
        Thread server = Thread.ofPlatform().start(() -> executeServer(scenarioNumber));
        connectToServerURL(expectedValue);
        server.join();
        System.out.println();
    }

    private static void initialize() throws Exception {
        System.clearProperty("http.proxyPort");
        System.clearProperty("http.proxyHost");
        System.setProperty("java.net.useSystemProxies", "false");

        Field keepAliveField = sun.net.www.http.HttpClient.class.getDeclaredField("kac");
        keepAliveField.setAccessible(true);
        keepAliveCache = (KeepAliveCache) keepAliveField.get(null);
        System.out.println("KeepAliveCache: " + keepAliveCache);
        keepAliveKeyClassconstructor = Class.forName("sun.net.www.http.KeepAliveKey").getDeclaredConstructors()[0];
        keepAliveKeyClassconstructor.setAccessible(true);

        logger.setLevel(Level.FINEST);
        ConsoleHandler h = new ConsoleHandler();
        h.setLevel(Level.FINEST);
        logger.addHandler(h);

        System.out.println("Client properties: http.keepAlive.time.server=" + System.getProperty("http.keepAlive.time.server") +
                ", http.keepAlive.time.proxy=" + System.getProperty("http.keepAlive.time.proxy"));
    }

    public static void main(String[] args) throws Exception {
        if (args.length > 1) {
            throw new IllegalArgumentException("Usage:java KeepAliveTest.java <scenarioNumber>");
        } else if (args.length == 1) {
            // an individual test scenario
            try {
                int scenarioNumber = Integer.valueOf(args[0]);
                if (scenarioNumber < 0 || scenarioNumber > 9) {
                    throw new IllegalArgumentException("Scenario " + scenarioNumber + " does not exist");
                }
                initialize();
                new KeepAliveTest().runScenario(scenarioNumber);
            } catch (NumberFormatException e) {
                throw new IllegalArgumentException("Scenario must be a number, got " + args[0]);
            }
        } else {
            // all server scenarios
            initialize();
            for (int i = 0; i < 10; i++) {
                new KeepAliveTest().runScenario(i);
            }
        }
    }
}