package de.juplo.httpresources;
   
   import org.apache.http.entity.StringEntity;
   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.boot.autoconfigure.SpringBootApplication;
  import org.springframework.boot.autoconfigure.thymeleaf.ThymeleafProperties;
  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.stereotype.Controller;
  import org.springframework.test.web.servlet.MockMvc;
  import org.springframework.test.web.servlet.setup.MockMvcBuilders;
  import org.springframework.ui.Model;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RequestParam;
  import org.springframework.web.context.WebApplicationContext;
  import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
  import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  import org.springframework.web.util.NestedServletException;
  import org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver;
  
  import java.io.IOException;
  import java.net.URI;
  import java.net.URISyntaxException;
  import java.nio.file.Files;
  import java.nio.file.Paths;
  import java.time.Duration;
  import java.util.Scanner;
  import java.util.stream.Collectors;
  
  import static org.junit.jupiter.api.Assertions.assertThrows;
  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;
  
  
  /**
   * This test-case showcases the usage of the {@link HttpResourceProtocolResolver}
   * with Thymeleaf.
   *
   * Since Thymeleaf does not use the Resource-Chain mechanism, that Spring introduced
   * for the handling of static resources, the {@code HttpResourceProtocolResolver} has
   * to be used and the protocol has to be hardwired into the configuration as
   * {@code spring.thymeleaf.prefix}.
   * The downside of this approach is, that the templates are only resolved against
   * the configured remote-URI and do not take part in the fallback-mechanism, that
   * can be configured through {@code spring.resources.static-locations}.
   *
   * The test-case was addapted accordingly, to show the changed behaviour.
   */
  @SpringBootTest({
      "juplo.http-resources.protocol-resolver.enabled=true",
      "spring.thymeleaf.cache=true" })
  public class ThymeleafWithHttpResourceProtocolResolverIT extends IntegrationTestBase
  {
    private static final Logger LOG =
        LoggerFactory.getLogger(ThymeleafWithHttpResourceProtocolResolverIT.class);
  
  
    @Autowired
    HttpResources resources;
    @Autowired
    Cache cache;
    @Autowired
    WebApplicationContext context;
  
    MockMvc mvc;
  
  
    @BeforeEach
    public void setUp()
    {
      cache.clear();
      mvc = MockMvcBuilders
          .webAppContextSetup(context)
          .alwaysDo(print())
          .build();
    }
  
  
    @Test
    public void testRenderLocalTemplate() throws Exception
    {
      LOG.info("<-- start of test-case");
  
      assertThrows(
          NestedServletException.class,
          () -> mvc.perform(get(URI.create("http://test/controller.html?template=local"))));
  
     server.verify(FETCH("/local.html"), exactly(2));
   }
 
   @Test
   public void testRenderRemoteTemplate() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     mvc
         .perform(get(URI.create("http://test/controller.html?template=remote")))
         .andExpect(status().isOk())
         .andExpect(content().string(read("/rendered/remote.html")));
 
     server.verify(FETCH("/remote.html"), exactly(1));
   }
 
   @Test
   public void testRenderCachedRemoteTemplate() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     mvc
         .perform(get(URI.create("http://test/controller.html?template=remote")))
         .andExpect(status().isOk())
         .andExpect(content().string(read("/rendered/remote.html")));
 
     mvc
         .perform(get(URI.create("http://test/controller.html?template=remote")))
         .andExpect(status().isOk())
         .andExpect(content().string(read("/rendered/remote.html")));
 
     mvc
         .perform(get(URI.create("http://test/controller.html?template=remote")))
         .andExpect(status().isOk())
         .andExpect(content().string(read("/rendered/remote.html")));
 
     mvc
         .perform(get(URI.create("http://test/controller.html?template=remote")))
         .andExpect(status().isOk())
         .andExpect(content().string(read("/rendered/remote.html")));
 
     server.verify(FETCH("/remote.html"), exactly(1));
   }
 
   @Test
   public void testRenderModifiedRemoteTemplate() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     mvc
         .perform(get(URI.create("http://test/controller.html?template=remote")))
         .andExpect(status().isOk())
         .andExpect(content().string(read("/rendered/remote.html")));
 
     CLOCK.timetravel(Duration.ofSeconds(10));
     server.when(FETCH("/remote.html")).forward(NGINX("/modified.html"));
 
     mvc
         .perform(get(URI.create("http://test/controller.html?template=remote")))
         .andExpect(status().isOk())
         .andExpect(content().string(read("/rendered/modified.html")));
 
     server.verify(FETCH("/remote.html"), exactly(2));
     server.verify(
         request()
             .withPath("/remote.html")
             .withHeader("If-Modified-Since")
             .withHeader("If-None-Match"),
         exactly(1));
   }
 
 
   @Controller
   public static class TestController
   {
 
     @RequestMapping("/controller.html")
     public String controller(
         @RequestParam String template,
         Model model
         )
     {
       model.addAttribute("template", template);
       return template;
     }
 
   }
 
 
   static StringEntity body(String resource) throws URISyntaxException, IOException
   {
     return new StringEntity(read(resource));
   }
 
   static String read(String resource) throws URISyntaxException, IOException
   {
     URI uri = ThymeleafWithHttpResourceProtocolResolverIT.class.getResource(resource).toURI();
     return Files.readAllLines(Paths.get(uri)).stream().collect(Collectors.joining("\n"));
   }
 
   static String read(Resource resource) throws URISyntaxException, IOException
   {
     Scanner s = new Scanner(resource.getInputStream()).useDelimiter("\\A");
     return s.hasNext() ? s.next() : "";
   }
 
 
   @SpringBootApplication
   public static class Application implements WebMvcConfigurer
   {
     @Autowired
     ClientAndServer server;
 
     /**
      * This mimics the autoconfiguration of Thymeleaf in Spring-Boot.
      * Reason: Found no other way to inject the property {@code spring.thymeleaf.prefix} dynamically
      */
     @Bean
     public SpringResourceTemplateResolver defaultTemplateResolver(
         ThymeleafProperties properties,
         ApplicationContext applicationContext,
         ClientAndServer server)
     {
       SpringResourceTemplateResolver resolver = new SpringResourceTemplateResolver();
       resolver.setApplicationContext(applicationContext);
       resolver.setPrefix("http://localhost:" + server.getLocalPort() + "/"); // << Cannot be passed in via properties
       resolver.setSuffix(properties.getSuffix());
       resolver.setTemplateMode(properties.getMode());
       if (properties.getEncoding() != null)
       {
         resolver.setCharacterEncoding(properties.getEncoding().name());
       }
       resolver.setCacheable(false); // << With caching enabled, the caching of HttpResources cannot be tested
       Integer order = properties.getTemplateResolverOrder();
       if (order != null)
       {
         resolver.setOrder(order);
       }
       resolver.setCheckExistence(properties.isCheckTemplate());
       return resolver;
     }
 
     @Bean
     public TestController testController()
     {
       return new TestController();
     }
 
     @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);
     }
   }
 }