/*
 * 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.juneau;

import static org.apache.juneau.UriRelativity.*;
import static org.apache.juneau.UriResolution.*;
import static org.apache.juneau.commons.utils.StringUtils.*;
import static org.apache.juneau.commons.utils.ThrowableUtils.*;
import static org.apache.juneau.commons.utils.Utils.*;

import java.io.*;
import java.net.*;

/**
 * Class used to create absolute and root-relative URIs based on your current URI 'location' and rules about how to
 * make such resolutions.
 *
 * <p>
 * Combines a {@link UriContext} instance with rules for resolution ({@link UriResolution} and relativity
 * ({@link UriRelativity}) to define simple {@link #resolve(Object)} and {@link #append(Appendable, Object)} methods.
 *
 * <p>
 * Three special protocols are used to represent context-root-relative, servlet-relative, and request-path-relative
 * URIs:
 *    <js>"context:"</js>, <js>"servlet:"</js>, and <js>"request:"</js>.
 *
 * <p>
 * The following list shows the protocols of URLs that can be resolved with this class:
 * <ul>
 *    <li><js>"foo://foo"</js> - Absolute URI.
 *    <li><js>"/foo"</js> - Root-relative URI.
 *    <li><js>"/"</js> - Root URI.
 *    <li><js>"context:/foo"</js> - Context-root-relative URI with path.
 *    <li><js>"context:/"</js> - Context-root URI.
 *    <li><js>"context:?foo=bar"</js> - Context-root URI with query string.
 *    <li><js>"servlet:/foo"</js> - Servlet-path-relative URI with path.
 *    <li><js>"servlet:/"</js> - Servlet-path URI.
 *    <li><js>"servlet:?foo=bar"</js> - Servlet-path URI with query string.
 *    <li><js>"request:/foo"</js> - Request-path-relative URI with path.
 *    <li><js>"request:/"</js> - Request-path URI.
 *    <li><js>"request:?foo=bar"</js> - Request-path URI with query string.
 *    <li><js>"foo"</js> - Path-info-relative URI.
 *    <li><js>""</js> - Path-info URI.
 * </ul>
 *
 */
public class UriResolver {

   /**
    * Static creator.
    *
    * @param resolution Rule on how URIs should be resolved.
    * @param relativity Rule on what relative URIs are relative to.
    * @param uriContext Current URI context (i.e. the current URI 'location').
    * @return A new {@link UriResolver} object.
    */
   public static UriResolver of(UriResolution resolution, UriRelativity relativity, UriContext uriContext) {
      return new UriResolver(resolution, relativity, uriContext);
   }

   private static boolean hasDotSegments(String s) {
      if (s == null)
         return false;
      for (var i = 0; i < s.length() - 1; i++) {
         var c = s.charAt(i);
         if ((i == 0 && c == '/') || (c == '/' && s.charAt(i + 1) == '.'))
            return true;
      }
      return false;
   }

   private static boolean isSpecialUri(String s) {
      if (s == null || s.isEmpty())
         return false;
      var c = s.charAt(0);
      if (c != 's' && c != 'c' && c != 'r')
         return false;
      return s.startsWith("servlet:") || s.startsWith("context:") || s.startsWith("request:");
   }

   private static String normalize(String s) {
      s = URI.create(s).normalize().toString();
      if (s.length() > 1 && s.charAt(s.length() - 1) == '/')
         s = s.substring(0, s.length() - 1);
      return s;
   }

   private final UriResolution resolution;

   private final UriRelativity relativity;

   private final String authority, contextRoot, servletPath, pathInfo, parentPath;

   /**
    * Constructor.
    *
    * @param resolution Rule on how URIs should be resolved.
    * @param relativity Rule on what relative URIs are relative to.
    * @param uriContext Current URI context (i.e. the current URI 'location').
    */
   public UriResolver(UriResolution resolution, UriRelativity relativity, UriContext uriContext) {
      this.resolution = resolution;
      this.relativity = relativity;
      this.authority = uriContext.authority;
      this.contextRoot = uriContext.contextRoot;
      this.servletPath = uriContext.servletPath;
      this.pathInfo = uriContext.pathInfo;
      this.parentPath = uriContext.parentPath;
   }

