package de.juplo.httpresources;
   
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.core.io.Resource;
   import org.springframework.core.io.ResourceLoader;
   
   import java.util.Arrays;
   
  public class HttpResourceChainAwareResourceLoader implements ResourceLoader
  {
    private static final Logger LOG =
        LoggerFactory.getLogger(HttpResourceChainAwareResourceLoader.class);
  
  
    private final ResourceLoader loader;
    private final String[] sources;
  
  
  
    public HttpResourceChainAwareResourceLoader(
        ResourceLoader loader,
        String... sources)
    {
      this.loader = loader;
      this.sources =
          Arrays
              .stream(sources)
              .map(location -> location.trim())
              .filter(location ->
              {
                if (location.length() > 0)
                  return true;
  
                LOG.warn("Filtered out empty entry from list of sources");
                return false;
              })
              .map(location ->
              {
                int length = location.length();
                if (length > 0 && location.charAt(length - 1) != '/')
                {
                  LOG.info("Adding trailing slash to configured source {}", location);
                  return location + "/";
                }
                else
                  return location;
              })
              .toArray(size -> new String[size]);
    }
  
  
    /**
     * Returns the first existing resource, or the first, if non of the
     * resources exists.
     *
     * This mimics the behavior of the original resolver as closeley as possible,
     * asuming, that the first source is a / the local one.
     *
     * @param location The name of the requested resource
     * @return The first existing resource, or the first resource - never <code>null</code>.
     */
    @Override
    public Resource getResource(String location)
    {
      // We assure in the constructore, that sources always end with a '/'
      String relativeResourceName =
          location.charAt(0) == '/'
              ? location.substring(1)
              : location;
  
      for (String source : sources)
      {
        Resource resource = loader.getResource(source + relativeResourceName);
  
        // Return the resource, if it exists.
        if (resource.exists())
          return resource;
      }
  
      // If all sources were checked without success, return the resource from
      // the first source, although it does not exists - the contract of an
      // {@link ResourceLoader} requires, that the return-value is neve {@code null}.
      // Therefore, we fall back to the behaviour of our parent-loader.
      return loader.getResource(location);
    }
  
    @Override
    public ClassLoader getClassLoader()
    {
      return loader.getClassLoader();
    }
  }