/*

 * Copyright (c) 2015, 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.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

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

 */

package jdk.internal.net.http;

import java.io.EOFException;

import java.io.IOException;

import java.io.UncheckedIOException;

import java.lang.System.Logger.Level;

import java.net.InetSocketAddress;

import java.net.URI;

import java.nio.ByteBuffer;

import java.nio.charset.StandardCharsets;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.CompletableFuture;

import java.util.ArrayList;

import java.util.Objects;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ConcurrentLinkedQueue;

import java.util.concurrent.Flow;

import java.util.function.Function;

import java.util.function.Supplier;

import javax.net.ssl.SSLEngine;

import javax.net.ssl.SSLException;

import java.net.http.HttpClient;

import java.net.http.HttpHeaders;

import jdk.internal.net.http.HttpConnection.HttpPublisher;

import jdk.internal.net.http.common.FlowTube;

import jdk.internal.net.http.common.FlowTube.TubeSubscriber;

import jdk.internal.net.http.common.HttpHeadersImpl;

import jdk.internal.net.http.common.Log;

import jdk.internal.net.http.common.Logger;

import jdk.internal.net.http.common.MinimalFuture;

import jdk.internal.net.http.common.SequentialScheduler;

import jdk.internal.net.http.common.Utils;

import jdk.internal.net.http.frame.ContinuationFrame;

import jdk.internal.net.http.frame.DataFrame;

import jdk.internal.net.http.frame.ErrorFrame;

import jdk.internal.net.http.frame.FramesDecoder;

import jdk.internal.net.http.frame.FramesEncoder;

import jdk.internal.net.http.frame.GoAwayFrame;

import jdk.internal.net.http.frame.HeaderFrame;

import jdk.internal.net.http.frame.HeadersFrame;

import jdk.internal.net.http.frame.Http2Frame;

import jdk.internal.net.http.frame.MalformedFrame;

import jdk.internal.net.http.frame.OutgoingHeaders;

import jdk.internal.net.http.frame.PingFrame;

import jdk.internal.net.http.frame.PushPromiseFrame;

import jdk.internal.net.http.frame.ResetFrame;

import jdk.internal.net.http.frame.SettingsFrame;

import jdk.internal.net.http.frame.WindowUpdateFrame;

import jdk.internal.net.http.hpack.Encoder;

import jdk.internal.net.http.hpack.Decoder;

import jdk.internal.net.http.hpack.DecodingCallback;

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

import static jdk.internal.net.http.frame.SettingsFrame.*;

/**

 * An Http2Connection. Encapsulates the socket(channel) and any SSLEngine used

 * over it. Contains an HttpConnection which hides the SocketChannel SSL stuff.

 *

 * Http2Connections belong to a Http2ClientImpl, (one of) which belongs

 * to a HttpClientImpl.

 *

 * Creation cases:

 * 1) upgraded HTTP/1.1 plain tcp connection

 * 2) prior knowledge directly created plain tcp connection

 * 3) directly created HTTP/2 SSL connection which uses ALPN.

 *

 * Sending is done by writing directly to underlying HttpConnection object which

 * is operating in async mode. No flow control applies on output at this level

 * and all writes are just executed as puts to an output Q belonging to HttpConnection

 * Flow control is implemented by HTTP/2 protocol itself.

 *

 * Hpack header compression

 * and outgoing stream creation is also done here, because these operations

 * must be synchronized at the socket level. Stream objects send frames simply

 * by placing them on the connection's output Queue. sendFrame() is called

 * from a higher level (Stream) thread.

 *

 * asyncReceive(ByteBuffer) is always called from the selector thread. It assembles

 * incoming Http2Frames, and directs them to the appropriate Stream.incoming()

 * or handles them directly itself. This thread performs hpack decompression

 * and incoming stream creation (Server push). Incoming frames destined for a

 * stream are provided by calling Stream.incoming().

 */

class Http2Connection  {

    final Logger debug = Utils.getDebugLogger(this::dbgString, Utils.DEBUG);

    final static Logger DEBUG_LOGGER =

            Utils.getDebugLogger("Http2Connection"::toString, Utils.DEBUG);

    private final Logger debugHpack =

            Utils.getHpackLogger(this::dbgString, Utils.DEBUG_HPACK);

    static final ByteBuffer EMPTY_TRIGGER = ByteBuffer.allocate(0);

