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.core.io.Resource;
  import org.springframework.test.web.servlet.MockMvc;
  import org.springframework.test.web.servlet.setup.MockMvcBuilders;
  import org.springframework.util.StreamUtils;
  import org.springframework.web.context.WebApplicationContext;
  import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
  import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  
  import java.net.URI;
  import java.nio.charset.Charset;
  import java.time.Duration;
  
  import static de.juplo.httpresources.TestUtil.CONTENT;
  import static de.juplo.httpresources.TestUtil.read;
  import static org.junit.jupiter.api.Assertions.*;
  import static org.mockserver.model.HttpRequest.request;
  import static org.mockserver.verify.VerificationTimes.exactly;
  import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
  import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
  import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
  import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
  
  /**
   * Mostly identically with {@link HttpResourceResolverIT}.
   * Differences:Test explicit lookup with full address through context and has
   * no exclusion/inclusion.
   */
  @SpringBootTest({
      "juplo.http-resources.protocol-resolver.enabled=true",
      "juplo.http-resources.resolver.enabled=false",
      "juplo.http-resources.resolver.exclusion-patterns=**.txt" // << Not used here!
      })
  public class HttpResourceProtocolResolverIT extends IntegrationTestBase
  {
    private final static Logger LOG =
        LoggerFactory.getLogger(HttpResourceProtocolResolverIT.class);
  
  
    @Autowired
    HttpResources resources;
    @Autowired
    Cache cache;
    @Autowired
    WebApplicationContext context;
  
    @Value("classpath:remote/remote.html")
    Resource remote;
    @Value("classpath:remote/modified.html")
    Resource modified;
  
    MockMvc mvc;
  
  
    @BeforeEach
    public void setUp()
    {
      cache.clear();
      mvc = MockMvcBuilders
              .webAppContextSetup(context)
              .alwaysDo(print())
              .build();
    }
  
  
    /**
     * Olthough the {@HttpResourceResolver} is not enabled in this test-scenario,
     * this works nearly, identically to the same test there, because all lookups
     * for resources in the resource-chain for static http-resources are executed
     * through the application-context, where the
     * {@link HttpResourceProtocolResolver} is registerd.
     * Only exclusion is not working, since this is only implemented in the
     * {@HttpResourceResolver}.
     */
    @Test
    public void testResourceHandling() throws Exception
    {
      LOG.info("<-- start of test-case");
  
      mvc
          .perform(get(URI.create("http://test/foo")))
          .andExpect(status().isOk())
          .andExpect(content().contentType("application/octet-stream"))
          .andExpect(content().string("FOO\n"));
      mvc
          .perform(get(URI.create("http://test/bar")))
          .andExpect(status().isOk())
          .andExpect(content().contentType("application/octet-stream"))
         .andExpect(content().string("BAR\n"));
     mvc
         .perform(get(URI.create("http://test/hello")))
         .andExpect(status().isOk())
         .andExpect(content().contentType("application/octet-stream"))
         .andExpect(content().bytes(CONTENT));
     mvc
         .perform(get(URI.create("http://test/remote.html")))
         .andExpect(status().isOk())
         .andExpect(content().contentType("text/html"))
         .andExpect(content().bytes(StreamUtils.copyToByteArray(remote.getInputStream())));
     mvc
         .perform(get(URI.create("http://test/foobar")))
         .andExpect(status().isOk())
         .andExpect(content().contentType("application/octet-stream"))
         .andExpect(content().string("FOOBAR\n"));
     mvc
         .perform(get(URI.create("http://test/hello")))
         .andExpect(status().isOk())
         .andExpect(content().contentType("application/octet-stream"))
         .andExpect(content().bytes(CONTENT));
     mvc
         .perform(get(URI.create("http://test/hello")))
         .andExpect(status().isOk())
         .andExpect(content().contentType("application/octet-stream"))
         .andExpect(content().bytes(CONTENT));
     mvc
         .perform(get(URI.create("http://test/hello")))
         .andExpect(status().isOk())
         .andExpect(content().contentType("application/octet-stream"))
         .andExpect(content().bytes(CONTENT));
     mvc
         .perform(get(URI.create("http://test/hallo.txt")))
         .andExpect(status().isOk())
         .andExpect(content().contentType("text/plain"))
         .andExpect(content().string("welt\n"));
 
     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 = context.getResource(address("/remote.html"));
     assertNotNull(resource);
     assertTrue(resource.exists());
     String expected = StreamUtils.copyToString(remote.getInputStream(), Charset.forName("UTF-8"));
     String content = StreamUtils.copyToString(resource.getInputStream(), Charset.forName("UTF-8"));
     assertEquals(expected, content);
   }
 
   @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 = context.getResource(address("/peter.html"));
     assertNotNull(resource);
     assertFalse(resource.exists());
   }
 
   @Test
   public void testModifiedResource() throws Exception
   {
     LOG.info("<-- Start of test-case");
 
     mvc
         .perform(get(URI.create("http://test/remote.html")))
         .andExpect(status().isOk())
         .andExpect(content().string(read(remote)));
 
     CLOCK.timetravel(Duration.ofSeconds(10));
     server.when(FETCH("/remote.html")).forward(NGINX("/modified.html"));
 
     mvc
         .perform(get(URI.create("http://test/remote.html")))
             .andExpect(status().isOk())
             .andExpect(content().string(read(modified)));
 
     server.verify(FETCH("/remote.html"), exactly(2));
     server.verify(
         request()
             .withPath("/remote.html")
             .withHeader("If-Modified-Since")
             .withHeader("If-None-Match"),
         exactly(1));
   }
 
 
   @SpringBootApplication
   public static class Application implements WebMvcConfigurer
   {
     @Autowired
     ClientAndServer server;
 
     @Override
     public void addResourceHandlers(ResourceHandlerRegistry registry)
     {
       LOG.info(
           "{} resource-handler for static location {}",
           registry.hasMappingForPattern("/**") ? "Overwriting" : "Setting",
           "/**"
           );
       registry
           .addResourceHandler("/**")
           .addResourceLocations(
               "classpath:/static/",
               "classpath:/public/",
               "http://localhost:" + server.getLocalPort(),
               "classpath:/fallback/")
           .resourceChain(false);
     }
   }
 }