/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.wicket.request;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.wicket.util.lang.Args;
import org.apache.wicket.util.string.PrependingStringBuffer;
import org.apache.wicket.util.string.Strings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Takes care of rendering URLs.
 * <p>
 * Normally Urls are rendered relative to the base Url. Base Url is normally Url of the page being
 * rendered. However, during Ajax request and redirect to buffer rendering the BaseUrl needs to be
 * adjusted.
 *
 * @author Matej Knopp
 * @author Igor Vaynberg
 */
public class UrlRenderer
{
        private static final Logger LOG = LoggerFactory.getLogger(UrlRenderer.class);

        private static final Map<String, Integer> PROTO_TO_PORT = new HashMap<>();
        static
        {
                PROTO_TO_PORT.put("http", 80);
                PROTO_TO_PORT.put("https", 443);
        }

        private final Request request;
        private Url baseUrl;

        /**
         * Construct.
         *
         * @param request
         *            Request that serves as the base for rendering urls
         */
        public UrlRenderer(final Request request)
        {
                this.request = request;
                baseUrl = request.getClientUrl();
        }

        /**
         * Sets the base Url. All generated URLs will be relative to this Url.
         *
         * @param base
         * @return original base Url
         */
        public Url setBaseUrl(final Url base)
        {
                Args.notNull(base, "base");

                Url original = baseUrl;
                baseUrl = base;
                return original;
        }

        /**
         * Returns the base Url.
         *
         * @return base Url
         */
        public Url getBaseUrl()
        {
                return baseUrl;
        }

        /**
         * Renders the Url
         *
         * @param url
         * @return Url rendered as string
         */
        public String renderUrl(final Url url)
        {
                final String renderedUrl;
                if (shouldRenderAsFull(url))
                {
                        if (!(url.isFull() || url.isContextAbsolute()))
                        {
                                String relativeUrl = renderRelativeUrl(url);
                                Url relative = Url.parse(relativeUrl, url.getCharset());
                                relative.setHost(url.getHost());
                                relative.setPort(url.getPort());
                                relative.setProtocol(url.getProtocol());
                                renderedUrl = renderFullUrl(relative);
                        }
                        else
                        {
                                renderedUrl = renderFullUrl(url);
                        }
                }
                else
                {
                        renderedUrl = renderRelativeUrl(url);
                }
                return renderedUrl;
        }

        /**
         * Renders a full URL in the {@code protocol://hostname:port/path} format
         *
         * @param url
         * @return rendered URL
         */
        public String renderFullUrl(final Url url)
        {
                if (url instanceof IUrlRenderer)
                {
                        IUrlRenderer renderer = (IUrlRenderer)url;
                        return renderer.renderFullUrl(url, getBaseUrl());
                }

                final String protocol = resolveProtocol(url);
                final String host = resolveHost(url);
                final Integer port = resolvePort(url);

                final StringBuilder path;
                if (url.isFull() || url.isContextAbsolute())
                {
                        path = new StringBuilder(url.canonical().toString());
                }
                else
                {
                        Url base = new Url(baseUrl);
                        base.resolveRelative(url);
                        path = new StringBuilder(base.toString());
                }

                StringBuilder render = new StringBuilder();
                if (Strings.isEmpty(protocol) == false)
                {
                        render.append(protocol);
                        render.append(':');
                }

                if (Strings.isEmpty(host) == false)
                {
                        render.append("//");
                        render.append(host);

                        if ((port != null) && !port.equals(PROTO_TO_PORT.get(protocol)))
                        {
                                render.append(':');
                                render.append(port);
                        }
                }

                if (!(url.isFull() || url.isContextAbsolute()))
                {
                        render.append(request.getContextPath());
                        render.append(request.getFilterPath());
                }
                return Strings.join("/", render.toString(), path.toString());
        }

        /**
         * Gets port that should be used to render the url
         *
         * @param url
         *            url being rendered
         * @return port or {@code null} if none is set
         */
        protected Integer resolvePort(final Url url)
        {
                return choose(url.getPort(), baseUrl.getPort(), request.getClientUrl().getPort());
        }

        /**
         * Gets the host name that should be used to render the url
         *
         * @param url
         *            url being rendered
         * @return the host name or {@code null} if none is set
         */
        protected String resolveHost(final Url url)
        {
                return choose(url.getHost(), baseUrl.getHost(), request.getClientUrl().getHost());
        }

        /**
         * Gets the protocol that should be used to render the url
         *
         * @param url
         *            url being rendered
         * @return the protocol or {@code null} if none is set
         */
        protected String resolveProtocol(final Url url)
        {
                return choose(url.getProtocol(), baseUrl.getProtocol(), request.getClientUrl()
                        .getProtocol());
        }

