/*
* Copyright (c) 2021, 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.net.URI;
import java.net.URISyntaxException;
import java.net.http.HttpClient.Version;
import java.net.http.HttpHeaders;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse.BodySubscriber;
import java.net.http.HttpResponse.BodySubscribers;
import java.nio.ByteBuffer;
import java.time.Duration;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.Flow;
import java.util.function.BiConsumer;
import java.util.function.BiPredicate;
import static java.net.http.HttpClient.Version.HTTP_2;
import static java.net.http.HttpClient.Version.HTTP_1_1;
import static java.nio.charset.StandardCharsets.UTF_8;

import org.testng.annotations.Test;
import org.testng.annotations.DataProvider;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertThrows;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;

/**
* @test
* @bug 8252304 8276559
* @summary HttpRequest.newBuilder(HttpRequest) API and behaviour checks
* @run testng/othervm HttpRequestNewBuilderTest
*/
public class HttpRequestNewBuilderTest {
    static final Class<NullPointerException> NPE = NullPointerException.class;
    static final Class<IllegalArgumentException> IAE = IllegalArgumentException.class;

    record NamedAssertion(String name, BiConsumer<HttpRequest, HttpRequest> test) { }

    List<NamedAssertion> REQUEST_ASSERTIONS = List.of(
            new NamedAssertion("uri", (r1, r2) -> assertEquals(r1.uri(), r2.uri())),
            new NamedAssertion("timeout", (r1, r2) -> assertEquals(r1.timeout(), r2.timeout())),
            new NamedAssertion("version", (r1, r2) -> assertEquals(r1.version(), r2.version())),
            new NamedAssertion("headers", (r1, r2) -> assertEquals(r1.headers(), r2.headers())),
            new NamedAssertion("expectContinue", (r1, r2) -> assertEquals(r1.expectContinue(), r2.expectContinue())),
            new NamedAssertion("method", (r1, r2) -> {
                assertEquals(r1.method(), r2.method());
                assertBodyPublisherEqual(r1, r2);
            })
    );

    @DataProvider(name = "testRequests")
    public Object[][] variants() {
        return new Object[][]{
                { HttpRequest.newBuilder(URI.create("https://uri-1/")).build() },
                { HttpRequest.newBuilder(URI.create("https://version-1/")).version(HTTP_1_1).build() },
                { HttpRequest.newBuilder(URI.create("https://version-2/")).version(HTTP_2).build() },
                { HttpRequest.newBuilder(URI.create("https://timeout-1/")).timeout(Duration.ofSeconds(30)).build() },
                { HttpRequest.newBuilder(URI.create("https://header-1/")).header("testName1", "testValue1").build() },
                { HttpRequest.newBuilder(URI.create("https://header-2/"))
                        .headers("testName1", "testValue1", "a", "1", "b", "2", "c", "3", "d", "4").build() },
                { HttpRequest.newBuilder(URI.create("https://header-3/"))
                        .headers("testName1", "testValue1", "a", "1", "b", "2", "c", "3", "d", "4", "testName2", "testValue2").build() },
                { HttpRequest.newBuilder(URI.create("https://header-4/"))
                        .headers("a", "1", "b", "2", "c", "3", "d", "4", "testName1", "testValue1").build() },
                { HttpRequest.newBuilder(URI.create("https://header-5/"))
                        .headers( "a", "1", "b", "2", "testName1", "testValue1", "testName2", "testValue2", "c", "3", "d", "4").build() },
                { HttpRequest.newBuilder(URI.create("https://header-6/"))
                        .headers("testName1", "testValue1")
                        .headers("testName1", "v")
                        .headers("testName1", "w")
                        .headers("testName1", "x")
                        .headers("testName1", "y")
                        .headers("testName1", "z").build() },
                { HttpRequest.newBuilder(URI.create("https://header-7/"))
                        .headers("testName1", "testValue1")
                        .headers("testName1", "v")
                        .headers("testName1", "w")
                        .headers("testName1", "x")
                        .headers("testName1", "y")
                        .headers("testName1", "z")
                        .headers("testName1", "testValue2").build() },
                { HttpRequest.newBuilder(URI.create("https://header-8/"))
                        .headers("testName1", "v")
                        .headers("testName1", "w")
                        .headers("testName1", "x")
                        .headers("testName1", "y")
                        .headers("testName1", "z")
                        .headers("testName1", "testValue1").build() },
                { HttpRequest.newBuilder(URI.create("https://header-9/"))
                        .headers("testName1", "v")
                        .headers("testName1", "w")
                        .headers("testName1", "testValue1")
                        .headers("testName1", "testValue2")
                        .headers("testName1", "x")
                        .headers("testName1", "y")
                        .headers("testName1", "z").build() },
                // dedicated method
                { HttpRequest.newBuilder(URI.create("https://method-0/")).HEAD().build() },
                { HttpRequest.newBuilder(URI.create("https://method-1/")).GET().build() },
                { HttpRequest.newBuilder(URI.create("https://method-2/")).DELETE().build() },
                { HttpRequest.newBuilder(URI.create("https://method-3/")).POST(HttpRequest.BodyPublishers.ofString("testData")).build() },
                { HttpRequest.newBuilder(URI.create("https://method-4/")).PUT(HttpRequest.BodyPublishers.ofString("testData")).build() },
                // method w/body
                { HttpRequest.newBuilder(URI.create("https://method-5/")).method("GET", HttpRequest.BodyPublishers.ofString("testData")).build() },
                { HttpRequest.newBuilder(URI.create("https://method-6/")).method("DELETE", HttpRequest.BodyPublishers.ofString("testData")).build() },
                { HttpRequest.newBuilder(URI.create("https://method-7/")).method("POST", HttpRequest.BodyPublishers.ofString("testData")).build() },
                { HttpRequest.newBuilder(URI.create("https://method-8/")).method("PUT", HttpRequest.BodyPublishers.ofString("testData")).build() },
                // method w/o body
                { HttpRequest.newBuilder(URI.create("https://method-9/")).method("GET", HttpRequest.BodyPublishers.noBody()).build() },
                { HttpRequest.newBuilder(URI.create("https://method-10/")).method("DELETE", HttpRequest.BodyPublishers.noBody()).build() },
                { HttpRequest.newBuilder(URI.create("https://method-11/")).method("POST", HttpRequest.BodyPublishers.noBody()).build() },
                { HttpRequest.newBuilder(URI.create("https://method-12/")).method("PUT", HttpRequest.BodyPublishers.noBody()).build() },
                // user defined methods w/ & w/o body
                { HttpRequest.newBuilder(URI.create("https://method-13/")).method("TEST", HttpRequest.BodyPublishers.noBody()).build() },
                { HttpRequest.newBuilder(URI.create("https://method-14/")).method("TEST", HttpRequest.BodyPublishers.ofString("testData")).build() },

                { HttpRequest.newBuilder(URI.create("https://all-fields-1/")).GET().expectContinue(true).version(HTTP_2)
                        .timeout(Duration.ofSeconds(1)).header("testName1", "testValue1").build() },
        };
    }