    private boolean singleStream; // used only for stream 1, then closed

    /*

     *  ByteBuffer pooling strategy for HTTP/2 protocol:

     *

     * In general there are 4 points where ByteBuffers are used:

     *  - incoming/outgoing frames from/to ByteBuffers plus incoming/outgoing encrypted data

     *    in case of SSL connection.

     *

     * 1. Outgoing frames encoded to ByteBuffers.

     *    Outgoing ByteBuffers are created with requited size and frequently small (except DataFrames, etc)

     *    At this place no pools at all. All outgoing buffers should be collected by GC.

     *

     * 2. Incoming ByteBuffers (decoded to frames).

     *    Here, total elimination of BB pool is not a good idea.

     *    We don't know how many bytes we will receive through network.

     * So here we allocate buffer of reasonable size. The following life of the BB:

     * - If all frames decoded from the BB are other than DataFrame and HeaderFrame (and HeaderFrame subclasses)

     *     BB is returned to pool,

     * - If we decoded DataFrame from the BB. In that case DataFrame refers to subbuffer obtained by slice() method.

     *     Such BB is never returned to pool and will be GCed.

     * - If we decoded HeadersFrame from the BB. Then header decoding is performed inside processFrame method and

     *     the buffer could be release to pool.

     *

     * 3. SLL encrypted buffers. Here another pool was introduced and all net buffers are to/from the pool,

     *    because of we can't predict size encrypted packets.

     *

     */

    // A small class that allows to control frames with respect to the state of

    // the connection preface. Any data received before the connection

    // preface is sent will be buffered.

    private final class FramesController {

        volatile boolean prefaceSent;

        volatile List<ByteBuffer> pending;

        boolean processReceivedData(FramesDecoder decoder, ByteBuffer buf)

                throws IOException

        {

            // if preface is not sent, buffers data in the pending list

            if (!prefaceSent) {

                if (debug.on())

                    debug.log("Preface not sent: buffering %d", buf.remaining());

                synchronized (this) {

                    if (!prefaceSent) {

                        if (pending == null) pending = new ArrayList<>();

                        pending.add(buf);

                        if (debug.on())

                            debug.log("there are now %d bytes buffered waiting for preface to be sent"

                                    + Utils.remaining(pending)

                            );

                        return false;

                    }

                }

            }

            // Preface is sent. Checks for pending data and flush it.

            // We rely on this method being called from within the Http2TubeSubscriber

            // scheduler, so we know that no other thread could execute this method

            // concurrently while we're here.

            // This ensures that later incoming buffers will not

            // be processed before we have flushed the pending queue.

            // No additional synchronization is therefore necessary here.

            List<ByteBuffer> pending = this.pending;

            this.pending = null;

            if (pending != null) {

                // flush pending data

                if (debug.on()) debug.log(() -> "Processing buffered data: "

                      + Utils.remaining(pending));

                for (ByteBuffer b : pending) {

                    decoder.decode(b);

                }

            }

            // push the received buffer to the frames decoder.

            if (buf != EMPTY_TRIGGER) {

                if (debug.on()) debug.log("Processing %d", buf.remaining());

                decoder.decode(buf);

            }

            return true;

        }

        // Mark that the connection preface is sent

        void markPrefaceSent() {

            assert !prefaceSent;

            synchronized (this) {

                prefaceSent = true;

            }

        }

    }

    volatile boolean closed;

    //-------------------------------------

    final HttpConnection connection;

    private final Http2ClientImpl client2;

    private final Map<Integer,Stream<?>> streams = new ConcurrentHashMap<>();

    private int nextstreamid;

    private int nextPushStream = 2;

    private final Encoder hpackOut;

    private final Decoder hpackIn;

    final SettingsFrame clientSettings;

    private volatile SettingsFrame serverSettings;

    private final String key; // for HttpClientImpl.connections map

    private final FramesDecoder framesDecoder;

    private final FramesEncoder framesEncoder = new FramesEncoder();

    /**

     * Send Window controller for both connection and stream windows.

     * Each of this connection's Streams MUST use this controller.

     */

    private final WindowController windowController = new WindowController();

    private final FramesController framesController = new FramesController();

    private final Http2TubeSubscriber subscriber = new Http2TubeSubscriber();

    final ConnectionWindowUpdateSender windowUpdater;

    private volatile Throwable cause;

