package de.juplo.httpresources;
   
   
   import org.junit.jupiter.api.BeforeEach;
   import org.junit.jupiter.api.Test;
   import org.mockserver.integration.ClientAndServer;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  import org.springframework.boot.test.context.SpringBootTest;
  import org.springframework.cache.Cache;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.annotation.Bean;
  import org.springframework.core.io.Resource;
  import org.springframework.util.MimeType;
  
  import java.time.Duration;
  
  import static org.assertj.core.api.Assertions.assertThat;
  import static org.junit.jupiter.api.Assertions.*;
  import static org.mockserver.model.HttpRequest.request;
  import static org.mockserver.verify.VerificationTimes.exactly;
  
  
  /**
   *
   * @author Kai Moritz
   */
  @SpringBootTest({
      "juplo.http-resources.protocol-resolver.enabled=true",
      "juplo.http-resources.resolver.enabled=false",
      "juplo.http-resources.resolver.exclusion-patterns=**.txt"
      })
  public class HttpResourceChainAwareResourceLoaderIT extends IntegrationTestBase
  {
    private final static Logger LOG =
        LoggerFactory.getLogger(HttpResourceChainAwareResourceLoaderIT.class);
  
  
    @Autowired
    HttpResourceChainAwareResourceLoader loader;
    @Autowired
    Cache cache;
    @Autowired
    HttpResources resources;
  
    @Value("classpath:static/foo")
    Resource foo;
    @Value("classpath:public/bar")
    Resource bar;
    @Value("classpath:remote/hello")
    Resource hello;
    @Value("classpath:remote/remote.html")
    Resource remote;
    @Value("classpath:remote/modified.html")
    Resource modified;
    @Value("classpath:fallback/foobar")
    Resource foobar;
    @Value("classpath:remote/hallo.txt")
    Resource hallo;
  
  
    @BeforeEach
    public void setUp()
    {
      cache.clear();
    }
  
  
    /**
     * In contrast to {@link HttpResourceResolverIT} and
     * {@link HttpResourceProtocolResolverIT} it does not
     * make sense to test through the web-layer here,
     * because the {@link HttpResourceChainAwareResourceLoader}
     * is intended to mimic the look-upp through the source,
     * that are configured for resource-chain for static
     * http-resources for the look-up of local resources.
     */
    @Test
    public void testResourceHandling() throws Exception
    {
      LOG.info("<-- start of test-case");
  
      Resource resource;
  
      resource = loader.getResource("foo");
      assertThat(resource.exists());
      assertThat(resource.getInputStream()).hasSameContentAs(foo.getInputStream());
  
      resource = loader.getResource("bar");
      assertThat(resource.exists());
      assertThat(resource.getInputStream()).hasSameContentAs(bar.getInputStream());
  
      resource = loader.getResource("hello");
      assertThat(resource.exists());
      assertThat(resource).isInstanceOf(HttpResource.class);
      assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("application/octet-stream"));
     assertThat(resource.getInputStream()).hasSameContentAs(hello.getInputStream());
 
     resource = loader.getResource("remote.html");
     assertThat(resource.exists());
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("text/html"));
     assertThat(resource.getInputStream()).hasSameContentAs(remote.getInputStream());
 
     resource = loader.getResource("foobar");
     assertThat(resource.exists());
     assertThat(resource.getInputStream()).hasSameContentAs(foobar.getInputStream());
 
     resource = loader.getResource("/hello");
     assertThat(resource.exists());
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("application/octet-stream"));
     assertThat(resource.getInputStream()).hasSameContentAs(hello.getInputStream());
 
     resource = loader.getResource("hello");
     assertThat(resource.exists());
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("application/octet-stream"));
     assertThat(resource.getInputStream()).hasSameContentAs(hello.getInputStream());
 
     resource = loader.getResource("/hello");
     assertThat(resource.exists());
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("application/octet-stream"));
     assertThat(resource.getInputStream()).hasSameContentAs(hello.getInputStream());
 
     resource = loader.getResource("hallo.txt");
     assertThat(resource.exists());
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("text/plain"));
     assertThat(resource.getInputStream()).hasSameContentAs(hallo.getInputStream());
 
     server.verify(FETCH("/foo"), exactly(0));
     server.verify(FETCH("/bar"), exactly(0));
     server.verify(FETCH("/hello"), exactly(1));
     server.verify(FETCH("/hallo.txt"), exactly(1));
     server.verify(FETCH("/remote.html"), exactly(1));
     server.verify(FETCH("/foobar"), exactly(2));
   }
 
   @Test
   public void testFetchExistent() throws Exception
   {
     LOG.info("<-- Start of test-case");
 
     getRemoteHtml();
 
     server.verify(FETCH("/remote.html"), exactly(1));
   }
 
   @Test
   public void testCachingOfExisting() throws Exception
   {
     LOG.info("<-- Start of test-case");
 
     getRemoteHtml();
     getRemoteHtml();
     getRemoteHtml();
     getRemoteHtml();
     getRemoteHtml();
     getRemoteHtml();
     getRemoteHtml();
     getRemoteHtml();
 
     server.verify(FETCH("/remote.html"), exactly(1));
   }
 
   private void getRemoteHtml() throws Exception
   {
     Resource resource = loader.getResource("/remote.html");
     assertNotNull(resource);
     assertTrue(resource.exists());
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("text/html"));
     assertThat(resource.getInputStream()).hasSameContentAs(remote.getInputStream());
   }
 
   @Test
   public void testCachingOfModified() throws Exception
   {
     LOG.info("<-- Start of test-case");
 
     Resource resource;
 
     resource = loader.getResource("/remote.html");
     assertNotNull(resource);
     assertTrue(resource.exists());
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("text/html"));
     assertThat(resource.getInputStream()).hasSameContentAs(remote.getInputStream());
 
     CLOCK.timetravel(Duration.ofSeconds(10));
     server.when(FETCH("/remote.html")).forward(NGINX("/modified.html"));
 
     resource = loader.getResource("/remote.html");
     assertNotNull(resource);
     assertTrue(resource.exists());
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("text/html"));
     assertThat(resource.getInputStream()).hasSameContentAs(modified.getInputStream());
 
     server.verify(FETCH("/remote.html"), exactly(2));
     server.verify(
         request()
             .withPath("/remote.html")
             .withHeader("If-Modified-Since")
             .withHeader("If-None-Match"),
         exactly(1));
   }
 
   @Test
   public void testFetchNonExistent() throws Exception
   {
     LOG.info("<-- Start of test-case");
 
     getNonExistingHtml();
 
     server.verify(FETCH("/peter.html"), exactly(2));
   }
 
   @Test
   public void testCachingOfNonExistent() throws Exception
   {
     LOG.info("<-- Start of test-case");
 
     getNonExistingHtml();
     getNonExistingHtml();
     getNonExistingHtml();
     getNonExistingHtml();
     getNonExistingHtml();
     getNonExistingHtml();
     getNonExistingHtml();
 
     // Remote-requests answered with 404 are repeated
     server.verify(FETCH("/peter.html"), exactly(14));
   }
 
   private void getNonExistingHtml() throws Exception
   {
     Resource resource = loader.getResource("/peter.html");
     assertNotNull(resource);
     assertFalse(resource.exists());
   }
 
   @Test
   public void testFetchServerResponse500() throws Exception
   {
     LOG.info("<-- Start of test-case");
 
     server.when(FETCH("/peter.html")).respond(INTERNAL_SERVER_ERROR());
 
     Resource resource = loader.getResource(address("/peter.html"));
 
     assertThat(resource.exists()).isFalse();
     server.verify(FETCH("/peter.html"), exactly(2));
   }
 
   @Test
   public void testCaching() throws Exception
   {
     LOG.info("<-- Start of test-case");
 
     Resource resource;
 
     LOG.debug("First access /remote.html");
     resource= loader.getResource("/remote.html");
     assertThat(resource.exists()).isTrue();
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("text/html"));
     assertThat(((HttpResource)resource).isModified()).isFalse();
     assertThat(resource.getInputStream()).hasSameContentAs(remote.getInputStream());
 
     LOG.debug("Second access to /remote.html");
     resource= loader.getResource("/remote.html");
     assertThat(resource.exists()).isTrue();
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).isModified()).isFalse();
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("text/html"));
     assertThat(resource.getInputStream()).hasSameContentAs(remote.getInputStream());
 
     LOG.debug("Third access /remote.html");
     resource= loader.getResource("/remote.html");
     assertThat(resource.exists()).isTrue();
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).isModified()).isFalse();
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("text/html"));
     assertThat(resource.getInputStream()).hasSameContentAs(remote.getInputStream());
 
     LOG.debug("First access to remote.html");
     resource= loader.getResource("remote.html");
     assertThat(resource.exists()).isTrue();
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).isModified()).isFalse();
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("text/html"));
     assertThat(resource.getInputStream()).hasSameContentAs(remote.getInputStream());
 
     LOG.debug("Fourth access to /remote.html after a pause of 10 seconds -- resource should be expired");
     CLOCK.timetravel(Duration.ofSeconds(10));
     assertThat(resource.exists()).isTrue();
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).isModified()).isFalse();
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("text/html"));
     assertThat(resource.getInputStream()).hasSameContentAs(remote.getInputStream());
 
     LOG.debug("Fifth access /remote.html");
     resource= loader.getResource("/remote.html");
     assertThat(resource.exists()).isTrue();
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).isModified()).isFalse();
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("text/html"));
     assertThat(resource.getInputStream()).hasSameContentAs(remote.getInputStream());
 
     LOG.debug("Sixth access /remote.html");
     resource= loader.getResource("/remote.html");
     assertThat(resource.exists()).isTrue();
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).isModified()).isFalse();
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("text/html"));
     assertThat(resource.getInputStream()).hasSameContentAs(remote.getInputStream());
 
     LOG.debug("Second access /remote.html");
     resource= loader.getResource("remote.html");
     assertThat(resource.exists()).isTrue();
     assertThat(resource).isInstanceOf(HttpResource.class);
     assertThat(((HttpResource)resource).isModified()).isFalse();
     assertThat(((HttpResource)resource).contentType()).isEqualTo(MimeType.valueOf("text/html"));
     assertThat(resource.getInputStream()).hasSameContentAs(remote.getInputStream());
 
     server.verify(FETCH("/remote.html"), exactly(2));
     server.verify(
         request()
             .withPath("/remote.html")
             .withHeader("If-Modified-Since")
             .withHeader("If-None-Match"),
         exactly(1));
   }
 
 
   @SpringBootApplication
   static class Application
   {
     @Bean
     public HttpResourceChainAwareResourceLoader httpResourceChainAwareResourceLoader(
         ClientAndServer server,
         ApplicationContext context)
     {
       return new HttpResourceChainAwareResourceLoader(
           context,
           new String[]
           {
               "classpath:/static/",
               "classpath:/public/",
               "http://localhost:" + server.getLocalPort(),
               "classpath:/fallback/"
           });
     }
   }
 }