/*

 * Copyright (c) 2015, 2017, 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.nio.ByteBuffer;

import java.nio.charset.StandardCharsets;

import java.util.*;

import java.util.concurrent.ExecutorService;

import java.util.function.Consumer;

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

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

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

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

import sun.net.www.http.ChunkedInputStream;

import sun.net.www.http.HttpClient;

import static jdk.incubator.http.internal.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;

    volatile boolean stopping;

    volatile int nextPushStreamId = 2;

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

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

    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 Sentinel sentinel;

    Http2TestServerConnection(Http2TestServer server,

                              Socket socket,

                              Http2TestExchangeSupplier exchangeSupplier)

        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.socket = socket;

        this.socket.setTcpNoDelay(true);

        this.serverSettings = SettingsFrame.getDefaultSettings();

        this.exec = server.exec;

        this.secure = server.secure;

        this.pushStreams = new HashSet<>();

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

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

    }

    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("127.0.0.1")) {

            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("127.0.0.1"))

                    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 close() {

        stopping = true;

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

            q.close();

        });

        try {

            socket.close();

            // TODO: put a reset on each stream

        } catch (IOException 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));

        }

    }

    String doUpgrade() throws IOException {

        String upgrade = readHttp1Request();

        String h2c = getHeader(upgrade, "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, "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;

    }

    void run() throws Exception {

        String 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;

        }

        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;

        }

        exec.submit(this::readLoop);

        exec.submit(this::writeLoop);

    }

    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();

    }

    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);

    }

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

        HttpHeadersImpl headers = new HttpHeadersImpl();

        DecodingCallback cb = (name, value) -> {

            headers.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 headers;

    }

    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);

    }

    void addHeaders(String headers, HttpHeadersImpl hdrs) {

        String[] hh = headers.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);

            hdrs.addHeader(name, value);

        }

    }

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

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

    void createPrimordialStream(String request) throws IOException {

        HttpHeadersImpl headers = new HttpHeadersImpl();

        String requestLine = getRequestLine(request);

        String[] tokens = requestLine.split(" ");

        if (!tokens[2].equals("HTTP/1.1")) {

            throw new IOException("bad request line");

        }

        URI uri = null;

        try {

            uri = new URI(tokens[1]);

        } catch (URISyntaxException e) {

            throw new IOException(e);

        }

        String host = getHeader(request, "Host");

        if (host == null) {

            throw new IOException("missing Host");

        }

        headers.setHeader(":method", tokens[0]);

        headers.setHeader(":scheme", "http"); // always in this case

        headers.setHeader(":authority", host);

        headers.setHeader(":path", uri.getPath());

        Queue q = new Queue(sentinel);

        String body = getRequestBody(request);

        addHeaders(getHeaders(request), headers);

        headers.setHeader("Content-length", Integer.toString(body.length()));

        addRequestBodyToQueue(body, q);

        streams.put(1, q);

        exec.submit(() -> {

            handleRequest(headers, q, 1, true /*complete request has been read*/);

        });

    }

    // all other streams created here

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

    void createStream(HeaderFrame frame) throws IOException {

        List<HeaderFrame> frames = new LinkedList<>();

        frames.add(frame);

        int streamid = frame.streamid();

        if (streamid != nextstream) {

            throw new IOException("unexpected stream id");

        }

        nextstream += 2;

        boolean endStream = false;

        if (frame.getFlag(HeaderFrame.END_STREAM)) {

            endStream = true;

        }

        while (!frame.getFlag(HeaderFrame.END_HEADERS)) {

            Http2Frame f = readFrame();

            if (!(f instanceof HeaderFrame)) {

                handleCommonFrame(f); // should only be error frames

            } else {

                frame = (HeaderFrame) f;

                if (frame.getFlag(HeaderFrame.END_STREAM)) {

                    endStream = true;

                }

                frames.add(frame);

            }

        }

        boolean endStreamReceived = endStream;

        HttpHeadersImpl headers = decodeHeaders(frames);

        Queue q = new Queue(sentinel);

        streams.put(streamid, q);

        exec.submit(() -> {

            handleRequest(headers, q, streamid, endStreamReceived);

        });

    }

    // runs in own thread. Handles request from start to finish. Incoming frames

    // for this stream/request delivered on Q

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

    void handleRequest(HttpHeadersImpl headers,

                       Queue queue,

                       int streamid,

                       boolean endStreamReceived)

    {

        String method = headers.firstValue(":method").orElse("");

        //System.out.println("method = " + method);

        String path = headers.firstValue(":path").orElse("");

        //System.out.println("path = " + path);

        String scheme = headers.firstValue(":scheme").orElse("");

        //System.out.println("scheme = " + scheme);

        String authority = headers.firstValue(":authority").orElse("");

        //System.out.println("authority = " + authority);

        System.err.printf("TestServer: %s %s\n", method, path);

        HttpHeadersImpl rspheaders = new HttpHeadersImpl();

        int winsize = clientSettings.getParameter(

                SettingsFrame.INITIAL_WINDOW_SIZE);

        //System.err.println ("Stream window size = " + winsize);

        final InputStream bis;

        if (endStreamReceived && queue.size() == 0) {

            System.err.println("Server: got END_STREAM for stream " + streamid);

            bis = NullInputStream.INSTANCE;

        } else {

            System.err.println("Server: creating input stream for stream " + streamid);

            bis = new BodyInputStream(queue, streamid, this);

        }

        try (bis;

             BodyOutputStream bos = new BodyOutputStream(streamid, winsize, this))

        {

            outStreams.put(streamid, bos);

            String us = scheme + "://" + authority + path;

            URI uri = new URI(us);

            boolean pushAllowed = clientSettings.getParameter(SettingsFrame.ENABLE_PUSH) == 1;