/*

 * Copyright (c) 2018, 2019, 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.

 */

import com.sun.net.httpserver.BasicAuthenticator;

import com.sun.net.httpserver.HttpServer;

import com.sun.net.httpserver.HttpsConfigurator;

import com.sun.net.httpserver.HttpsParameters;

import com.sun.net.httpserver.HttpsServer;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.io.Writer;

import java.math.BigInteger;

import java.net.Authenticator;

import java.net.HttpURLConnection;

import java.net.InetAddress;

import java.net.InetSocketAddress;

import java.net.MalformedURLException;

import java.net.PasswordAuthentication;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.StandardSocketOptions;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

import java.nio.charset.StandardCharsets;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.time.Instant;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Base64;

import java.util.List;

import java.util.Locale;

import java.util.Objects;

import java.util.Optional;

import java.util.Random;

import java.util.StringTokenizer;

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.CopyOnWriteArrayList;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import javax.net.ssl.SSLContext;

import sun.net.www.HeaderParser;

import java.net.http.HttpClient.Version;

/**

 * A simple HTTP server that supports Basic or Digest authentication.

 * By default this server will echo back whatever is present

 * in the request body. Note that the Digest authentication is

 * a test implementation implemented only for tests purposes.

 * @author danielfuchs

 */

public abstract class DigestEchoServer implements HttpServerAdapters {

    public static final boolean DEBUG =

            Boolean.parseBoolean(System.getProperty("test.debug", "false"));

    public static final boolean NO_LINGER =

            Boolean.parseBoolean(System.getProperty("test.nolinger", "false"));

    public static final boolean TUNNEL_REQUIRES_HOST =

            Boolean.parseBoolean(System.getProperty("test.requiresHost", "false"));

    public enum HttpAuthType {

        SERVER, PROXY, SERVER307, PROXY305

        /* add PROXY_AND_SERVER and SERVER_PROXY_NONE */

    };

    public enum HttpAuthSchemeType { NONE, BASICSERVER, BASIC, DIGEST };

    public static final HttpAuthType DEFAULT_HTTP_AUTH_TYPE = HttpAuthType.SERVER;

    public static final String DEFAULT_PROTOCOL_TYPE = "https";

    public static final HttpAuthSchemeType DEFAULT_SCHEME_TYPE = HttpAuthSchemeType.DIGEST;

    public static class HttpTestAuthenticator extends Authenticator {

        private final String realm;

        private final String username;

        // Used to prevent incrementation of 'count' when calling the

        // authenticator from the server side.

        private final ThreadLocal<Boolean> skipCount = new ThreadLocal<>();

        // count will be incremented every time getPasswordAuthentication()

        // is called from the client side.

        final AtomicInteger count = new AtomicInteger();

        public HttpTestAuthenticator(String realm, String username) {

            this.realm = realm;

            this.username = username;

        }

        @Override

        protected PasswordAuthentication getPasswordAuthentication() {

            if (skipCount.get() == null || skipCount.get().booleanValue() == false) {

                System.out.println("Authenticator called: " + count.incrementAndGet());

            }

            return new PasswordAuthentication(getUserName(),

                    new char[] {'d','e','n', 't'});

        }

        // Called by the server side to get the password of the user

        // being authentified.

        public final char[] getPassword(String user) {

            if (user.equals(username)) {

                skipCount.set(Boolean.TRUE);

                try {

                    return getPasswordAuthentication().getPassword();

                } finally {

                    skipCount.set(Boolean.FALSE);

                }

            }

            throw new SecurityException("User unknown: " + user);

        }

        public final String getUserName() {

            return username;

        }

        public final String getRealm() {

            return realm;

        }

    }

    public static final HttpTestAuthenticator AUTHENTICATOR;

    static {

        AUTHENTICATOR = new HttpTestAuthenticator("earth", "arthur");

    }

    final HttpTestServer       serverImpl; // this server endpoint

