/*

 * Copyright (c) 2016, 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.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.net.URI;

import jdk.incubator.http.HttpClient;

import jdk.incubator.http.HttpHeaders;

import jdk.incubator.http.HttpRequest;

import jdk.incubator.http.HttpResponse;

import java.nio.ByteBuffer;

import java.nio.charset.Charset;

import java.util.Locale;

import java.util.Optional;

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.CompletionStage;

import java.util.concurrent.Flow;

import java.util.stream.Stream;

/*

 * @test

 * @summary An example on how to read a response body with InputStream...

 * @run main/othervm HttpInputStreamTest

 * @author daniel fuchs

 */

public class HttpInputStreamTest {

    public static boolean DEBUG = Boolean.getBoolean("test.debug");

    /**

     * A simple HttpResponse.BodyHandler that creates a live

     * InputStream to read the response body from the underlying ByteBuffer

     * Flow.

     * The InputStream is made immediately available for consumption, before

     * the response body is fully received.

     */

    public static class HttpInputStreamHandler

        implements HttpResponse.BodyHandler<InputStream>    {

        public static final int MAX_BUFFERS_IN_QUEUE = 1;

        private final int maxBuffers;

        public HttpInputStreamHandler() {

            this(MAX_BUFFERS_IN_QUEUE);

        }

        public HttpInputStreamHandler(int maxBuffers) {

            this.maxBuffers = maxBuffers <= 0 ? MAX_BUFFERS_IN_QUEUE : maxBuffers;

        }

        @Override

        public synchronized HttpResponse.BodyProcessor<InputStream>

                apply(int i, HttpHeaders hh) {

            return new HttpResponseInputStream(maxBuffers);

        }

        /**

         * An InputStream built on top of the Flow API.

         */

        private static class HttpResponseInputStream extends InputStream

                    implements HttpResponse.BodyProcessor<InputStream> {

            // An immutable ByteBuffer sentinel to mark that the last byte was received.

            private static final ByteBuffer LAST = ByteBuffer.wrap(new byte[0]);

            // A queue of yet unprocessed ByteBuffers received from the flow API.

            private final BlockingQueue<ByteBuffer> buffers;

            private volatile Flow.Subscription subscription;

            private volatile boolean closed;

            private volatile Throwable failed;

            private volatile ByteBuffer current;

            HttpResponseInputStream() {

                this(MAX_BUFFERS_IN_QUEUE);

            }

            HttpResponseInputStream(int maxBuffers) {

                int capacity = maxBuffers <= 0 ? MAX_BUFFERS_IN_QUEUE : maxBuffers;

                this.buffers = new ArrayBlockingQueue<>(capacity);

            }

            @Override

            public CompletionStage<InputStream> getBody() {

                // Return the stream immediately, before the

                // response body is received.

                // This makes it possible for senAsync().get().body()

                // to complete before the response body is received.

                return CompletableFuture.completedStage(this);

            }

            // Returns the current byte buffer to read from.

            // If the current buffer has no remaining data, will take the

            // next buffer from the buffers queue, possibly blocking until

            // a new buffer is made available through the Flow API, or the

            // end of the flow is reached.

            private ByteBuffer current() throws IOException {

                while (current == null || !current.hasRemaining()) {

                    // Check whether the stream is claused or exhausted

                    if (closed || failed != null) {

                        throw new IOException("closed", failed);

                    }

                    if (current == LAST) break;

                    try {

                        // Take a new buffer from the queue, blocking

                        // if none is available yet...

                        if (DEBUG) System.err.println("Taking Buffer");

                        current = buffers.take();

                        if (DEBUG) System.err.println("Buffer Taken");

                        // Check whether some exception was encountered

                        // upstream

                        if (closed || failed != null) {

                            throw new IOException("closed", failed);

                        }

                        // Check whether we're done.

                        if (current == LAST) break;

                        // Inform the producer that it can start sending

                        // us a new buffer

                        Flow.Subscription s = subscription;

                        if (s != null) s.request(1);

                    } catch (InterruptedException ex) {

                        // continue

                    }

                }

                assert current == LAST || current.hasRemaining();

                return current;

            }

            @Override

            public int read(byte[] bytes, int off, int len) throws IOException {

                // get the buffer to read from, possibly blocking if

                // none is available

                ByteBuffer buffer;

                if ((buffer = current()) == LAST) return -1;

                // don't attempt to read more than what is available

                // in the current buffer.

                int read = Math.min(buffer.remaining(), len);

                assert read > 0 && read <= buffer.remaining();

                // buffer.get() will do the boundary check for us.

                buffer.get(bytes, off, read);

                return read;

            }

            @Override

            public int read() throws IOException {

                ByteBuffer buffer;

                if ((buffer = current()) == LAST) return -1;

                return buffer.get() & 0xFF;

            }

            @Override

            public void onSubscribe(Flow.Subscription s) {

                this.subscription = s;

                s.request(Math.max(2, buffers.remainingCapacity() + 1));

            }

            @Override

            public synchronized void onNext(ByteBuffer t) {

                try {

                    if (DEBUG) System.err.println("next buffer received");

                    buffers.put(t);

                    if (DEBUG) System.err.println("buffered offered");

                } catch (Exception ex) {

                    failed = ex;

                    try {

                        close();

                    } catch (IOException ex1) {

                        // OK

                    }

                }

            }

            @Override

            public void onError(Throwable thrwbl) {

                failed = thrwbl;

            }

            @Override

            public synchronized void onComplete() {

                subscription = null;

                onNext(LAST);

            }

            @Override

            public void close() throws IOException {

                synchronized (this) {

                    closed = true;

                    Flow.Subscription s = subscription;

                    if (s != null) {

                        s.cancel();

                    }

                    subscription = null;

                }

                super.close();

            }

        }

    }

