/*

 * 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.ServerSocket;

import java.net.Socket;

import java.net.URI;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.ByteBuffer;

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.Flow;

import java.util.concurrent.TimeoutException;

import java.util.concurrent.TimeUnit;

import static java.nio.charset.StandardCharsets.US_ASCII;

import static jdk.incubator.http.HttpResponse.BodyHandler.discard;

import static java.nio.charset.StandardCharsets.UTF_8;

/**

 * @test

 * @bug 8151441

 * @summary Request body of incorrect (larger or smaller) sizes than that

 * @run main/othervm ShortRequestBody

 */

public class ShortRequestBody {

    static final Path testSrc = Paths.get(System.getProperty("test.src", "."));

    // Some body types ( sources ) for testing.

    static final String STRING_BODY = "Hello world";

    static final byte[] BYTE_ARRAY_BODY = new byte[] {

        (byte)0xCA, (byte)0xFE, (byte)0xBA, (byte)0xBE };

    static final Path FILE_BODY = testSrc.resolve("docs").resolve("files").resolve("foo.txt");

    // Body lengths and offsets ( amount to be wrong by ), to make coordination

    // between client and server easier.

    static final int[] BODY_LENGTHS = new int[] { STRING_BODY.length(),

                                                  BYTE_ARRAY_BODY.length,

                                                  fileSize(FILE_BODY) };

    static final int[] BODY_OFFSETS = new int[] { 0, +1, -1, +2, -2, +3, -3 };

    static abstract class AbstractDelegateRequestBody

        final long contentLength;

                                    long contentLength) {

            this.delegate = delegate;

            this.contentLength = contentLength;

        }

        @Override

        public void subscribe(Flow.Subscriber<? super ByteBuffer> subscriber) {

            delegate.subscribe(subscriber);

        }

        @Override

        public long contentLength() { return contentLength; /* may be wrong! */ }

    }

    // bytes to that of what is reported through their {@code contentLength}.

    static class StringRequestBody extends AbstractDelegateRequestBody {

        StringRequestBody(String body, int additionalLength) {

                  body.getBytes(UTF_8).length + additionalLength);

        }

    }

    static class ByteArrayRequestBody extends AbstractDelegateRequestBody {

        ByteArrayRequestBody(byte[] body, int additionalLength) {

                  body.length + additionalLength);

        }

    }

    static class FileRequestBody extends AbstractDelegateRequestBody {

        FileRequestBody(Path path, int additionalLength) throws IOException {

                  Files.size(path) + additionalLength);

        }

    }

    // ---

    public static void main(String[] args) throws Exception {

            }

        }

    }

        throws Exception

    {

        CompletableFuture<HttpResponse<Void>> cf;

        HttpRequest request = HttpRequest.newBuilder(uri)

                                         .build();

        HttpResponse<Void> resp = cf.get(30, TimeUnit.SECONDS);

        check(resp.statusCode() == 200, "Expected 200, got ", resp.statusCode());

    }

        throws Exception

    {

        CompletableFuture<HttpResponse<Void>> cf;

        HttpRequest request = HttpRequest.newBuilder(uri)

                                         .build();

        try {

            HttpResponse<Void> r = cf.get(30, TimeUnit.SECONDS);

            throw new RuntimeException("Unexpected response: " + r.statusCode());

        } catch (TimeoutException x) {

            throw new RuntimeException("Unexpected timeout", x);

        } catch (ExecutionException expected) {

                  "Expected cause IOException, but got: ", expected.getCause());

        }

    }

        throws Exception

    {

        HttpRequest request = HttpRequest.newBuilder(uri)

                                         .build();

        try {

            throw new RuntimeException("Unexpected response: " + r.statusCode());

        } catch (IOException expected) {

        }

    }

    static class Server extends Thread implements AutoCloseable {

        static String RESPONSE = "HTTP/1.1 200 OK\r\n" +

                                 "Connection: close\r\n"+

                                 "Content-length: 0\r\n\r\n";

        private final ServerSocket ss;

        private volatile boolean closed;

        Server() throws IOException {

            super("Test-Server");

            ss = new ServerSocket(0); this.start();

        }

        int getPort() { return ss.getLocalPort(); }

        @Override

        public void run() {

            int count = 0;

            int offset = 0;

            while (!closed) {

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

                    InputStream is = s.getInputStream();

                    readRequestHeaders(is);

                    byte[] ba = new byte[1024];

                    int length = BODY_LENGTHS[count % 3];

                    length += BODY_OFFSETS[offset];

                    count++;

                    if (count % 6 == 0) // 6 is the number of failure requests per offset

                        offset++;

                } catch (IOException e) {

                    if (!closed)

                        System.out.println("Unexpected" + e);

                }

            }

        }

        @Override

        public void close() {

            if (closed)

                return;

            closed = true;

            try {

                ss.close();

            } catch (IOException e) {

                throw new UncheckedIOException("Unexpected", e);

            }

        }

    }

    static final byte[] requestEnd = new byte[] {'\r', '\n', '\r', '\n' };

    // Read until the end of a HTTP request headers

    static void readRequestHeaders(InputStream is) throws IOException {

        int requestEndCount = 0, r;

        while ((r = is.read()) != -1) {

            if (r == requestEnd[requestEndCount]) {

                requestEndCount++;

                if (requestEndCount == 4) {

                    break;

                }

            } else {

                requestEndCount = 0;

            }

        }

    }

    static int fileSize(Path p) {

        try { return (int) Files.size(p); }

        catch (IOException x) { throw new UncheckedIOException(x); }

    }

    static boolean check(boolean cond, Object... failedArgs) {

        if (cond)

            return true;

        // We are going to fail...

        StringBuilder sb = new StringBuilder();

        for (Object o : failedArgs)

                sb.append(o);

        throw new RuntimeException(sb.toString());

    }

}