        /**
         * Renders the Url relative to currently set Base Url.
         *
         * This method is only intended for Wicket URLs, because the {@link Url} object represents part
         * of URL after Wicket Filter.
         *
         * For general URLs within context use {@link #renderContextRelativeUrl(String)}
         *
         * @param url
         * @return Url rendered as string
         */
        public String renderRelativeUrl(final Url url)
        {
                Args.notNull(url, "url");

                if (url instanceof IUrlRenderer)
                {
                        IUrlRenderer renderer = (IUrlRenderer)url;
                        return renderer.renderRelativeUrl(url, getBaseUrl());
                }

                List<String> baseUrlSegments =  new ArrayList<>(getBaseUrl().getSegments());
                List<String> urlSegments = new ArrayList<>(url.getSegments());

                if (!getBaseUrl().isContextRelative())
                {
                        // so we remove any possible filter/context segments
                        removeCommonPrefixes(request, baseUrlSegments);
                }
                removeCommonPrefixes(request, urlSegments);

                List<String> newSegments = new ArrayList<>();

                int common = 0;

                String last = null;

                for (String s : baseUrlSegments)
                {
                        if (!urlSegments.isEmpty() && s.equals(urlSegments.get(0)))
                        {
                                ++common;
                                last = urlSegments.remove(0);
                        }
                        else
                        {
                                break;
                        }
                }

                // we want the new URL to have at least one segment (other than possible ../)
                if ((last != null) && (urlSegments.isEmpty() || (baseUrlSegments.size() == common)))
                {
                        --common;
                        urlSegments.add(0, last);
                }

                int baseUrlSize = baseUrlSegments.size();
                if (common + 1 == baseUrlSize && urlSegments.isEmpty())
                {
                        newSegments.add(".");
                }
                else
                {
                        for (int i = common + 1; i < baseUrlSize; ++i)
                        {
                                newSegments.add("..");
                        }
                }
                newSegments.addAll(urlSegments);

                Url relativeUrl = new Url(newSegments, url.getQueryParameters());
                relativeUrl.setFragment(url.getFragment());
                String renderedUrl = relativeUrl.toString();

                // sanitize start
                if (renderedUrl.startsWith("...") || (!renderedUrl.startsWith("..") && !renderedUrl.equals(".")))
                {
                        // WICKET-4260
                        renderedUrl = "./" + renderedUrl;
                }

                // add trailing slash if the url has no query string and ends with ..
                if (renderedUrl.indexOf('?') == -1 && (renderedUrl.endsWith("..") && renderedUrl.endsWith("...") == false))
                {
                        // WICKET-4401
                        renderedUrl = renderedUrl + '/';
                }

                return renderedUrl;
        }

        /**
         * Removes common prefixes like empty first segment, context path and filter path.
         *
         * @param request
         *            the current web request
         * @param segments
         *            the segments to clean
         */
        private void removeCommonPrefixes(Request request, List<String> segments)
        {
                // try to remove context/filter path only if the Url starts with '/',
                // i.e. has an empty segment in the beginning
                if ((segments.isEmpty() || segments.get(0).isEmpty()) == false)
                {
                        return;
                }

                Url commonPrefix = Url.parse(request.getContextPath() + request.getFilterPath());
                // if both context and filter path are empty, common prefixes are empty too
                if (commonPrefix.getSegments().isEmpty())
                {
                        // WICKET-4920 and WICKET-4935
                        commonPrefix.getSegments().add("");
                }

                for (int i = 0; i < commonPrefix.getSegments().size() && i < segments.size(); i++)
                {
                        String commonPrefixSegment = Strings.stripJSessionId(commonPrefix.getSegments().get(i));
                        String segmentToClean = Strings.stripJSessionId(segments.get(i));
                        if (commonPrefixSegment.equals(segmentToClean) == false)
                        {
                                LOG.debug("Segments '{}' do not start with common prefix '{}'", segments,
                                        commonPrefix);
                                return;
                        }
                }

                for (int i = 0; i < commonPrefix.getSegments().size() && !segments.isEmpty(); i++)
                {
                        segments.remove(0);
                }
        }

        /**
         * Determines whether a URL should be rendered in its full form
         *
         * @param url
         * @return {@code true} if URL should be rendered in the full form
         */
        protected boolean shouldRenderAsFull(final Url url)
        {
                if (url.shouldRenderAsFull()) {
                        return true;
                }

                Url clientUrl = request.getClientUrl();

                if (!Strings.isEmpty(url.getProtocol()) &&
                        !url.getProtocol().equals(clientUrl.getProtocol()))
                {
                        return true;
                }
                if (!Strings.isEmpty(url.getHost()) && !url.getHost().equals(clientUrl.getHost()))
                {
                        return true;
                }
                if ((url.getPort() != null) && !url.getPort().equals(clientUrl.getPort()))
                {
                        return true;
                }
                if (url.isContextAbsolute())
                {
                        // do not relativize urls like "/a/b"
                        return true;
                }
                return false;
        }

        /**
         * Renders the URL within context relative to current base URL.
         *
         * @param url
         * @return relative URL
         */
        public String renderContextRelativeUrl(String url)
        {
                Args.notNull(url, "url");

                if (url.startsWith("/"))
                {
                        url = url.substring(1);
                }

                PrependingStringBuffer buffer = new PrependingStringBuffer(url);
                for (int i = 0; i < getBaseUrl().getSegments().size() - 1; ++i)
                {
                        buffer.prepend("../");
                }

                buffer.prepend(request.getPrefixToContextPath());

                return buffer.toString();
        }

        private static String choose(String value, final String fallback1, final String fallback2)
        {
                if (Strings.isEmpty(value))
                {
                        value = fallback1;
                        if (Strings.isEmpty(value))
                        {
                                value = fallback2;
                        }
                }
                return value;
        }

        private static Integer choose(Integer value, final Integer fallback1, final Integer fallback2)
        {
                if (value == null)
                {
                        value = fallback1;
                        if (value == null)
                        {
                                value = fallback2;
                        }
                }
                return value;
        }
}