/*
 * Copyright (c) 2017, 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.IOException;
import java.lang.reflect.Method;
import java.net.Authenticator;
import java.net.CookieHandler;
import java.net.CookieManager;
import java.net.InetSocketAddress;
import java.net.ProxySelector;
import java.net.URI;
import java.net.http.HttpHeaders;
import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandler;
import java.net.http.HttpResponse.BodyHandlers;
import java.net.http.HttpResponse.PushPromiseHandler;
import java.time.Duration;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.TreeMap;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLParameters;
import java.net.http.HttpClient;
import java.net.http.HttpClient.Redirect;
import java.net.http.HttpClient.Version;
import jdk.testlibrary.SimpleSSLContext;
import org.testng.annotations.Test;
import static org.testng.Assert.*;

/*
 * @test
 * @summary HttpClient[.Builder] API and behaviour checks
 * @library /lib/testlibrary/
 * @build jdk.testlibrary.SimpleSSLContext
 * @run testng HttpClientBuilderTest
 */

public class HttpClientBuilderTest {

    static final Class<NullPointerException> NPE = NullPointerException.class;
    static final Class<IllegalArgumentException> IAE = IllegalArgumentException.class;

    @Test
    public void testDefaults() throws Exception {
        List<HttpClient> clients = List.of(HttpClient.newHttpClient(),
                                           HttpClient.newBuilder().build());

        for (HttpClient client : clients) {
            // Empty optionals and defaults
            assertFalse(client.authenticator().isPresent());
            assertFalse(client.cookieHandler().isPresent());
            assertFalse(client.executor().isPresent());
            assertFalse(client.proxy().isPresent());
            assertTrue(client.sslParameters() != null);
            assertTrue(client.followRedirects().equals(HttpClient.Redirect.NEVER));
            assertTrue(client.sslContext() == SSLContext.getDefault());
            assertTrue(client.version().equals(HttpClient.Version.HTTP_2));
        }
    }

    @Test
    public void testNull() throws Exception {
        HttpClient.Builder builder = HttpClient.newBuilder();
        assertThrows(NPE, () -> builder.authenticator(null));
        assertThrows(NPE, () -> builder.cookieHandler(null));
        assertThrows(NPE, () -> builder.executor(null));
        assertThrows(NPE, () -> builder.proxy(null));
        assertThrows(NPE, () -> builder.sslParameters(null));
        assertThrows(NPE, () -> builder.followRedirects(null));
        assertThrows(NPE, () -> builder.sslContext(null));
        assertThrows(NPE, () -> builder.version(null));
    }

    static class TestAuthenticator extends Authenticator { }

    @Test
    public void testAuthenticator() {
        HttpClient.Builder builder = HttpClient.newBuilder();
        Authenticator a = new TestAuthenticator();
        builder.authenticator(a);
        assertTrue(builder.build().authenticator().get() == a);
        Authenticator b = new TestAuthenticator();
        builder.authenticator(b);
        assertTrue(builder.build().authenticator().get() == b);
        assertThrows(NPE, () -> builder.authenticator(null));
        Authenticator c = new TestAuthenticator();
        builder.authenticator(c);
        assertTrue(builder.build().authenticator().get() == c);
    }

    @Test
    public void testCookieHandler() {
        HttpClient.Builder builder = HttpClient.newBuilder();
        CookieHandler a = new CookieManager();
        builder.cookieHandler(a);
        assertTrue(builder.build().cookieHandler().get() == a);
        CookieHandler b = new CookieManager();
        builder.cookieHandler(b);
        assertTrue(builder.build().cookieHandler().get() == b);
        assertThrows(NPE, () -> builder.cookieHandler(null));
        CookieManager c = new CookieManager();
        builder.cookieHandler(c);
        assertTrue(builder.build().cookieHandler().get() == c);
    }

    static class TestExecutor implements Executor {
        public void execute(Runnable r) { }
    }

