/*

 * Copyright (c) 2018, 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 java.io.BufferedInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.UncheckedIOException;

import java.net.ConnectException;

import java.net.InetAddress;

import java.net.InetSocketAddress;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.URI;

import java.time.Duration;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.CompletionException;

import java.net.http.HttpClient;

import java.net.http.HttpClient.Version;

import java.net.http.HttpConnectTimeoutException;

import java.net.http.HttpRequest;

import java.net.http.HttpRequest.BodyPublishers;

import java.net.http.HttpResponse;

import java.net.http.HttpResponse.BodyHandlers;

import org.testng.annotations.AfterTest;

import org.testng.annotations.BeforeTest;

import org.testng.annotations.DataProvider;

import static java.lang.String.format;

import static java.lang.System.out;

import static java.net.http.HttpClient.Builder.NO_PROXY;

import static java.net.http.HttpClient.Version.HTTP_1_1;

import static java.net.http.HttpClient.Version.HTTP_2;

import static java.time.Duration.*;

import static java.util.concurrent.TimeUnit.NANOSECONDS;

import static org.testng.Assert.fail;

public abstract class AbstractConnectTimeoutHandshake {

    // The number of iterations each testXXXClient performs.

    static final int TIMES = 2;

    Server server;

    URI httpsURI;

    static final Duration NO_DURATION = null;

    static List<List<Duration>> TIMEOUTS = List.of(

                    // connectTimeout   HttpRequest timeout

            Arrays.asList( NO_DURATION,   ofSeconds(1)  ),

            Arrays.asList( NO_DURATION,   ofSeconds(2)  ),

            Arrays.asList( NO_DURATION,   ofMillis(500) ),

            Arrays.asList( ofSeconds(1),  NO_DURATION   ),

            Arrays.asList( ofSeconds(2),  NO_DURATION   ),

            Arrays.asList( ofMillis(500), NO_DURATION   ),

            Arrays.asList( ofSeconds(1),  ofMinutes(1)  ),

            Arrays.asList( ofSeconds(2),  ofMinutes(1)  ),

            Arrays.asList( ofMillis(500), ofMinutes(1)  )

    );

    static final List<String> METHODS = List.of("GET" , "POST");

    static final List<Version> VERSIONS = List.of(HTTP_2, HTTP_1_1);

    @DataProvider(name = "variants")

    public Object[][] variants() {

        List<Object[]> l = new ArrayList<>();

        for (List<Duration> timeouts : TIMEOUTS) {

           Duration connectTimeout = timeouts.get(0);

           Duration requestTimeout = timeouts.get(1);

           for (String method: METHODS) {

            for (Version requestVersion : VERSIONS) {

             l.add(new Object[] {requestVersion, method, connectTimeout, requestTimeout});

        }}}

        return l.stream().toArray(Object[][]::new);

    }

    //@Test(dataProvider = "variants")

    protected void timeoutSync(Version requestVersion,

                              String method,

                              Duration connectTimeout,

                              Duration requestTimeout)

        throws Exception

    {

        out.printf("%n--- timeoutSync requestVersion=%s, method=%s, "

                   + "connectTimeout=%s, requestTimeout=%s ---%n",

                   requestVersion, method, connectTimeout, requestTimeout);

        HttpClient client = newClient(connectTimeout);

        HttpRequest request = newRequest(requestVersion, method, requestTimeout);

        for (int i = 0; i < TIMES; i++) {

            out.printf("iteration %d%n", i);

            long startTime = System.nanoTime();

            try {

                HttpResponse<String> resp = client.send(request, BodyHandlers.ofString());

                printResponse(resp);

                fail("Unexpected response: " + resp);

            } catch (HttpConnectTimeoutException expected) {

                long elapsedTime = NANOSECONDS.toMillis(System.nanoTime() - startTime);

                out.printf("Client: received in %d millis%n", elapsedTime);

                out.printf("Client: caught expected HttpConnectTimeoutException: %s%n", expected);

                checkExceptionOrCause(ConnectException.class, expected);

            }

        }

    }

    //@Test(dataProvider = "variants")

    protected void timeoutAsync(Version requestVersion,

                                String method,

                                Duration connectTimeout,

                                Duration requestTimeout) {

        out.printf("%n--- timeoutAsync requestVersion=%s, method=%s, "

                        + "connectTimeout=%s, requestTimeout=%s ---%n",

                   requestVersion, method, connectTimeout, requestTimeout);

        HttpClient client = newClient(connectTimeout);

        HttpRequest request = newRequest(requestVersion, method, requestTimeout);

        for (int i = 0; i < TIMES; i++) {

            out.printf("iteration %d%n", i);

            long startTime = System.nanoTime();

            CompletableFuture<HttpResponse<String>> cf =

                    client.sendAsync(request, BodyHandlers.ofString());

            try {

                HttpResponse<String> resp = cf.join();

                printResponse(resp);

                fail("Unexpected response: " + resp);

            } catch (CompletionException ce) {

                long elapsedTime = NANOSECONDS.toMillis(System.nanoTime() - startTime);

                out.printf("Client: received in %d millis%n", elapsedTime);

                Throwable expected = ce.getCause();

                if (expected instanceof HttpConnectTimeoutException) {

                    out.printf("Client: caught expected HttpConnectTimeoutException: %s%n", expected);

                    checkExceptionOrCause(ConnectException.class, expected);

                } else {

                    out.printf("Client: caught UNEXPECTED exception: %s%n", expected);

                    throw ce;

                }

            }

        }

    }

    static HttpClient newClient(Duration connectTimeout) {

        HttpClient.Builder builder = HttpClient.newBuilder().proxy(NO_PROXY);

        if (connectTimeout != NO_DURATION)

            builder.connectTimeout(connectTimeout);

        return builder.build();

    }

    HttpRequest newRequest(Version reqVersion,

                           String method,

                           Duration requestTimeout) {

        HttpRequest.Builder reqBuilder = HttpRequest.newBuilder(httpsURI);

        reqBuilder = reqBuilder.version(reqVersion);

        switch (method) {

            case "GET"   : reqBuilder.GET();                         break;

            case "POST"  : reqBuilder.POST(BodyPublishers.noBody()); break;

            default: throw new AssertionError("Unknown method:" + method);

        }

        if (requestTimeout != NO_DURATION)

            reqBuilder.timeout(requestTimeout);

        return reqBuilder.build();

    }

    static void checkExceptionOrCause(Class<? extends Throwable> clazz, Throwable t) {

        final Throwable original = t;

        do {

            if (clazz.isInstance(t)) {

                System.out.println("Found expected exception/cause: " + t);

                return; // found

            }

        } while ((t = t.getCause()) != null);

        original.printStackTrace(System.out);

        throw new RuntimeException("Expected " + clazz + "in " + original);

    }

    static void printResponse(HttpResponse<?> response) {

        out.println("Unexpected response: " + response);

        out.println("Headers: " + response.headers());

        out.println("Body: " + response.body());

    }

    // -- Infrastructure

    static String serverAuthority(Server server) {

        return InetAddress.getLoopbackAddress().getHostName() + ":"

                + server.getPort();

    }

    @BeforeTest

    public void setup() throws Exception {

        server = new Server();

        httpsURI = URI.create("https://" + serverAuthority(server) + "/foo");

        out.println("HTTPS URI: " + httpsURI);

    }

    @AfterTest

    public void teardown() throws Exception {

        server.close();

        out.printf("%n--- teardown ---%n");

        int numClientConnections = variants().length * TIMES;

        int serverCount = server.count;

        out.printf("Client made %d connections.%n", numClientConnections);

        out.printf("Server received %d connections.%n", serverCount);

        // This is usually the case, but not always, do not assert. Remains

        // as an informative message only.

        //if (numClientConnections != serverCount)

        //    fail(format("[numTests: %d] != [serverCount: %d]",

        //                numClientConnections, serverCount));

    }

    /**

     * Emulates a server-side, using plain cleartext Sockets, that just reads

     * initial client hello and does nothing more.

     */

    static class Server extends Thread implements AutoCloseable {

        private final ServerSocket ss;

        private volatile boolean closed;

        volatile int count;

        Server() throws IOException {

            super("Server");

            ss = new ServerSocket();

            ss.setReuseAddress(false);

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

            this.start();

        }

        int getPort() {

            return ss.getLocalPort();

        }

        @Override

        public void close() {

            if (closed)

                return;

            closed = true;

            try {

                ss.close();

            } catch (IOException e) {

                throw new UncheckedIOException("Unexpected", e);

            }

        }

        @Override

        public void run() {

            while (!closed) {

                try (Socket s = ss.accept()) {

                    count++;

                    out.println("Server: accepted new connection");

                    InputStream is = new BufferedInputStream(s.getInputStream());

                    out.println("Server: starting to read");

                    while (is.read() != -1) ;

                    out.println("Server: closing connection");

                    s.close(); // close without giving any reply

                } catch (IOException e) {

                    if (!closed)

                        out.println("UNEXPECTED " + e);

                }

            }

        }

    }

}