    final DigestEchoServer     redirect;   // the target server where to redirect 3xx

    final HttpTestHandler      delegate;   // unused

    final String               key;

    DigestEchoServer(String key,

                             HttpTestServer server,

                             DigestEchoServer target,

                             HttpTestHandler delegate) {

        this.key = key;

        this.serverImpl = server;

        this.redirect = target;

        this.delegate = delegate;

    }

    public static void main(String[] args)

            throws IOException {

        DigestEchoServer server = create(Version.HTTP_1_1,

                DEFAULT_PROTOCOL_TYPE,

                DEFAULT_HTTP_AUTH_TYPE,

                AUTHENTICATOR,

                DEFAULT_SCHEME_TYPE);

        try {

            System.out.println("Server created at " + server.getAddress());

            System.out.println("Strike <Return> to exit");

            System.in.read();

        } finally {

            System.out.println("stopping server");

            server.stop();

        }

    }

    private static String toString(HttpTestRequestHeaders headers) {

        return headers.entrySet().stream()

                .map((e) -> e.getKey() + ": " + e.getValue())

                .collect(Collectors.joining("\n"));

    }

    public static DigestEchoServer create(Version version,

                                          String protocol,

                                          HttpAuthType authType,

                                          HttpAuthSchemeType schemeType)

            throws IOException {

        return create(version, protocol, authType, AUTHENTICATOR, schemeType);

    }

    public static DigestEchoServer create(Version version,

                                          String protocol,

                                          HttpAuthType authType,

                                          HttpTestAuthenticator auth,

                                          HttpAuthSchemeType schemeType)

            throws IOException {

        return create(version, protocol, authType, auth, schemeType, null);

    }

    public static DigestEchoServer create(Version version,

                                        String protocol,

                                        HttpAuthType authType,

                                        HttpTestAuthenticator auth,

                                        HttpAuthSchemeType schemeType,

                                        HttpTestHandler delegate)

            throws IOException {

        Objects.requireNonNull(authType);

        Objects.requireNonNull(auth);

        switch(authType) {

            // A server that performs Server Digest authentication.

            case SERVER: return createServer(version, protocol, authType, auth,

                                             schemeType, delegate, "/");

            // A server that pretends to be a Proxy and performs

            // Proxy Digest authentication. If protocol is HTTPS,

            // then this will create a HttpsProxyTunnel that will

            // handle the CONNECT request for tunneling.

            case PROXY: return createProxy(version, protocol, authType, auth,

                                           schemeType, delegate, "/");

            // A server that sends 307 redirect to a server that performs

            // Digest authentication.

            // Note: 301 doesn't work here because it transforms POST into GET.

            case SERVER307: return createServerAndRedirect(version,

                                                        protocol,

                                                        HttpAuthType.SERVER,

                                                        auth, schemeType,

                                                        delegate, 307);

            // A server that sends 305 redirect to a proxy that performs

            // Digest authentication.

            // Note: this is not correctly stubbed/implemented in this test.

            case PROXY305:  return createServerAndRedirect(version,

                                                        protocol,

                                                        HttpAuthType.PROXY,

                                                        auth, schemeType,

                                                        delegate, 305);

            default:

                throw new InternalError("Unknown server type: " + authType);

        }

    }

    /**

     * The SocketBindableFactory ensures that the local port used by an HttpServer

     * or a proxy ServerSocket previously created by the current test/VM will not

     * get reused by a subsequent test in the same VM.

     * This is to avoid having the test client trying to reuse cached connections.

     */

    private static abstract class SocketBindableFactory<B> {

        private static final int MAX = 10;

        private static final CopyOnWriteArrayList<String> addresses =

                new CopyOnWriteArrayList<>();

