/*

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

 *

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

import java.io.BufferedOutputStream;

import java.io.Closeable;

import java.io.IOException;

import java.io.UncheckedIOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.Socket;

import java.net.URI;

import java.net.InetAddress;

import javax.net.ssl.*;

import java.net.URISyntaxException;

import java.net.http.HttpHeaders;

import java.nio.ByteBuffer;

import java.util.*;

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.ConcurrentLinkedQueue;

import java.util.function.Consumer;

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

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

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

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

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

import sun.net.www.http.ChunkedInputStream;

import sun.net.www.http.HttpClient;

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

/**

 * Represents one HTTP2 connection, either plaintext upgraded from HTTP/1.1

 * or HTTPS opened using "h2" ALPN.

 */

public class Http2TestServerConnection {

    final Http2TestServer server;

    @SuppressWarnings({"rawtypes","unchecked"})

    final Map<Integer, Queue> streams; // input q per stream

    final Map<Integer, BodyOutputStream> outStreams; // output q per stream

    final HashSet<Integer> pushStreams;

    final Queue<Http2Frame> outputQ;

    volatile int nextstream;

    final Socket socket;

    final Http2TestExchangeSupplier exchangeSupplier;

    final InputStream is;

    final OutputStream os;

    volatile Encoder hpackOut;

    volatile Decoder hpackIn;

    volatile SettingsFrame clientSettings;

    final SettingsFrame serverSettings;

    final ExecutorService exec;

    final boolean secure;

    final Properties properties;

    volatile boolean stopping;

    volatile int nextPushStreamId = 2;

    ConcurrentLinkedQueue<PingRequest> pings = new ConcurrentLinkedQueue<>();

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

    final static byte[] EMPTY_BARRAY = new byte[0];

    final Random random;

    final static byte[] clientPreface = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n".getBytes();

    static class Sentinel extends Http2Frame {

        Sentinel() { super(-1,-1);}

    }

    static final Sentinel sentinel = new Sentinel();

    class PingRequest {

        final byte[] pingData;

        final long pingStamp;

        final CompletableFuture<Long> response;

        PingRequest() {

            pingData = new byte[8];

            random.nextBytes(pingData);

            pingStamp = System.currentTimeMillis();

            response = new CompletableFuture<>();

        }

        PingFrame frame() {

            return new PingFrame(0, pingData);

        }

        CompletableFuture<Long> response() {

            return response;

        }

        void success() {

            response.complete(System.currentTimeMillis() - pingStamp);

        }

        void fail(Throwable t) {

            response.completeExceptionally(t);

        }

    }

    Http2TestServerConnection(Http2TestServer server,

                              Socket socket,

                              Http2TestExchangeSupplier exchangeSupplier,

                              Properties properties)

        throws IOException

    {

        if (socket instanceof SSLSocket) {

            handshake(server.serverName(), (SSLSocket)socket);

        }

        System.err.println("TestServer: New connection from " + socket);

        this.server = server;

        this.exchangeSupplier = exchangeSupplier;

        this.streams = Collections.synchronizedMap(new HashMap<>());

        this.outStreams = Collections.synchronizedMap(new HashMap<>());

        this.outputQ = new Queue<>(sentinel);

        this.random = new Random();

        this.socket = socket;

        this.properties = properties;

        this.socket.setTcpNoDelay(true);

        this.serverSettings = getServerSettingProperties();

        this.exec = server.exec;

        this.secure = server.secure;

        this.pushStreams = new HashSet<>();

        is = new BufferedInputStream(socket.getInputStream());

        os = new BufferedOutputStream(socket.getOutputStream());

    }

    static final String propPrefix = "http2server.settings.";

    static final String[][] propIDs = {

        {"header_table_size", Integer.toString(SettingsFrame.HEADER_TABLE_SIZE)},

        {"enable_push", Integer.toString(SettingsFrame.ENABLE_PUSH)},

        {"max_concurrent_streams", Integer.toString(SettingsFrame.MAX_CONCURRENT_STREAMS)},

        {"initial_window_size", Integer.toString(SettingsFrame.INITIAL_WINDOW_SIZE)},

        {"max_frame_size", Integer.toString(SettingsFrame.MAX_FRAME_SIZE)},

        {"max_header_list_size", Integer.toString(SettingsFrame.MAX_HEADER_LIST_SIZE)}

    };

    private SettingsFrame getServerSettingProperties() {

        if (properties == null)

            return s;

        for (int i=0; i<propIDs.length; i++) {

            String key = propIDs[i][0];

            String numS = propIDs[i][1];

            String prop = properties.getProperty(propPrefix + key);

            if (prop != null) {

                try {

                    System.err.println("TestServer: setting " + key + " property to: " +

                        prop);

                    int num = Integer.parseInt(numS);

                    System.err.println("TestServer: num = " + num);

                    s.setParameter(num, Integer.parseInt(prop));

                } catch (NumberFormatException e) {/* ignore errors */}

            }

        }

        return s;

    }

    /**

     * Sends a PING frame on this connection, and completes the returned

     * CF when the PING ack is received. The CF is given

     * an integer, whose value is the number of milliseconds

     * between PING and ACK.

     */