    // test methods
    void assertBodyPublisherEqual(HttpRequest r1, HttpRequest r2) {
        if (r1.bodyPublisher().isPresent()) {
            assertTrue(r2.bodyPublisher().isPresent());
            var bp1 = r1.bodyPublisher().get();
            var bp2 = r2.bodyPublisher().get();

            assertEquals(bp1.getClass(), bp2.getClass());
            assertEquals(bp1.contentLength(), bp2.contentLength());

            final class TestSubscriber implements Flow.Subscriber<ByteBuffer> {
                final BodySubscriber<String> s;
                TestSubscriber(BodySubscriber<String> s) { this.s = s; }
                @Override
                public void onSubscribe(Flow.Subscription subscription) { s.onSubscribe(subscription); }
                @Override
                public void onNext(ByteBuffer item) { s.onNext(List.of(item)); }
                @Override
                public void onError(Throwable throwable) { fail("TestSubscriber failed"); }
                @Override
                public void onComplete() { s.onComplete(); }
            }
            var bs1 = BodySubscribers.ofString(UTF_8);
            bp1.subscribe(new TestSubscriber(bs1));
            var b1 = bs1.getBody().toCompletableFuture().join().getBytes();

            var bs2 = BodySubscribers.ofString(UTF_8);
            bp2.subscribe(new TestSubscriber(bs2));
            var b2 = bs2.getBody().toCompletableFuture().join().getBytes();

            assertEquals(b1, b2);
        } else {
            assertFalse(r2.bodyPublisher().isPresent());
        }
    }

    void assertAllOtherElementsEqual(HttpRequest r1, HttpRequest r2, String... except) {
        var ignoreList = Arrays.asList(except);
        REQUEST_ASSERTIONS.stream()
                .filter(a -> !ignoreList.contains(a.name()))
                .forEach(testCaseAssertion -> testCaseAssertion.test().accept(r1, r2));
    }

    void testBodyPublisher(String methodName, HttpRequest request) {
        // method w/body
        var r = HttpRequest.newBuilder(request, (n, v) -> true)
                .method(methodName, HttpRequest.BodyPublishers.ofString("testData"))
                .build();
        assertEquals(r.method(), methodName);
        assertTrue(r.bodyPublisher().isPresent());
        assertEquals(r.bodyPublisher().get().contentLength(), 8);
        assertAllOtherElementsEqual(r, request, "method");

        // method w/o body
        var noBodyPublisher = HttpRequest.BodyPublishers.noBody();
        var r1 = HttpRequest.newBuilder(request, (n, v) -> true)
                .method(methodName, noBodyPublisher)
                .build();
        assertEquals(r1.method(), methodName);
        assertTrue(r1.bodyPublisher().isPresent());
        assertEquals(r1.bodyPublisher().get(), noBodyPublisher);
        assertAllOtherElementsEqual(r1, request, "method");
    }

