/*

 * Copyright (c) 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.IOException;

import java.io.UncheckedIOException;

import java.net.URI;

import java.nio.file.OpenOption;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.StandardOpenOption;

import java.util.List;

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.ConcurrentMap;

import java.util.function.Function;

import java.net.http.HttpHeaders;

import java.net.http.HttpRequest;

import java.net.http.HttpResponse;

import java.net.http.HttpResponse.BodyHandler;

import java.net.http.HttpResponse.BodySubscriber;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import jdk.internal.net.http.ResponseSubscribers.PathSubscriber;

import static java.util.regex.Pattern.CASE_INSENSITIVE;

public final class ResponseBodyHandlers {

    private ResponseBodyHandlers() { }

    /**

     * A Path body handler.

     */

    public static class PathBodyHandler implements BodyHandler<Path>{

        private final Path file;

        private final List<OpenOption> openOptions;

        public PathBodyHandler(Path file, List<OpenOption> openOptions) {

            this.file = file;

            this.openOptions = openOptions;

        }

        @Override

        public BodySubscriber<Path> apply(int statusCode, HttpHeaders headers) {

            return new PathSubscriber(file, openOptions);

        }

    }

    /** With push promise Map implementation */

    public static class PushPromisesHandlerWithMap<T>

        implements HttpResponse.PushPromiseHandler<T>

    {

        private final ConcurrentMap<HttpRequest,CompletableFuture<HttpResponse<T>>> pushPromisesMap;

        private final Function<HttpRequest,BodyHandler<T>> pushPromiseHandler;

        public PushPromisesHandlerWithMap(Function<HttpRequest,BodyHandler<T>> pushPromiseHandler,

                                          ConcurrentMap<HttpRequest,CompletableFuture<HttpResponse<T>>> pushPromisesMap) {

            this.pushPromiseHandler = pushPromiseHandler;

            this.pushPromisesMap = pushPromisesMap;

        }

        @Override

        public void applyPushPromise(

                HttpRequest initiatingRequest, HttpRequest pushRequest,

                Function<BodyHandler<T>,CompletableFuture<HttpResponse<T>>> acceptor)

        {

            URI initiatingURI = initiatingRequest.uri();

            URI pushRequestURI = pushRequest.uri();

            if (!initiatingURI.getHost().equalsIgnoreCase(pushRequestURI.getHost()))

                return;

            int initiatingPort = initiatingURI.getPort();

            if (initiatingPort == -1 ) {

                if ("https".equalsIgnoreCase(initiatingURI.getScheme()))

                    initiatingPort = 443;

                else

                    initiatingPort = 80;

            }

            int pushPort = pushRequestURI.getPort();

            if (pushPort == -1 ) {

                if ("https".equalsIgnoreCase(pushRequestURI.getScheme()))

                    pushPort = 443;

                else

                    pushPort = 80;

            }

            if (initiatingPort != pushPort)

                return;

            CompletableFuture<HttpResponse<T>> cf =

                    acceptor.apply(pushPromiseHandler.apply(pushRequest));

            pushPromisesMap.put(pushRequest, cf);

        }

    }

    // Similar to Path body handler, but for file download.

    public static class FileDownloadBodyHandler implements BodyHandler<Path> {

        private final Path directory;

        private final List<OpenOption> openOptions;

        public FileDownloadBodyHandler(Path directory, List<OpenOption> openOptions) {

            this.directory = directory;

            this.openOptions = openOptions;

        }

        /** The "attachment" disposition-type and separator. */

        static final String DISPOSITION_TYPE = "attachment;";

        /** The "filename" parameter. */

        static final Pattern FILENAME = Pattern.compile("filename\\s*=", CASE_INSENSITIVE);

        static final List<String> PROHIBITED = List.of(".", "..", "", "~" , "|");

        static final UncheckedIOException unchecked(int code,

                                                    HttpHeaders headers,

                                                    String msg) {

            String s = String.format("%s in response [%d, %s]", msg, code, headers);

            return new UncheckedIOException(new IOException(s));

        }

        @Override

        public BodySubscriber<Path> apply(int statusCode, HttpHeaders headers) {

            String dispoHeader = headers.firstValue("Content-Disposition")

                    .orElseThrow(() -> unchecked(statusCode, headers,

                            "No Content-Disposition header"));

            if (!dispoHeader.regionMatches(true, // ignoreCase

                                           0, DISPOSITION_TYPE,

                                           0, DISPOSITION_TYPE.length())) {

                throw unchecked(statusCode, headers, "Unknown Content-Disposition type");

            }

            Matcher matcher = FILENAME.matcher(dispoHeader);

            if (!matcher.find()) {

                throw unchecked(statusCode, headers,

                          "Bad Content-Disposition filename parameter");

            }

            int n = matcher.end();

            int semi = dispoHeader.substring(n).indexOf(";");

            String filenameParam;

            if (semi < 0) {

                filenameParam = dispoHeader.substring(n);

            } else {

                filenameParam = dispoHeader.substring(n, n + semi);

            }

            // strip all but the last path segment

            int x = filenameParam.lastIndexOf("/");

            if (x != -1) {

                filenameParam = filenameParam.substring(x+1);

            }

            x = filenameParam.lastIndexOf("\\");

            if (x != -1) {

                filenameParam = filenameParam.substring(x+1);

            }

            filenameParam = filenameParam.trim();

            if (filenameParam.startsWith("\"")) {  // quoted-string

                if (!filenameParam.endsWith("\"") || filenameParam.length() == 1) {

                    throw unchecked(statusCode, headers,

                            "Badly quoted Content-Disposition filename parameter");

                }

                filenameParam = filenameParam.substring(1, filenameParam.length() -1 );

            } else {  // token,

                if (filenameParam.contains(" ")) {  // space disallowed

                    throw unchecked(statusCode, headers,

                            "unquoted space in Content-Disposition filename parameter");

                }

            }

            if (PROHIBITED.contains(filenameParam)) {

                throw unchecked(statusCode, headers,

                        "Prohibited Content-Disposition filename parameter:"

                                + filenameParam);

            }

            Path file = Paths.get(directory.toString(), filenameParam);

            if (!file.startsWith(directory)) {

                throw unchecked(statusCode, headers,

                        "Resulting file, " + file.toString() + ", outside of given directory");

            }

            return new PathSubscriber(file, openOptions);

        }

    }

}