    @Test
    public void testExecutor() {
        HttpClient.Builder builder = HttpClient.newBuilder();
        TestExecutor a = new TestExecutor();
        builder.executor(a);
        assertTrue(builder.build().executor().get() == a);
        TestExecutor b = new TestExecutor();
        builder.executor(b);
        assertTrue(builder.build().executor().get() == b);
        assertThrows(NPE, () -> builder.executor(null));
        TestExecutor c = new TestExecutor();
        builder.executor(c);
        assertTrue(builder.build().executor().get() == c);
    }

    @Test
    public void testProxySelector() {
        HttpClient.Builder builder = HttpClient.newBuilder();
        ProxySelector a = ProxySelector.of(null);
        builder.proxy(a);
        assertTrue(builder.build().proxy().get() == a);
        ProxySelector b = ProxySelector.of(InetSocketAddress.createUnresolved("foo", 80));
        builder.proxy(b);
        assertTrue(builder.build().proxy().get() == b);
        assertThrows(NPE, () -> builder.proxy(null));
        ProxySelector c = ProxySelector.of(InetSocketAddress.createUnresolved("bar", 80));
        builder.proxy(c);
        assertTrue(builder.build().proxy().get() == c);
    }

    @Test
    public void testSSLParameters() {
        HttpClient.Builder builder = HttpClient.newBuilder();
        SSLParameters a = new SSLParameters();
        a.setCipherSuites(new String[] { "A" });
        builder.sslParameters(a);
        a.setCipherSuites(new String[] { "Z" });
        assertTrue(builder.build().sslParameters() != (a));
        assertTrue(builder.build().sslParameters().getCipherSuites()[0].equals("A"));
        SSLParameters b = new SSLParameters();
        b.setEnableRetransmissions(true);
        builder.sslParameters(b);
        assertTrue(builder.build().sslParameters() != b);
        assertTrue(builder.build().sslParameters().getEnableRetransmissions());
        assertThrows(NPE, () -> builder.sslParameters(null));
        SSLParameters c = new SSLParameters();
        c.setProtocols(new String[] { "C" });
        builder.sslParameters(c);
        c.setProtocols(new String[] { "D" });
        assertTrue(builder.build().sslParameters().getProtocols()[0].equals("C"));
    }

    @Test
    public void testSSLContext() throws Exception {
        HttpClient.Builder builder = HttpClient.newBuilder();
        SSLContext a = (new SimpleSSLContext()).get();
        builder.sslContext(a);
        assertTrue(builder.build().sslContext() == a);
        SSLContext b = (new SimpleSSLContext()).get();
        builder.sslContext(b);
        assertTrue(builder.build().sslContext() == b);
        assertThrows(NPE, () -> builder.sslContext(null));
        SSLContext c = (new SimpleSSLContext()).get();
        builder.sslContext(c);
        assertTrue(builder.build().sslContext() == c);
    }

    @Test
    public void testFollowRedirects() {
        HttpClient.Builder builder = HttpClient.newBuilder();
        builder.followRedirects(Redirect.ALWAYS);
        assertTrue(builder.build().followRedirects() == Redirect.ALWAYS);
        builder.followRedirects(Redirect.NEVER);
        assertTrue(builder.build().followRedirects() == Redirect.NEVER);
        assertThrows(NPE, () -> builder.followRedirects(null));
        builder.followRedirects(Redirect.NORMAL);
        assertTrue(builder.build().followRedirects() == Redirect.NORMAL);
    }

    @Test
    public void testVersion() {
        HttpClient.Builder builder = HttpClient.newBuilder();
        builder.version(Version.HTTP_2);
        assertTrue(builder.build().version() == Version.HTTP_2);
        builder.version(Version.HTTP_1_1);
        assertTrue(builder.build().version() == Version.HTTP_1_1);
        assertThrows(NPE, () -> builder.version(null));
        builder.version(Version.HTTP_2);
        assertTrue(builder.build().version() == Version.HTTP_2);
        builder.version(Version.HTTP_1_1);
        assertTrue(builder.build().version() == Version.HTTP_1_1);
    }

    @Test
    static void testPriority() throws Exception {
        HttpClient.Builder builder = HttpClient.newBuilder();
        assertThrows(IAE, () -> builder.priority(-1));
        assertThrows(IAE, () -> builder.priority(0));
        assertThrows(IAE, () -> builder.priority(257));
        assertThrows(IAE, () -> builder.priority(500));

        builder.priority(1);
        builder.build();
        builder.priority(256);
        builder.build();
    }

