/*

 * Copyright (c) 2015, 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.  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.incubator.http;

import java.io.IOException;

import java.net.URI;

import java.nio.ByteBuffer;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.net.InetSocketAddress;

import jdk.incubator.http.HttpConnection.Mode;

import jdk.incubator.http.RequestProcessors.ProcessorBase;

import java.nio.charset.StandardCharsets;

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

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.CompletionException;

import java.util.concurrent.Flow;

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

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

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

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

/**

 *  A HTTP/1.1 request.

 *

 * send() -> Writes the request + body to the given channel, in one blocking

 * operation.

 */

class Http1Request {

    final HttpClientImpl client;

    final HttpRequestImpl request;

    final HttpConnection chan;

    // Multiple buffers are used to hold different parts of request

    // See line 206 and below for description

    final ByteBuffer[] buffers;

    final HttpRequest.BodyProcessor requestProc;

    final HttpHeaders userHeaders;

    final HttpHeadersImpl systemHeaders;

    boolean streaming;

    long contentLength;

    final CompletableFuture<Void> cf;

    Http1Request(HttpRequestImpl request, HttpClientImpl client, HttpConnection connection)

        throws IOException

    {

        this.client = client;

        this.request = request;

        this.chan = connection;

        buffers = new ByteBuffer[5]; // TODO: check

        this.requestProc = request.requestProcessor;

        this.userHeaders = request.getUserHeaders();

        this.systemHeaders = request.getSystemHeaders();

        this.cf = new MinimalFuture<>();

    }

    private void logHeaders() throws IOException {

        StringBuilder sb = new StringBuilder(256);

        sb.append("REQUEST HEADERS:\n");

        Log.dumpHeaders(sb, "    ", systemHeaders);

        Log.dumpHeaders(sb, "    ", userHeaders);

        Log.logHeaders(sb.toString());

    }

    private void dummy(long x) {

        // not used in this class

    }

    private void collectHeaders0() throws IOException {

        if (Log.headers()) {

            logHeaders();

        }

        StringBuilder sb = new StringBuilder(256);

        collectHeaders1(sb, request, systemHeaders);

        collectHeaders1(sb, request, userHeaders);

        sb.append("\r\n");

        String headers = sb.toString();

        buffers[1] = ByteBuffer.wrap(headers.getBytes(StandardCharsets.US_ASCII));

    }

    private void collectHeaders1(StringBuilder sb,

                                 HttpRequestImpl request,

                                 HttpHeaders headers)

        throws IOException

    {

        Map<String,List<String>> h = headers.map();

        Set<Map.Entry<String,List<String>>> entries = h.entrySet();

        for (Map.Entry<String,List<String>> entry : entries) {

            String key = entry.getKey();

            List<String> values = entry.getValue();

            for (String value : values) {

                sb.append(key)

                  .append(": ")

                  .append(value)

                  .append("\r\n");

            }

        }

    }

    private String getPathAndQuery(URI uri) {

        String path = uri.getPath();

        String query = uri.getQuery();

        if (path == null || path.equals("")) {

            path = "/";

        }

        if (query == null) {

            query = "";

        }

        if (query.equals("")) {

            return path;

        } else {

            return path + "?" + query;

        }

    }

    private String authorityString(InetSocketAddress addr) {

        return addr.getHostString() + ":" + addr.getPort();

    }

    private String hostString() {

        URI uri = request.uri();

        int port = uri.getPort();

        String host = uri.getHost();

        boolean defaultPort;

        if (port == -1) {

            defaultPort = true;

        } else if (request.secure()) {

            defaultPort = port == 443;

        } else {

            defaultPort = port == 80;

        }

        if (defaultPort) {

            return host;

        } else {

            return host + ":" + Integer.toString(port);

        }

    }

    private String requestURI() {

        URI uri = request.uri();

        String method = request.method();

        if ((request.proxy(client) == null && !method.equals("CONNECT"))

                || request.isWebSocket()) {

            return getPathAndQuery(uri);

        }

        if (request.secure()) {

            if (request.method().equals("CONNECT")) {

                // use authority for connect itself

                return authorityString(request.authority());

            } else {

                // requests over tunnel do not require full URL

                return getPathAndQuery(uri);

            }

        }

        return uri == null? authorityString(request.authority()) : uri.toString();

    }