        protected B createInternal() throws IOException {

            final int max = addresses.size() + MAX;

            final List<B> toClose = new ArrayList<>();

            try {

                for (int i = 1; i <= max; i++) {

                    B bindable = createBindable();

                    InetSocketAddress address = getAddress(bindable);

                    String key = "localhost:" + address.getPort();

                    if (addresses.addIfAbsent(key)) {

                        System.out.println("Socket bound to: " + key

                                + " after " + i + " attempt(s)");

                        return bindable;

                    }

                    System.out.println("warning: address " + key

                            + " already used. Retrying bind.");

                    // keep the port bound until we get a port that we haven't

                    // used already

                    toClose.add(bindable);

                }

            } finally {

                // if we had to retry, then close the socket we're not

                // going to use.

                for (B b : toClose) {

                    try { close(b); } catch (Exception x) { /* ignore */ }

                }

            }

            throw new IOException("Couldn't bind socket after " + max + " attempts: "

                    + "addresses used before: " + addresses);

        }

        protected abstract B createBindable() throws IOException;

        protected abstract InetSocketAddress getAddress(B bindable);

        protected abstract void close(B bindable) throws IOException;

    }

    /*

     * Used to create ServerSocket for a proxy.

     */

    private static final class ServerSocketFactory

    extends SocketBindableFactory<ServerSocket> {

        private static final ServerSocketFactory instance = new ServerSocketFactory();

        static ServerSocket create() throws IOException {

            return instance.createInternal();

        }

        @Override

        protected ServerSocket createBindable() throws IOException {

            ServerSocket ss = new ServerSocket();

            ss.setReuseAddress(false);

            ss.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0));