    private volatile Supplier<ByteBuffer> initial;

    static final int DEFAULT_FRAME_SIZE = 16 * 1024;

    // TODO: need list of control frames from other threads

    // that need to be sent

    private Http2Connection(HttpConnection connection,

                            Http2ClientImpl client2,

                            int nextstreamid,

                            String key) {

        this.connection = connection;

        this.client2 = client2;

        this.nextstreamid = nextstreamid;

        this.key = key;

        this.clientSettings = this.client2.getClientSettings();

        this.framesDecoder = new FramesDecoder(this::processFrame,

                clientSettings.getParameter(SettingsFrame.MAX_FRAME_SIZE));

        // serverSettings will be updated by server

        this.serverSettings = SettingsFrame.getDefaultSettings();

        this.hpackOut = new Encoder(serverSettings.getParameter(HEADER_TABLE_SIZE));

        this.hpackIn = new Decoder(clientSettings.getParameter(HEADER_TABLE_SIZE));

        if (debugHpack.on()) {

            debugHpack.log("For the record:" + super.toString());

            debugHpack.log("Decoder created: %s", hpackIn);

            debugHpack.log("Encoder created: %s", hpackOut);

        }

        this.windowUpdater = new ConnectionWindowUpdateSender(this,

                client2.getConnectionWindowSize(clientSettings));

    }

    /**

     * Case 1) Create from upgraded HTTP/1.1 connection.

     * Is ready to use. Can be SSL. exchange is the Exchange

     * that initiated the connection, whose response will be delivered

     * on a Stream.

     */

    private Http2Connection(HttpConnection connection,

                    Http2ClientImpl client2,

                    Exchange<?> exchange,

                    Supplier<ByteBuffer> initial)

        throws IOException, InterruptedException

    {

        this(connection,

                client2,

                3, // stream 1 is registered during the upgrade

                keyFor(connection));

        Log.logTrace("Connection send window size {0} ", windowController.connectionWindowSize());

        Stream<?> initialStream = createStream(exchange);

        initialStream.registerStream(1);

        windowController.registerStream(1, getInitialSendWindowSize());

        initialStream.requestSent();

        // Upgrading:

        //    set callbacks before sending preface - makes sure anything that

        //    might be sent by the server will come our way.

        this.initial = initial;

        connectFlows(connection);

        sendConnectionPreface();

    }

    // Used when upgrading an HTTP/1.1 connection to HTTP/2 after receiving

    // agreement from the server. Async style but completes immediately, because

    // the connection is already connected.

    static CompletableFuture<Http2Connection> createAsync(HttpConnection connection,

                                                          Http2ClientImpl client2,

                                                          Exchange<?> exchange,

                                                          Supplier<ByteBuffer> initial)

    {

        return MinimalFuture.supply(() -> new Http2Connection(connection, client2, exchange, initial));

    }

    // Requires TLS handshake. So, is really async

    static CompletableFuture<Http2Connection> createAsync(HttpRequestImpl request,

                                                          Http2ClientImpl h2client) {

        assert request.secure();

        AbstractAsyncSSLConnection connection = (AbstractAsyncSSLConnection)

        HttpConnection.getConnection(request.getAddress(),

                                     h2client.client(),

                                     request,

                                     HttpClient.Version.HTTP_2);

        return connection.connectAsync()

                  .thenCompose(unused -> checkSSLConfig(connection))

                  .thenCompose(notused-> {

                      CompletableFuture<Http2Connection> cf = new MinimalFuture<>();

                      try {

                          Http2Connection hc = new Http2Connection(request, h2client, connection);

                          cf.complete(hc);

                      } catch (IOException e) {

                          cf.completeExceptionally(e);

                      }

                      return cf; } );

    }

    /**

     * Cases 2) 3)

     *

     * request is request to be sent.

     */

    private Http2Connection(HttpRequestImpl request,

                            Http2ClientImpl h2client,

                            HttpConnection connection)

        throws IOException

    {

        this(connection,

             h2client,

             1,

             keyFor(request.uri(), request.proxy()));

        Log.logTrace("Connection send window size {0} ", windowController.connectionWindowSize());

        // safe to resume async reading now.

        connectFlows(connection);

        sendConnectionPreface();

    }

    private void connectFlows(HttpConnection connection) {

        FlowTube tube =  connection.getConnectionFlow();

        // Connect the flow to our Http2TubeSubscriber:

        tube.connectFlows(connection.publisher(), subscriber);

    }