    void sendHeadersOnly() throws IOException {

        collectHeaders();

        chan.write(buffers, 0, 2);

    }

    void sendRequest() throws IOException {

        collectHeaders();

        chan.configureMode(Mode.BLOCKING);

        if (contentLength == 0) {

            chan.write(buffers, 0, 2);

        } else if (contentLength > 0) {

            writeFixedContent(true);

        } else {

            writeStreamedContent(true);

        }

        setFinished();

    }

    private boolean finished;

    synchronized boolean finished() {

        return  finished;

    }

    synchronized void setFinished() {

        finished = true;

    }

    private void collectHeaders() throws IOException {

        if (Log.requests() && request != null) {

            Log.logRequest(request.toString());

        }

        String uriString = requestURI();

        StringBuilder sb = new StringBuilder(64);

        sb.append(request.method())

          .append(' ')

          .append(uriString)

          .append(" HTTP/1.1\r\n");

        String cmd = sb.toString();

        buffers[0] = ByteBuffer.wrap(cmd.getBytes(StandardCharsets.US_ASCII));

        URI uri = request.uri();

        if (uri != null) {

            systemHeaders.setHeader("Host", hostString());

        }

        if (request == null) {

            // this is not a user request. No content

            contentLength = 0;

        } else {

            contentLength = requestProc.contentLength();

        }

        if (contentLength == 0) {

            systemHeaders.setHeader("Content-Length", "0");

            collectHeaders0();

        } else if (contentLength > 0) {

            /* [0] request line [1] headers [2] body  */

            systemHeaders.setHeader("Content-Length",

                                    Integer.toString((int) contentLength));

            streaming = false;

            collectHeaders0();

            buffers[2] = getBuffer();

        } else {

            /* Chunked:

             *

             * [0] request line [1] headers [2] chunk header [3] chunk data [4]

             * final chunk header and trailing CRLF of previous chunks

             *

             * 2,3,4 used repeatedly */

            streaming = true;

            systemHeaders.setHeader("Transfer-encoding", "chunked");

            collectHeaders0();

            buffers[3] = getBuffer();

        }

    }

    private ByteBuffer getBuffer() {

        return ByteBuffer.allocate(Utils.BUFSIZE);

    }

    // The following two methods used by Http1Exchange to handle expect continue

    void continueRequest() throws IOException {

        if (streaming) {

            writeStreamedContent(false);

        } else {

            writeFixedContent(false);

        }

        setFinished();

    }

    class StreamSubscriber extends ProcessorBase

        implements Flow.Subscriber<ByteBuffer>

    {

        volatile Flow.Subscription subscription;

        volatile boolean includeHeaders;

        StreamSubscriber(boolean includeHeaders) {

            this.includeHeaders = includeHeaders;

        }

        @Override

        public void onSubscribe(Flow.Subscription subscription) {

            if (this.subscription != null) {

                throw new IllegalStateException("already subscribed");

            }

            this.subscription = subscription;

            subscription.request(1);

        }

        @Override

        public void onNext(ByteBuffer item) {

            int startbuf, nbufs;

            if (cf.isDone()) {

                throw new IllegalStateException("subscription already completed");

            }

            if (includeHeaders) {

                startbuf = 0;

                nbufs = 5;

            } else {

                startbuf = 2;

                nbufs = 3;

            }

            int chunklen = item.remaining();

            buffers[3] = item;

            buffers[2] = getHeader(chunklen);

            buffers[4] = CRLF_BUFFER();

            try {

                chan.write(buffers, startbuf, nbufs);

            } catch (IOException e) {

                subscription.cancel();

                cf.completeExceptionally(e);

            }

            includeHeaders = false;

            subscription.request(1);

        }

        @Override

        public void onError(Throwable throwable) {

            if (cf.isDone()) {

                return;

            }

            subscription.cancel();

            cf.completeExceptionally(throwable);

        }

        @Override

        public void onComplete() {

            if (cf.isDone()) {

                throw new IllegalStateException("subscription already completed");

            }

            buffers[3] = EMPTY_CHUNK_HEADER();

            buffers[4] = CRLF_BUFFER();

            try {

                chan.write(buffers, 3, 2);

            } catch (IOException ex) {

                cf.completeExceptionally(ex);

                return;

            }

            cf.complete(null);

        }

    }