    /**

     * Examine the response headers to figure out the charset used to

     * encode the body content.

     * If the content type is not textual, returns an empty Optional.

     * Otherwise, returns the body content's charset, defaulting to

     * ISO-8859-1 if none is explicitly specified.

     * @param headers The response headers.

     * @return The charset to use for decoding the response body, if

     *         the response body content is text/...

     */

    public static Optional<Charset> getCharset(HttpHeaders headers) {

        Optional<String> contentType = headers.firstValue("Content-Type");

        Optional<Charset> charset = Optional.empty();

        if (contentType.isPresent()) {

            final String[] values = contentType.get().split(";");

            if (values[0].startsWith("text/")) {

                charset = Optional.of(Stream.of(values)

                    .map(x -> x.toLowerCase(Locale.ROOT))

                    .map(String::trim)

                    .filter(x -> x.startsWith("charset="))

                    .map(x -> x.substring("charset=".length()))

                    .findFirst()

                    .orElse("ISO-8859-1"))

                    .map(Charset::forName);

            }

        }

        return charset;

    }

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

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest

            .newBuilder(new URI("http://hg.openjdk.java.net/jdk9/sandbox/jdk/shortlog/http-client-branch/"))

            .GET()

            .build();

        // This example shows how to return an InputStream that can be used to

        // start reading the response body before the response is fully received.

        // In comparison, the snipet below (which uses

        // HttpResponse.BodyHandler.asString()) obviously will not return before the

        // response body is fully read:

        //

        // System.out.println(

        //    client.sendAsync(request, HttpResponse.BodyHandler.asString()).get().body());

        CompletableFuture<HttpResponse<InputStream>> handle =

            client.sendAsync(request, new HttpInputStreamHandler());

        if (DEBUG) System.err.println("Request sent");

        HttpResponse<InputStream> pending = handle.get();

        // At this point, the response headers have been received, but the

        // response body may not have arrived yet. This comes from

        // the implementation of HttpResponseInputStream::getBody above,

        // which returns an already completed completion stage, without

        // waiting for any data.

        // We can therefore access the headers - and the body, which

        // is our live InputStream, without waiting...

        HttpHeaders responseHeaders = pending.headers();

        // Get the charset declared in the response headers.

        // The optional will be empty if the content type is not

        // of type text/...

        Optional<Charset> charset = getCharset(responseHeaders);

        try (InputStream is = pending.body();

            // We assume a textual content type. Construct an InputStream

            // Reader with the appropriate Charset.

            // charset.get() will throw NPE if the content is not textual.

            Reader r = new InputStreamReader(is, charset.get())) {

            char[] buff = new char[32];

            int off=0, n=0;

            if (DEBUG) System.err.println("Start receiving response body");

            if (DEBUG) System.err.println("Charset: " + charset.get());

            // Start consuming the InputStream as the data arrives.

            // Will block until there is something to read...

            while ((n = r.read(buff, off, buff.length - off)) > 0) {

                assert (buff.length - off) > 0;

                assert n <= (buff.length - off);

                if (n == (buff.length - off)) {

                    System.out.print(buff);

                    off = 0;

                } else {

                    off += n;

                }

                assert off < buff.length;

            }

            // last call to read may not have filled 'buff' completely.

            // flush out the remaining characters.

            assert off >= 0 && off < buff.length;

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

                System.out.print(buff[i]);

            }

            // We're done!

            System.out.println("Done!");

        }

    }

}