    final HttpClientImpl client() {

        return client2.client();

    }

    /**

     * Throws an IOException if h2 was not negotiated

     */

    private static CompletableFuture<?> checkSSLConfig(AbstractAsyncSSLConnection aconn) {

        assert aconn.isSecure();

        Function<String, CompletableFuture<Void>> checkAlpnCF = (alpn) -> {

            CompletableFuture<Void> cf = new MinimalFuture<>();

            SSLEngine engine = aconn.getEngine();

            assert Objects.equals(alpn, engine.getApplicationProtocol());

            DEBUG_LOGGER.log("checkSSLConfig: alpn: %s", alpn );

            if (alpn == null || !alpn.equals("h2")) {

                String msg;

                if (alpn == null) {

                    Log.logSSL("ALPN not supported");

                    msg = "ALPN not supported";

                } else {

                    switch (alpn) {

                        case "":

                            Log.logSSL(msg = "No ALPN negotiated");

                            break;

                        case "http/1.1":

                            Log.logSSL( msg = "HTTP/1.1 ALPN returned");

                            break;

                        default:

                            Log.logSSL(msg = "Unexpected ALPN: " + alpn);

                            cf.completeExceptionally(new IOException(msg));

                    }

                }

                cf.completeExceptionally(new ALPNException(msg, aconn));

                return cf;

            }

            cf.complete(null);

            return cf;

        };

        return aconn.getALPN()

                .whenComplete((r,t) -> {

                    if (t != null && t instanceof SSLException) {

                        // something went wrong during the initial handshake

                        // close the connection

                        aconn.close();

                    }

                })

                .thenCompose(checkAlpnCF);

    }

    synchronized boolean singleStream() {

        return singleStream;

    }

    synchronized void setSingleStream(boolean use) {

        singleStream = use;

    }

    static String keyFor(HttpConnection connection) {

        boolean isProxy = connection.isProxied(); // tunnel or plain clear connection through proxy

        boolean isSecure = connection.isSecure();

        InetSocketAddress addr = connection.address();

        return keyString(isSecure, isProxy, addr.getHostString(), addr.getPort());

    }

    static String keyFor(URI uri, InetSocketAddress proxy) {

        boolean isSecure = uri.getScheme().equalsIgnoreCase("https");

        boolean isProxy = proxy != null;

        String host;

        int port;

        if (proxy != null && !isSecure) {

            // clear connection through proxy: use

            // proxy host / proxy port

            host = proxy.getHostString();

            port = proxy.getPort();

        } else {

            // either secure tunnel connection through proxy

            // or direct connection to host, but in either

            // case only that host can be reached through

            // the connection: use target host / target port

            host = uri.getHost();

            port = uri.getPort();

        }

        return keyString(isSecure, isProxy, host, port);

    }

    // {C,S}:{H:P}:host:port

    // C indicates clear text connection "http"

    // S indicates secure "https"

    // H indicates host (direct) connection

    // P indicates proxy

    // Eg: "S:H:foo.com:80"

    static String keyString(boolean secure, boolean proxy, String host, int port) {

        if (secure && port == -1)

            port = 443;

        else if (!secure && port == -1)

            port = 80;

        return (secure ? "S:" : "C:") + (proxy ? "P:" : "H:") + host + ":" + port;

    }

    String key() {

        return this.key;

    }

    boolean offerConnection() {

        return client2.offerConnection(this);

    }

    private HttpPublisher publisher() {

        return connection.publisher();

    }

    private void decodeHeaders(HeaderFrame frame, DecodingCallback decoder)

            throws IOException

    {

        if (debugHpack.on()) debugHpack.log("decodeHeaders(%s)", decoder);

        boolean endOfHeaders = frame.getFlag(HeaderFrame.END_HEADERS);

        List<ByteBuffer> buffers = frame.getHeaderBlock();

        int len = buffers.size();

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

            ByteBuffer b = buffers.get(i);

            hpackIn.decode(b, endOfHeaders && (i == len - 1), decoder);

        }

    }

    final int getInitialSendWindowSize() {

        return serverSettings.getParameter(INITIAL_WINDOW_SIZE);

    }

    void close() {

        Log.logTrace("Closing HTTP/2 connection: to {0}", connection.address());