   /**
    * Same as {@link #resolve(Object)} except appends result to the specified appendable.
    *
    * @param a The appendable to append the URL to.
    * @param o The URI to convert to absolute form.
    * @return The same appendable passed in.
    */
   public Appendable append(Appendable a, Object o) {

      try {
         var uri = s(o);
         uri = nullIfEmpty(uri);
         var needsNormalize = hasDotSegments(uri) && nn(resolution);

         // Absolute paths are not changed.
         if (isAbsoluteUri(uri))
            return a.append(needsNormalize ? normalize(uri) : uri);
         if (resolution == NONE && ! isSpecialUri(uri))
            return a.append(emptyIfNull(uri));
         if (resolution == ROOT_RELATIVE && startsWith(uri, '/'))
            return a.append(needsNormalize ? normalize(uri) : uri);

         var a2 = needsNormalize ? new StringBuilder() : a;

         // Root-relative path
         if (startsWith(uri, '/')) {
            if (nn(authority))
               a2.append(authority);
            if (uri.length() != 1)
               a2.append(uri);
            else if (authority == null)
               a2.append('/');
         }

         // Context-relative path
         else if (nn(uri) && uri.startsWith("context:")) {
            if (resolution == ABSOLUTE && nn(authority))
               a2.append(authority);
            var hasContext = nn(contextRoot) && ! contextRoot.isEmpty();
            if (hasContext)
               a2.append('/').append(contextRoot);
            if (uri.length() > 8) {
               var remainder = uri.substring(8);
               // Skip if remainder is just "/" and something was appended OR we're at authority level with nothing else
               if (remainder.equals("/") && (hasContext || (resolution == ABSOLUTE && nn(authority)))) {
                  // Do nothing
               } else if (! remainder.isEmpty() && remainder.charAt(0) != '/' && remainder.charAt(0) != '?' && remainder.charAt(0) != '#') {
                  a2.append('/').append(remainder);
               } else {
                  a2.append(remainder);
               }
            } else if (! hasContext && (authority == null || resolution != ABSOLUTE))
               a2.append('/');
         }

         // Resource-relative path
         else if (nn(uri) && uri.startsWith("servlet:")) {
            if (resolution == ABSOLUTE && nn(authority))
               a2.append(authority);
            var hasContext = nn(contextRoot) && ! contextRoot.isEmpty();
            var hasServlet = nn(servletPath) && ! servletPath.isEmpty();
            if (hasContext)
               a2.append('/').append(contextRoot);
            if (hasServlet)
               a2.append('/').append(servletPath);
            if (uri.length() > 8) {
               var remainder = uri.substring(8);
               // Skip if remainder is just "/" and something was appended OR we're at authority level with nothing else
               if (remainder.equals("/") && (hasContext || hasServlet || (resolution == ABSOLUTE && nn(authority)))) {
                  // Do nothing
               } else if (! remainder.isEmpty() && remainder.charAt(0) != '/' && remainder.charAt(0) != '?' && remainder.charAt(0) != '#') {
                  a2.append('/').append(remainder);
               } else {
                  a2.append(remainder);
               }
            } else if (! hasServlet && ! hasContext && (authority == null || resolution != ABSOLUTE))
               a2.append('/');
         }

         // Request-relative path
         else if (nn(uri) && uri.startsWith("request:")) {
            if (resolution == ABSOLUTE && nn(authority))
               a2.append(authority);
            var hasContext = nn(contextRoot) && ! contextRoot.isEmpty();
            var hasServlet = nn(servletPath) && ! servletPath.isEmpty();
            var hasPath = nn(pathInfo) && ! pathInfo.isEmpty();
            if (hasContext)
               a2.append('/').append(contextRoot);
            if (hasServlet)
               a2.append('/').append(servletPath);
            if (hasPath)
               a2.append('/').append(pathInfo);
            if (uri.length() > 8) {
               var remainder = uri.substring(8);
               // Skip if remainder is just "/" and something was appended OR we're at authority level with nothing else
               if (remainder.equals("/") && (hasContext || hasServlet || hasPath || (resolution == ABSOLUTE && nn(authority)))) {
                  // Do nothing
               } else if (! remainder.isEmpty() && remainder.charAt(0) != '/' && remainder.charAt(0) != '?' && remainder.charAt(0) != '#') {
                  a2.append('/').append(remainder);
               } else {
                  a2.append(remainder);
               }
            } else if (! hasServlet && ! hasContext && ! hasPath && (authority == null || resolution != ABSOLUTE))
               a2.append('/');
         }

         // Relative path
         else {
            if (resolution == ABSOLUTE && nn(authority))
               a2.append(authority);
            if (nn(contextRoot))
               a2.append('/').append(contextRoot);
            if (nn(servletPath))
               a2.append('/').append(servletPath);
            if (relativity == RESOURCE && nn(uri))
               a2.append('/').append(uri);
            else if (relativity == PATH_INFO) {
               if (uri == null) {
                  if (nn(pathInfo))
                     a2.append('/').append(pathInfo);
               } else {
                  if (nn(parentPath))
                     a2.append('/').append(parentPath);
                  a2.append('/').append(uri);
               }
            } else if (uri == null && contextRoot == null && servletPath == null && (authority == null || resolution != ABSOLUTE))
               a2.append('/');
         }

         if (needsNormalize)
            a.append(normalize(a2.toString()));

         return a;
      } catch (IOException e) {
         throw toRex(e);
      }
   }