            return ss;

        }

        @Override

        protected InetSocketAddress getAddress(ServerSocket socket) {

            return new InetSocketAddress(socket.getInetAddress(), socket.getLocalPort());

        }

        @Override

        protected void close(ServerSocket socket) throws IOException {

            socket.close();

        }

    }

    /*

     * Used to create HttpServer

     */

    private static abstract class H1ServerFactory<S extends HttpServer>

            extends SocketBindableFactory<S> {

        @Override

        protected S createBindable() throws IOException {

            S server = newHttpServer();

            server.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0), 0);

            return server;

        }

        @Override

        protected InetSocketAddress getAddress(S server) {

            return server.getAddress();

        }

        @Override

        protected void close(S server) throws IOException {

            server.stop(1);

        }

        /*

         * Returns a HttpServer or a HttpsServer in different subclasses.

         */

        protected abstract S newHttpServer() throws IOException;

    }

    /*

     * Used to create Http2TestServer

     */

    private static abstract class H2ServerFactory<S extends Http2TestServer>

            extends SocketBindableFactory<S> {

        @Override

        protected S createBindable() throws IOException {

            final S server;

            try {

                server = newHttpServer();

            } catch (IOException io) {

                throw io;

            } catch (Exception x) {

                throw new IOException(x);

            }

            return server;

        }

        @Override

        protected InetSocketAddress getAddress(S server) {

            return server.getAddress();

        }

        @Override

        protected void close(S server) throws IOException {

            server.stop();

        }

        /*

         * Returns a HttpServer or a HttpsServer in different subclasses.

         */

        protected abstract S newHttpServer() throws Exception;

    }

    private static final class Http2ServerFactory extends H2ServerFactory<Http2TestServer> {

        private static final Http2ServerFactory instance = new Http2ServerFactory();

        static Http2TestServer create() throws IOException {

            return instance.createInternal();

        }

        @Override

        protected Http2TestServer newHttpServer() throws Exception {

            return new Http2TestServer("localhost", false, 0);

        }

    }

    private static final class Https2ServerFactory extends H2ServerFactory<Http2TestServer> {

        private static final Https2ServerFactory instance = new Https2ServerFactory();

        static Http2TestServer create() throws IOException {

            return instance.createInternal();

        }

        @Override

        protected Http2TestServer newHttpServer() throws Exception {

            return new Http2TestServer("localhost", true, 0);

        }

    }

    private static final class Http1ServerFactory extends H1ServerFactory<HttpServer> {

        private static final Http1ServerFactory instance = new Http1ServerFactory();

        static HttpServer create() throws IOException {

            return instance.createInternal();

        }

        @Override

        protected HttpServer newHttpServer() throws IOException {

            return HttpServer.create();

        }

    }

    private static final class Https1ServerFactory extends H1ServerFactory<HttpsServer> {

        private static final Https1ServerFactory instance = new Https1ServerFactory();

        static HttpsServer create() throws IOException {

            return instance.createInternal();

        }

        @Override

        protected HttpsServer newHttpServer() throws IOException {

            return HttpsServer.create();

        }

    }

    static Http2TestServer createHttp2Server(String protocol) throws IOException {

        final Http2TestServer server;

        if ("http".equalsIgnoreCase(protocol)) {

            server = Http2ServerFactory.create();

        } else if ("https".equalsIgnoreCase(protocol)) {

            server = Https2ServerFactory.create();

        } else {

            throw new InternalError("unsupported protocol: " + protocol);

        }

        return server;

    }

    static HttpTestServer createHttpServer(Version version, String protocol)

            throws IOException

    {

        switch(version) {

            case HTTP_1_1:

                return HttpTestServer.of(createHttp1Server(protocol));

            case HTTP_2:

                return HttpTestServer.of(createHttp2Server(protocol));

            default:

                throw new InternalError("Unexpected version: " + version);

        }

    }

    static HttpServer createHttp1Server(String protocol) throws IOException {

        final HttpServer server;

        if ("http".equalsIgnoreCase(protocol)) {

            server = Http1ServerFactory.create();

        } else if ("https".equalsIgnoreCase(protocol)) {

            server = configure(Https1ServerFactory.create());

        } else {

            throw new InternalError("unsupported protocol: " + protocol);

        }

        return server;

    }

    static HttpsServer configure(HttpsServer server) throws IOException {

        try {

            SSLContext ctx = SSLContext.getDefault();

            server.setHttpsConfigurator(new Configurator(ctx));

        } catch (NoSuchAlgorithmException ex) {

            throw new IOException(ex);

        }

        return server;

    }

    static void setContextAuthenticator(HttpTestContext ctxt,

                                        HttpTestAuthenticator auth) {

        final String realm = auth.getRealm();

        com.sun.net.httpserver.Authenticator authenticator =

            new BasicAuthenticator(realm) {

                @Override

                public boolean checkCredentials(String username, String pwd) {

                    return auth.getUserName().equals(username)

                           && new String(auth.getPassword(username)).equals(pwd);

                }

        };

        ctxt.setAuthenticator(authenticator);

    }

    public static DigestEchoServer createServer(Version version,

                                        String protocol,

                                        HttpAuthType authType,

                                        HttpTestAuthenticator auth,

                                        HttpAuthSchemeType schemeType,

                                        HttpTestHandler delegate,

                                        String path)

            throws IOException {

        Objects.requireNonNull(authType);

        Objects.requireNonNull(auth);

        HttpTestServer impl = createHttpServer(version, protocol);

        String key = String.format("DigestEchoServer[PID=%s,PORT=%s]:%s:%s:%s:%s",

                ProcessHandle.current().pid(),

                impl.getAddress().getPort(),

                version, protocol, authType, schemeType);

        final DigestEchoServer server = new DigestEchoServerImpl(key, impl, null, delegate);

        final HttpTestHandler handler =

                server.createHandler(schemeType, auth, authType, false);

        HttpTestContext context = impl.addHandler(handler, path);

        server.configureAuthentication(context, schemeType, auth, authType);

        impl.start();

        return server;

    }

    public static DigestEchoServer createProxy(Version version,

                                        String protocol,

                                        HttpAuthType authType,

                                        HttpTestAuthenticator auth,

                                        HttpAuthSchemeType schemeType,

                                        HttpTestHandler delegate,

                                        String path)

            throws IOException {