    @Test
    public void testNull() {
        var r = HttpRequest.newBuilder(URI.create("https://foobar/")).build();
        assertThrows(NPE, () -> HttpRequest.newBuilder(r, null));
        assertThrows(NPE, () -> HttpRequest.newBuilder(null, (n, v) -> true));
        assertThrows(NPE, () -> HttpRequest.newBuilder(null, null));
    }

    @Test(dataProvider = "testRequests")
    void testBuilder(HttpRequest request) {
        var r = HttpRequest.newBuilder(request, (n, v) -> true).build();
        assertEquals(r, request);
        assertAllOtherElementsEqual(r, request);
    }

    @Test(dataProvider = "testRequests")
    public void testURI(HttpRequest request) {
        URI newURI = URI.create("http://www.newURI.com/");
        var r = HttpRequest.newBuilder(request, (n, v) -> true).uri(newURI).build();

        assertEquals(r.uri(), newURI);
        assertAllOtherElementsEqual(r, request, "uri");
    }

    @Test(dataProvider = "testRequests")
    public void testTimeout(HttpRequest request) {
        var r = HttpRequest.newBuilder(request, (n, v) -> true).timeout(Duration.ofSeconds(2)).build();

        assertEquals(r.timeout().get().getSeconds(), 2);
        assertAllOtherElementsEqual(r, request, "timeout");
    }

    @Test(dataProvider = "testRequests")
    public void testVersion(HttpRequest request) {
        var r = HttpRequest.newBuilder(request, (n, v) -> true).version(HTTP_1_1).build();

        assertEquals(r.version().get(), HTTP_1_1);
        assertAllOtherElementsEqual(r, request, "version");
    }

    @Test(dataProvider = "testRequests")
    public void testGET(HttpRequest request) {
        var r = HttpRequest.newBuilder(request, (n, v) -> true)
                .GET()
                .build();
        assertEquals(r.method(), "GET");
        assertTrue(r.bodyPublisher().isEmpty());
        assertAllOtherElementsEqual(r, request, "method");

        testBodyPublisher("GET", request);
    }

    @Test(dataProvider = "testRequests")
    public void testDELETE(HttpRequest request) {
        var r = HttpRequest.newBuilder(request, (n, v) -> true)
                .DELETE()
                .build();
        assertEquals(r.method(), "DELETE");
        assertTrue(r.bodyPublisher().isEmpty());
        assertAllOtherElementsEqual(r, request, "method");

        testBodyPublisher("DELETE", request);
    }

    @Test(dataProvider = "testRequests")
    public void testPOST(HttpRequest request) {
        var r = HttpRequest.newBuilder(request, (n, v) -> true)
                .POST(HttpRequest.BodyPublishers.ofString("testData"))
                .build();
        assertEquals(r.method(), "POST");
        assertTrue(r.bodyPublisher().isPresent());
        assertEquals(r.bodyPublisher().get().contentLength(), 8);
        assertAllOtherElementsEqual(r, request, "method");

        testBodyPublisher("POST", request);
    }

    @Test(dataProvider = "testRequests")
    public void testPUT(HttpRequest request) {
        var r = HttpRequest.newBuilder(request, (n, v) -> true)
                .PUT(HttpRequest.BodyPublishers.ofString("testData"))
                .build();
        assertEquals(r.method(), "PUT");
        assertTrue(r.bodyPublisher().isPresent());
        assertEquals(r.bodyPublisher().get().contentLength(), 8);
        assertAllOtherElementsEqual(r, request, "method");

        testBodyPublisher("PUT", request);
    }

    @Test(dataProvider = "testRequests")
    public void testUserDefinedMethod(HttpRequest request) {
        testBodyPublisher("TEST", request);
    }

    @Test(dataProvider = "testRequests")
    public void testAddHeader(HttpRequest request) {
        BiPredicate<String, String> filter = (n, v) -> true;

        var r = HttpRequest.newBuilder(request, filter).headers("newName", "newValue").build();
        assertEquals(r.headers().firstValue("newName").get(), "newValue");
        assertEquals(r.headers().allValues("newName").size(), 1);
        assertAllOtherElementsEqual(r, request, "headers");
    }