    CompletableFuture<Long> sendPing() {

        PingRequest ping = null;

        try {

            ping = new PingRequest();

            pings.add(ping);

            outputQ.put(ping.frame());

        } catch (Throwable t) {

            ping.fail(t);

        }

        return ping.response();

    }

    void goAway(int error) throws IOException {

        int laststream = nextstream >= 3 ? nextstream - 2 : 1;

        GoAwayFrame go = new GoAwayFrame(laststream, error);

        outputQ.put(go);

    }

    /**

     * Returns the first PingRequest from Queue

     */

    private PingRequest getNextRequest() {

        return pings.poll();

    }

    /**

     * Handles incoming Ping, which could be an ack

     * or a client originated Ping

     */

    void handlePing(PingFrame ping) throws IOException {

        if (ping.streamid() != 0) {

            System.err.println("Invalid ping received");

            close(ErrorFrame.PROTOCOL_ERROR);

            return;

        }

        if (ping.getFlag(PingFrame.ACK)) {

            // did we send a Ping?

            PingRequest request = getNextRequest();

            if (request == null) {

                System.err.println("Invalid ping ACK received");

                close(ErrorFrame.PROTOCOL_ERROR);

                return;

            } else if (!Arrays.equals(request.pingData, ping.getData())) {

                request.fail(new RuntimeException("Wrong ping data in ACK"));

            } else {

                request.success();

            }

        } else {

            // client originated PING. Just send it back with ACK set

            ping.setFlag(PingFrame.ACK);

            outputQ.put(ping);

        }

    }

    private static boolean compareIPAddrs(InetAddress addr1, String host) {

        try {

            InetAddress addr2 = InetAddress.getByName(host);

            return addr1.equals(addr2);

        } catch (IOException e) {

            throw new UncheckedIOException(e);

        }

    }

    private static void handshake(String name, SSLSocket sock) throws IOException {

        if (name == null) {

            // no name set. No need to check

            return;

        } else if (name.equals("localhost")) {

            name = "localhost";

        }

        final String fname = name;

        final InetAddress addr1 = InetAddress.getByName(name);

        SSLParameters params = sock.getSSLParameters();

        SNIMatcher matcher = new SNIMatcher(StandardConstants.SNI_HOST_NAME) {

            public boolean matches (SNIServerName n) {

                String host = ((SNIHostName)n).getAsciiName();

                if (host.equals("localhost"))

                    host = "localhost";

                boolean cmp = host.equalsIgnoreCase(fname);

                if (cmp)

                    return true;

                return compareIPAddrs(addr1, host);

            }

        };

        List<SNIMatcher> list = List.of(matcher);

        params.setSNIMatchers(list);

        sock.setSSLParameters(params);

        sock.getSession(); // blocks until handshake done

    }

    void closeIncoming() {

        close(-1);

    }

    void close(int error) {

        if (stopping)

            return;

        stopping = true;

        System.err.printf("Server connection to %s stopping. %d streams\n",

            socket.getRemoteSocketAddress().toString(), streams.size());

        streams.forEach((i, q) -> {

            q.orderlyClose();

        });

        try {

            if (error != -1)

                goAway(error);

            outputQ.orderlyClose();

            socket.close();

        } catch (Exception e) {

        }

    }

    private void readPreface() throws IOException {

        int len = clientPreface.length;

        byte[] bytes = new byte[len];

        is.readNBytes(bytes, 0, len);

        if (Arrays.compare(clientPreface, bytes) != 0) {

            throw new IOException("Invalid preface: " + new String(bytes, 0, len));

        }

    }

    Http1InitialRequest doUpgrade() throws IOException {

        Http1InitialRequest upgrade = readHttp1Request();

        String h2c = getHeader(upgrade.headers, "Upgrade");

        if (h2c == null || !h2c.equals("h2c")) {

            System.err.println("Server:HEADERS: " + upgrade);

            throw new IOException("Bad upgrade 1 " + h2c);

        }

        sendHttp1Response(101, "Switching Protocols", "Connection", "Upgrade",

                "Upgrade", "h2c");

        sendSettingsFrame();

        readPreface();

        String clientSettingsString = getHeader(upgrade.headers, "HTTP2-Settings");

        clientSettings = getSettingsFromString(clientSettingsString);

        return upgrade;

    }

    /**

     * Decodes the given, Client, settings payload provided in base64 HTTP1

     * header value.

     */

    private SettingsFrame getSettingsFromString(String s) throws IOException {

        Base64.Decoder decoder = Base64.getUrlDecoder();

        byte[] payload = decoder.decode(s);

        ByteBuffer bb1 = ByteBuffer.wrap(payload);

        // simulate header of Settings Frame

        ByteBuffer bb0 = ByteBuffer.wrap(

                new byte[] {0, 0, (byte)payload.length, 4, 0, 0, 0, 0, 0});

        List<Http2Frame> frames = new ArrayList<>();

        FramesDecoder reader = new FramesDecoder(frames::add);

        reader.decode(bb0);

        reader.decode(bb1);

        if (frames.size()!=1)

            throw new IOException("Expected 1 frame got "+frames.size()) ;

        Http2Frame frame = frames.get(0);

        if (!(frame instanceof SettingsFrame))

            throw new IOException("Expected SettingsFrame");

        return (SettingsFrame)frame;

    }