    // ---

    static final URI uri = URI.create("http://foo.com/");

    @Test
    static void testHttpClientSendArgs() throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder(uri).build();

        assertThrows(NPE, () -> client.send(null, BodyHandlers.discarding()));
        assertThrows(NPE, () -> client.send(request, null));
        assertThrows(NPE, () -> client.send(null, null));

        assertThrows(NPE, () -> client.sendAsync(null, BodyHandlers.discarding()));
        assertThrows(NPE, () -> client.sendAsync(request, null));
        assertThrows(NPE, () -> client.sendAsync(null, null));

        assertThrows(NPE, () -> client.sendAsync(null, BodyHandlers.discarding(), null));
        assertThrows(NPE, () -> client.sendAsync(request, null, null));
        assertThrows(NPE, () -> client.sendAsync(null, null, null));

        // CONNECT is disallowed in the implementation, since it is used for
        // tunneling, and is handled separately for security checks.
        HttpRequest connectRequest = new HttpConnectRequest();
        assertThrows(IAE, () -> client.send(connectRequest, BodyHandlers.discarding()));
        assertThrows(IAE, () -> client.sendAsync(connectRequest, BodyHandlers.discarding()));
        assertThrows(IAE, () -> client.sendAsync(connectRequest, BodyHandlers.discarding(), null));
    }

    static class HttpConnectRequest extends HttpRequest {
        @Override public Optional<BodyPublisher> bodyPublisher() { return Optional.empty(); }
        @Override public String method() { return "CONNECT"; }
        @Override public Optional<Duration> timeout() { return Optional.empty(); }
        @Override public boolean expectContinue() { return false; }
        @Override public URI uri() { return URI.create("http://foo.com/"); }
        @Override public Optional<Version> version() { return Optional.empty(); }
        @Override public HttpHeaders headers() { return HttpHeaders.of(Map.of(), (x, y) -> true); }
    }

    // ---

    static final Class<UnsupportedOperationException> UOE =
            UnsupportedOperationException.class;

    @Test
    static void testUnsupportedWebSocket() throws Exception {
        //  @implSpec The default implementation of this method throws
        // {@code UnsupportedOperationException}.
        assertThrows(UOE, () -> (new MockHttpClient()).newWebSocketBuilder());
    }

    static class MockHttpClient extends HttpClient {
        @Override public Optional<CookieHandler> cookieHandler() { return null; }
        @Override public Redirect followRedirects() { return null; }
        @Override public Optional<ProxySelector> proxy() { return null; }
        @Override public SSLContext sslContext() { return null; }
        @Override public SSLParameters sslParameters() { return null; }
        @Override public Optional<Authenticator> authenticator() { return null; }
        @Override public Version version() { return null; }
        @Override public Optional<Executor> executor() { return null; }
        @Override public <T> HttpResponse<T>
        send(HttpRequest request, BodyHandler<T> responseBodyHandler)
                throws IOException, InterruptedException {
            return null;
        }
        @Override public <T> CompletableFuture<HttpResponse<T>>
        sendAsync(HttpRequest request, BodyHandler<T> responseBodyHandler) {
            return null;
        }
        @Override
        public <T> CompletableFuture<HttpResponse<T>>
        sendAsync(HttpRequest x, BodyHandler<T> y, PushPromiseHandler<T> z) {
            return null;
        }
    }

    /* ---- standalone entry point ---- */

    public static void main(String[] args) throws Exception {
        HttpClientBuilderTest test = new HttpClientBuilderTest();
        for (Method m : HttpClientBuilderTest.class.getDeclaredMethods()) {
            if (m.isAnnotationPresent(Test.class)) {
                try {
                    m.invoke(test);
                    System.out.printf("test %s: success%n", m.getName());
                } catch (Throwable t ) {
                    System.out.printf("test %s: failed%n", m.getName());
                    t.printStackTrace();
                }
            }
        }
    }
}