   /**
    * Relativizes a URI.
    *
    * <p>
    * Similar to {@link URI#relativize(URI)}, except supports special protocols (e.g. <js>"servlet:/"</js>) for both
    * the <c>relativeTo</c> and <c>uri</c> parameters.
    *
    * <p>
    * For example, to relativize a URI to its servlet-relative form:
    * <p class='bjava'>
    *    <jc>// relativeUri == "path/foo"</jc>
    *    String <jv>relativeUri</jv> = <jv>resolver</jv>.relativize(<js>"servlet:/"</js>, <js>"/context/servlet/path/foo"</js>);
    * </p>
    *
    * @param relativeTo The URI to relativize against.
    * @param uri The URI to relativize.
    * @return The relativized URI.
    */
   public String relativize(Object relativeTo, Object uri) {
      var r = resolve(relativeTo, ABSOLUTE);
      var s = resolve(uri, ABSOLUTE);
      return URI.create(r).relativize(URI.create(s)).toString();
   }

   /**
    * Converts the specified URI to absolute form based on values in this context.
    *
    * @param uri
    *    The URI to convert to absolute form.
    *    Can be any of the following:
    *    <ul>
    *       <li>{@link java.net.URI}
    *       <li>{@link java.net.URL}
    *       <li>{@link CharSequence}
    *    </ul>
    *    URI can be any of the following forms:
    *    <ul>
    *       <li><js>"foo://foo"</js> - Absolute URI.
    *       <li><js>"/foo"</js> - Root-relative URI.
    *       <li><js>"/"</js> - Root URI.
    *       <li><js>"context:/foo"</js> - Context-root-relative URI with path.
    *       <li><js>"context:/"</js> - Context-root URI.
    *       <li><js>"context:?foo=bar"</js> - Context-root URI with query string.
    *       <li><js>"servlet:/foo"</js> - Servlet-path-relative URI with path.
    *       <li><js>"servlet:/"</js> - Servlet-path URI.
    *       <li><js>"servlet:?foo=bar"</js> - Servlet-path URI with query string.
    *       <li><js>"request:/foo"</js> - Request-path-relative URI with path.
    *       <li><js>"request:/"</js> - Request-path URI.
    *       <li><js>"request:?foo=bar"</js> - Request-path URI with query string.
    *       <li><js>"foo"</js> - Path-info-relative URI.
    *       <li><js>""</js> - Path-info URI.
    *    </ul>
    * @return The converted URI.
    */
   public String resolve(Object uri) {
      return resolve(uri, resolution);
   }

   private String resolve(Object uri, UriResolution res) {
      var s = s(uri);
      if (isAbsoluteUri(s))
         return hasDotSegments(s) && res != NONE ? normalize(s) : s;
      if (res == ROOT_RELATIVE && startsWith(s, '/'))
         return hasDotSegments(s) ? normalize(s) : s;
      if (res == NONE && ! isSpecialUri(s))
         return s;
      return append(new StringBuilder(), s).toString();
   }
}