/*
 * 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.  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 sun.net.www.MessageHeader;

import java.io.IOException;
import java.io.InputStream;
import java.net.ProtocolException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.OptionalLong;

import static java.lang.String.format;
import static jdk.incubator.http.internal.common.Utils.isValidName;
import static jdk.incubator.http.internal.common.Utils.isValidValue;
import static java.util.Objects.requireNonNull;

/*
 * Reads entire header block off channel, in blocking mode.
 * This class is not thread-safe.
 */
final class ResponseHeaders implements HttpHeaders {

    private static final char CR = '\r';
    private static final char LF = '\n';

    private final ImmutableHeaders delegate;

    /*
     * This constructor takes a connection from which the header block is read
     * and a buffer which may contain an initial portion of this header block.
     *
     * After the headers have been parsed (this constructor has returned) the
     * leftovers (i.e. data, if any, beyond the header block) are accessible
     * from this same buffer from its position to its limit.
     */
    ResponseHeaders(HttpConnection connection, ByteBuffer buffer) throws IOException {
        requireNonNull(connection);
        requireNonNull(buffer);
        InputStreamWrapper input = new InputStreamWrapper(connection, buffer);
        delegate = ImmutableHeaders.of(parse(input));
    }

    static final class InputStreamWrapper extends InputStream {
        final HttpConnection connection;
        ByteBuffer buffer;
        int lastRead = -1; // last byte read from the buffer
        int consumed = 0; // number of bytes consumed.
        InputStreamWrapper(HttpConnection connection, ByteBuffer buffer) {
            super();
            this.connection = connection;
            this.buffer = buffer;
        }
        @Override
        public int read() throws IOException {
            if (!buffer.hasRemaining()) {
                buffer = connection.read();
                if (buffer == null) {
                    return lastRead = -1;
                }
            }
            // don't let consumed become positive again if it overflowed
            // we just want to make sure that consumed == 1 really means
            // that only one byte was consumed.
            if (consumed >= 0) consumed++;
            return lastRead = buffer.get();
        }
    }

    private static void display(Map<String, List<String>> map) {
        map.forEach((k,v) -> {
            System.out.print (k + ": ");
            for (String val : v) {
                System.out.print(val + ", ");
            }
            System.out.println("");
        });
    }

    private Map<String, List<String>> parse(InputStreamWrapper input)
         throws IOException
    {
        // The bulk of work is done by this time-proven class
        MessageHeader h = new MessageHeader();
        h.parseHeader(input);

        // When there are no headers (and therefore no body), the status line
        // will be followed by an empty CRLF line.
        // In that case MessageHeader.parseHeader() will consume the first
        // CR character and stop there. In this case we must consume the
        // remaining LF.
        if (input.consumed == 1 && CR == (char) input.lastRead) {
            // MessageHeader will not consume LF if the first character it
            // finds is CR. This only happens if there are no headers, and
            // only one byte will be consumed from the buffer. In this case
            // the next byte MUST be LF
            if (input.read() != LF) {
                throw new IOException("Unexpected byte sequence when no headers: "
                     + ((int)CR) + " " + input.lastRead
                     + "(" + ((int)CR) + " " + ((int)LF) + " expected)");
            }
        }

        Map<String, List<String>> rawHeaders = h.getHeaders();

        // Now some additional post-processing to adapt the results received
        // from MessageHeader to what is needed here
        Map<String, List<String>> cookedHeaders = new HashMap<>();
        for (Map.Entry<String, List<String>> e : rawHeaders.entrySet()) {
            String key = e.getKey();
            if (key == null) {
                throw new ProtocolException("Bad header-field");
            }
            if (!isValidName(key)) {
                throw new ProtocolException(format(
                        "Bad header-name: '%s'", key));
            }
            List<String> newValues = e.getValue();
            for (String v : newValues) {
                if (!isValidValue(v)) {
                    throw new ProtocolException(format(
                            "Bad header-value for header-name: '%s'", key));
                }
            }
            String k = key.toLowerCase(Locale.US);
            cookedHeaders.merge(k, newValues,
                    (v1, v2) -> {
                        ArrayList<String> newV = new ArrayList<>();
                        if (v1 != null) {
                            newV.addAll(v1);
                        }
                        newV.addAll(v2);
                        return newV;
                    });
        }
        return cookedHeaders;
    }

    int getContentLength() throws IOException {
        return (int) firstValueAsLong("Content-Length").orElse(-1);
    }

    @Override
    public Optional<String> firstValue(String name) {
        return delegate.firstValue(name);
    }

    @Override
    public OptionalLong firstValueAsLong(String name) {
        return delegate.firstValueAsLong(name);
    }

    @Override
    public List<String> allValues(String name) {
        return delegate.allValues(name);
    }

    @Override
    public Map<String, List<String>> map() {
        return delegate.map();
    }
}