    public int getMaxFrameSize() {

        return clientSettings.getParameter(SettingsFrame.MAX_FRAME_SIZE);

    }

    void run() throws Exception {

        Http1InitialRequest upgrade = null;

        if (!secure) {

            upgrade = doUpgrade();

        } else {

            readPreface();

            sendSettingsFrame(true);

            clientSettings = (SettingsFrame) readFrame();

            if (clientSettings.getFlag(SettingsFrame.ACK)) {

                // we received the ack to our frame first

                clientSettings = (SettingsFrame) readFrame();

            }

            nextstream = 1;

        }

        // Uncomment if needed, but very noisy

        //System.out.println("ServerSettings: " + serverSettings);

        //System.out.println("ClientSettings: " + clientSettings);

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

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

        if (!secure) {

            createPrimordialStream(upgrade);

            nextstream = 3;

        }

        (new ConnectionThread("readLoop", this::readLoop)).start();

        (new ConnectionThread("writeLoop", this::writeLoop)).start();

    }

    class ConnectionThread extends Thread {

        final Runnable r;

        ConnectionThread(String name, Runnable r) {

            setName(name);

            setDaemon(true);

            this.r = r;

        }

        public void run() {

            r.run();

        }

    }

    private void writeFrame(Http2Frame frame) throws IOException {

        List<ByteBuffer> bufs = new FramesEncoder().encodeFrame(frame);

        //System.err.println("TestServer: Writing frame " + frame.toString());

        int c = 0;

        for (ByteBuffer buf : bufs) {

            byte[] ba = buf.array();

            int start = buf.arrayOffset() + buf.position();

            c += buf.remaining();

            os.write(ba, start, buf.remaining());

//            System.out.println("writing byte at a time");

//            while (buf.hasRemaining()) {

//                byte b = buf.get();

//                os.write(b);

//                os.flush();

//                try {

//                    Thread.sleep(1);

//                } catch(InterruptedException e) {

//                    UncheckedIOException uie = new UncheckedIOException(new IOException(""));

//                    uie.addSuppressed(e);

//                    throw uie;

//                }

//            }

        }

        os.flush();

        //System.err.printf("TestServer: wrote %d bytes\n", c);

    }

    private void handleCommonFrame(Http2Frame f) throws IOException {

        if (f instanceof SettingsFrame) {

            SettingsFrame sf = (SettingsFrame) f;

            if (sf.getFlag(SettingsFrame.ACK)) // ignore

            {

                return;

            }

            // otherwise acknowledge it

            clientSettings = sf;

            SettingsFrame frame = new SettingsFrame();

            frame.setFlag(SettingsFrame.ACK);

            frame.streamid(0);

            outputQ.put(frame);

            return;

        } else if (f instanceof GoAwayFrame) {

            System.err.println("Closing: "+ f.toString());

            close(ErrorFrame.NO_ERROR);

        } else if (f instanceof PingFrame) {

            handlePing((PingFrame)f);

        } else

            throw new UnsupportedOperationException("Not supported yet: " + f.toString());

    }

    void sendWindowUpdates(int len, int streamid) throws IOException {

        if (len == 0)

            return;

        WindowUpdateFrame wup = new WindowUpdateFrame(streamid, len);

        outputQ.put(wup);

        wup = new WindowUpdateFrame(0 , len);

        outputQ.put(wup);

    }

    HttpHeaders decodeHeaders(List<HeaderFrame> frames) throws IOException {

        HttpHeadersBuilder headersBuilder = createNewHeadersBuilder();

        DecodingCallback cb = (name, value) -> {

            headersBuilder.addHeader(name.toString(), value.toString());

        };

        for (HeaderFrame frame : frames) {

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

            for (ByteBuffer buffer : buffers) {

                hpackIn.decode(buffer, false, cb);

            }

        }

        hpackIn.decode(EMPTY_BUFFER, true, cb);

        return headersBuilder.build();

    }

    String getRequestLine(String request) {

        int eol = request.indexOf(CRLF);

        return request.substring(0, eol);

    }

    String getHeaders(String request) {

        int start = request.indexOf(CRLF);

        int end = request.indexOf(CRLFCRLF);

        if (start == -1 || end == -1) {

            throw new RuntimeException("Malformed request");

        }

        return request.substring(start,end);

    }

    static void addHeaders(String headersString, HttpHeadersBuilder headersBuilder) {

        String[] hh = headersString.split(CRLF);

        for (String header : hh) {

            int colon = header.indexOf(':');

            if (colon == -1)

                continue;

            String name = header.substring(0, colon);

            String value = header.substring(colon+1);

            while (value.startsWith(" "))

                value = value.substring(1);

            headersBuilder.addHeader(name, value);

        }

    }

    // First stream (1) comes from a plaintext HTTP/1.1 request

    @SuppressWarnings({"rawtypes","unchecked"})