package de.juplo.httpresources;
   
   
   import java.time.Clock;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.boot.autoconfigure.AutoConfigureBefore;
   import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
   import org.springframework.boot.autoconfigure.web.ResourceProperties;
  import org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration;
  import org.springframework.boot.context.properties.EnableConfigurationProperties;
  import org.springframework.cache.Cache;
  import org.springframework.cache.concurrent.ConcurrentMapCache;
  import org.springframework.cache.support.NoOpCache;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.core.io.DefaultResourceLoader;
  import org.springframework.http.client.ClientHttpRequestFactory;
  
  
  /**
   * Automatic configuration
   *
   * @author Kai Moritz
   */
  @Configuration
  @EnableConfigurationProperties(HttpResourcesProperties.class)
  @AutoConfigureBefore(WebMvcAutoConfiguration.class)
  public class HttpResourcesAutoConfiguration
  {
    private static final Logger LOG =
        LoggerFactory.getLogger(HttpResourcesAutoConfiguration.class);
  
    public static final String CACHE_NAME = "http-resources-cache";
  
  
    @ConditionalOnMissingBean(Clock.class)
    @Bean
    public Clock clock()
    {
      return Clock.systemDefaultZone();
    }
  
    @ConditionalOnMissingBean(name = "sources")
    @Bean
    public String[] sources(ResourceProperties properties)
    {
      String[] sources = properties.getStaticLocations();
  
      if (sources.length == 0)
        throw new IllegalArgumentException("At least one source must be configured!");
  
      boolean hasRemoteResource = false;
      for (String source : sources)
        hasRemoteResource |= HttpResources.isHttpResource(source);
      if (!hasRemoteResource)
        LOG.warn("No remote-resource in {}", sources);
  
      return sources;
    }
  
  
    @ConditionalOnMissingBean(HttpResourceFetcher.class)
    @Bean
    public HttpResourceFetcher fetcher(
        ClientHttpRequestFactory requestFactory,
        Clock clock,
        HttpResourcesProperties properties)
    {
      LOG.info(
          "Creating bean of type HttpResourceFetcher (default-ttl={}, min-ttl={}, serve-stale={})",
          properties.defaultTTL,
          properties.minTTL,
          properties.serveStale);
  
      Cache cache;
      if (properties.cache)
      {
        LOG.info("Enable caching for HttpResources");
        cache = new ConcurrentMapCache(CACHE_NAME);
      }
      else
      {
        cache = new NoOpCache(CACHE_NAME);
      }
  
      return new HttpResourceFetcher(
          requestFactory,
          cache,
          clock,
          properties.defaultTTL,
          properties.minTTL,
          properties.serveStale);
    }
  
    @ConditionalOnMissingBean(HttpResources.class)
    @Bean
    public HttpResources httpResources(
       HttpResourceFetcher fetcher,
       Clock clock,
       HttpResourcesProperties properties
       )
   {
     LOG.info(
         "Creating bean of type HttpResources (fetcher={}, cache={})",
         properties.cache,
         fetcher);
 
     HttpResources#HttpResources">HttpResources resources = new HttpResources(fetcher, clock);
     return resources;
   }
 
   @ConditionalOnMissingBean
   @Bean
   public HttpResourceProtocolResolver httpResourceProtocolResolver(
       HttpResources resources,
       HttpResourcesProperties properties,
       DefaultResourceLoader resourceLoader
       )
   {
     LOG.info("Creating and registrating a bean of type HttpResourceProtocolResolver");
     HttpResourceProtocolResolver resolver =
         new HttpResourceProtocolResolver(resources);
     resourceLoader.addProtocolResolver(resolver);
     return resolver;
   }
 
   @ConditionalOnMissingBean
   @Bean
   public HttpResourceChainAwareResourceLoader httpResourceChainAwareResourceLoader(
       ApplicationContext context,
       String[] sources
       )
   {
     LOG.info("Creating a bean of type HttpResourceChainAwareResourceLoader");
     return new HttpResourceChainAwareResourceLoader(context, sources);
   }
 }