    @Test(dataProvider = "testRequests")
    public void testRemoveHeader(HttpRequest request) {
        if(!request.headers().map().isEmpty()) {
            assertTrue(request.headers().map().containsKey("testName1"));
        }
        BiPredicate<String, String> filter = (n, v) -> !n.equalsIgnoreCase("testName1");

        var r = HttpRequest.newBuilder(request, filter).build();
        assertFalse(r.headers().map().containsKey("testName1"));
        assertEquals(r.headers().map(), HttpHeaders.of(request.headers().map(), filter).map());
    }

    @Test(dataProvider = "testRequests")
    public void testRemoveSingleHeaderValue(HttpRequest request) {
        if(!request.headers().map().isEmpty()) {
            assertTrue(request.headers().allValues("testName1").contains("testValue1"));
        }
        BiPredicate<String, String> filter = (n, v) ->
                !(n.equalsIgnoreCase("testName1") && v.equals("testValue1"));

        var r = HttpRequest.newBuilder(request, filter).build();
        assertFalse(r.headers().map().containsValue("testValue1"));
        assertEquals(r.headers().map(), HttpHeaders.of(request.headers().map(), filter).map());
    }

    @Test(dataProvider = "testRequests")
    public void testRemoveMultipleHeaders(HttpRequest request) {
        BiPredicate<String, String> isTestName1Value1 = (n ,v) ->
                n.equalsIgnoreCase("testName1") && v.equals("testValue1");
        BiPredicate<String, String> isTestName2Value2 = (n ,v) ->
                n.equalsIgnoreCase("testName2") && v.equals("testValue2");
        var filter = (isTestName1Value1.or(isTestName2Value2)).negate();

        var r = HttpRequest.newBuilder(request, filter).build();
        assertEquals(r.headers().map(), HttpHeaders.of(request.headers().map(), filter).map());

        BiPredicate<String, String> filter1 = (n, v) ->
                !(n.equalsIgnoreCase("testName1") && (v.equals("testValue1") || v.equals("testValue2")));

        var r1 = HttpRequest.newBuilder(request, filter1).build();
        assertEquals(r1.headers().map(), HttpHeaders.of(request.headers().map(), filter1).map());
    }

    @Test(dataProvider = "testRequests")
    public void testRemoveAllHeaders(HttpRequest request) {
        if (!request.headers().map().isEmpty()) {
            BiPredicate<String, String> filter = (n, v) -> false;

            var r = HttpRequest.newBuilder(request, filter).build();
            assertTrue(r.headers().map().isEmpty());
            assertEquals(r.headers().map(), HttpHeaders.of(request.headers().map(), filter).map());
        }
    }

    @Test(dataProvider = "testRequests")
    public void testRetainAllHeaders(HttpRequest request) {
        if (!request.headers().map().isEmpty()) {
            BiPredicate<String, String> filter = (n, v) -> true;

            var r = HttpRequest.newBuilder(request, filter).build();
            assertFalse(r.headers().map().isEmpty());
            assertEquals(r.headers().map(), HttpHeaders.of(request.headers().map(), filter).map());
        }
    }

    @Test
    public void testHeaderExample() {
        var request = HttpRequest.newBuilder(URI.create("https://example/"))
                .header("Foo-Bar", "baz").build();

        BiPredicate<String, String> filter = (n, v) -> !n.equalsIgnoreCase("Foo-Bar");
        var r = HttpRequest.newBuilder(request, filter).build();
        assertFalse(r.headers().map().containsKey("Foo-Bar"));
        assertEquals(r.headers().map(), HttpHeaders.of(request.headers().map(), filter).map());
    }

    @Test
    public void testInvalidMethod() throws URISyntaxException {
        URI testURI = new URI("http://www.foo.com/");
        var r = new 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 testURI; }
            @Override
            public Optional<Version> version() { return Optional.empty(); }
            @Override
            public HttpHeaders headers() { return HttpHeaders.of(Map.of(), (n, v) -> true); }
        };
        assertThrows(IAE, () -> HttpRequest.newBuilder(r, (n, v) -> true).build());
    }

    @Test
    public void testInvalidURIScheme() throws URISyntaxException {
        URI badURI = new URI("ftp://foo.com/somefile");
        var r = new HttpRequest() {
            @Override
            public Optional<BodyPublisher> bodyPublisher() { return Optional.empty(); }
            @Override
            public String method() { return "GET"; }
            @Override
            public Optional<Duration> timeout() { return Optional.empty(); }
            @Override
            public boolean expectContinue() { return false; }
            @Override
            public URI uri() { return badURI; }
            @Override
            public Optional<Version> version() { return Optional.empty(); }
            @Override
            public HttpHeaders headers() { return HttpHeaders.of(Map.of(), (n, v) -> true); }
        };
        assertThrows(IAE, () -> HttpRequest.newBuilder(r, (n, v) -> true).build());
    }
}