package de.juplo.httpresources;
   
   
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.core.io.Resource;
   import org.springframework.util.Assert;
   
   import java.io.*;
  import java.net.URI;
  import java.net.URISyntaxException;
  import java.time.Clock;
  import java.util.regex.Pattern;
  
  
  /**
   *
   * @author Kai Moritz
   */
  public class HttpResources
  {
    private final static Logger LOG =
        LoggerFactory.getLogger(HttpResources.class);
    private final static Pattern RESOURCE_PATH_PATTERN =
        Pattern.compile("^http", Pattern.CASE_INSENSITIVE);
    private final static URI ABSOLUTE_PATH = URI.create("/");
  
  
    private final HttpResourceFetcher fetcher;
    private final Clock clock;
  
  
    public HttpResources(HttpResourceFetcher fetcher, Clock clock)
    {
      Assert.notNull(fetcher, "The HttpResourceFetcher must not be null");
      Assert.notNull(clock, "The Clock must not be null");
      this.fetcher = fetcher;
      this.clock = clock;
    }
  
  
    /**
     * @param uri the resource location (must be a valid <code>URI</code>)
     * @return the corresponding Resource handle (never {@code null})
     * @see {@link HttpResources#getResource(String)}
     */
    public HttpResource getResource(String uri)
    {
      return getResource(HttpResources.convert(uri));
    }
  
    /**
     * Returns the {@link HttpResource}, that represents the given {@link URI}.
  	 * <p>Note that a Resource handle does not imply an existing resource;
  	 * you need to invoke {@link Resource#exists} to check for existence.
  	 * @param uri the resource location, represented as an {@link URI}
  	 * @return the corresponding Resource handle (never {@code null})
     */
    public HttpResource getResource(URI uri)
    {
      HttpData data = fetcher.fetch(uri, HttpData.NOT_FETCHED);
      return new HttpResource(this, fetcher, clock, uri, data);
    }
  
  
    public static URI convert(String url)
    {
      return HttpResources.normalize(URI.create(url));
    }
  
    public static URI normalize(URI uri)
    {
      uri = uri.normalize();
  
      // An URI is opaque, if it is absolute and the scheme-specific part does
      // not start with a slash. A HTTP-URL cannot be opaque in this meaning!
      if (uri.isOpaque())
        throw new IllegalArgumentException("An opaque URI is no valid HTTP-URL: " + uri);
  
      String scheme = null;
      if (uri.isAbsolute())
      {
        // Enforce scheme "HTTP" or "HTTPS"
        switch (uri.getScheme().toLowerCase())
        {
          case "http":
            scheme = "http";
            break;
          case "https":
            scheme = "https";
            break;
          default:
            throw new IllegalArgumentException("Unallowed scheme: " + uri);
        }
      }
  
      String host = uri.getHost();
      String path = uri.getRawPath();
  
     if (host == null)
     {
       if (scheme != null)
         throw new IllegalArgumentException("Host is missing, although scheme is not empty: " + scheme);
     }
     else
     {
       host = host.toLowerCase();
       path = path == null || path.isEmpty() ? "/" : path;
     }
 
     try
     {
       return new URI(
           scheme,
           uri.getUserInfo(),
           host,
           uri.getPort(),
           path,
           uri.getQuery(),
           uri.getFragment()
           );
     }
     catch (URISyntaxException e)
     {
       throw new IllegalArgumentException("Invalid HTTP-URL: ", e);
     }
   }
 
   public static URI resolve(URI relative, URI uri) throws IOException
   {
     if (relative.getAuthority() != null)
       throw new IOException("URI is not relative: " + relative);
 
     URI cleaned;
     try
     {
       String path = relative.getRawPath();
       int length = path == null ? -1 : path.length();
       int i = 0;
 
       while (i < length)
       {
         switch (path.charAt(i))
         {
           case '.':
           case '/':
             i++;
             break;
           default:
             length = -1;
         }
       }
 
       cleaned = i > 0
               ? new URI(
               null,
               null,
               null,
               0,
               i == path.length() ? null : path.substring(i),
               relative.getQuery(),
               relative.getFragment()
       )
               : relative;
 
       path = uri.getPath();
       if (path == null || path.length() == 0)
         uri = uri.resolve(ABSOLUTE_PATH);
     }
     catch (URISyntaxException e)
     {
       throw new IOException("Invalid relative path: " + relative, e);
     }
 
     URI resolved = uri.resolve(cleaned);
     LOG.trace("resolved {} as {} in context {}", relative, resolved, uri);
     return resolved;
   }
 
 
   public static boolean isHttpResource(String resourcePath)
   {
     return RESOURCE_PATH_PATTERN.matcher(resourcePath).find();
   }
 }