    private void waitForCompletion() throws IOException {

        try {

            cf.join();

        } catch (CompletionException e) {

            throw Utils.getIOException(e);

        }

    }

    /* Entire request is sent, or just body only  */

    private void writeStreamedContent(boolean includeHeaders)

        throws IOException

    {

        StreamSubscriber subscriber = new StreamSubscriber(includeHeaders);

        subscriber.setClient(client);

        requestProc.subscribe(subscriber);

        waitForCompletion();

    }

    class FixedContentSubscriber extends ProcessorBase

        implements Flow.Subscriber<ByteBuffer>

    {

        volatile Flow.Subscription subscription;

        volatile boolean includeHeaders;

        volatile long contentWritten = 0;

        FixedContentSubscriber(boolean includeHeaders) {

            this.includeHeaders = includeHeaders;

        }

        @Override

        public void onSubscribe(Flow.Subscription subscription) {

            if (this.subscription != null) {

                throw new IllegalStateException("already subscribed");

            }

            this.subscription = subscription;

            subscription.request(1);

        }

        @Override

        public void onNext(ByteBuffer item) {

            int startbuf, nbufs;

            long headersLength;

            if (includeHeaders) {

                startbuf = 0;

                nbufs = 3;

                headersLength = buffers[0].remaining() + buffers[1].remaining();

            } else {

                startbuf = 2;

                nbufs = 1;

                headersLength = 0;

            }

            buffers[2] = item;

            try {

                long writing = buffers[2].remaining() + headersLength;

                contentWritten += buffers[2].remaining();

                chan.checkWrite(writing, buffers, startbuf, nbufs);

                if (contentWritten > contentLength) {

                    String msg = "Too many bytes in request body. Expected: " +

                        Long.toString(contentLength) + " Sent: " +

                        Long.toString(contentWritten);

                    throw new IOException(msg);

                }

                subscription.request(1);

            } catch (IOException e) {

                subscription.cancel();

                cf.completeExceptionally(e);

            }

        }

        @Override

        public void onError(Throwable throwable) {

            if (cf.isDone()) {

                return;

            }

            subscription.cancel();

            cf.completeExceptionally(throwable);

        }

        @Override

        public void onComplete() {

            if (cf.isDone()) {

                throw new IllegalStateException("subscription already completed");

            }

            if (contentLength > contentWritten) {

                subscription.cancel();

                Exception e = new IOException("Too few bytes returned by the processor");

                cf.completeExceptionally(e);

            } else {

                cf.complete(null);

            }

        }

    }

    /* Entire request is sent, or just body only */

    private void writeFixedContent(boolean includeHeaders)

            throws IOException {

        if (contentLength == 0) {

            return;

        }

        FixedContentSubscriber subscriber = new FixedContentSubscriber(includeHeaders);

        subscriber.setClient(client);

        requestProc.subscribe(subscriber);

        waitForCompletion();

    }

    private static final byte[] CRLF = {'\r', '\n'};

    private static final byte[] EMPTY_CHUNK_BYTES = {'0', '\r', '\n'};

    private ByteBuffer CRLF_BUFFER() {

        return ByteBuffer.wrap(CRLF);

    }

    private ByteBuffer EMPTY_CHUNK_HEADER() {

        return ByteBuffer.wrap(EMPTY_CHUNK_BYTES);

    }

    /* Returns a header for a particular chunk size */

    private static ByteBuffer getHeader(int size){

        String hexStr =  Integer.toHexString(size);

        byte[] hexBytes = hexStr.getBytes(US_ASCII);

        byte[] header = new byte[hexStr.length()+2];

        System.arraycopy(hexBytes, 0, header, 0, hexBytes.length);

        header[hexBytes.length] = CRLF[0];

        header[hexBytes.length+1] = CRLF[1];

        return ByteBuffer.wrap(header);

    }

}