package de.juplo.httpresources;
   
   
   import static de.juplo.httpresources.ConfigurableNginxContainer.DEFAULT_NGINX_PORT;
   import static org.mockserver.model.HttpClassCallback.callback;
   import static org.mockserver.model.HttpOverrideForwardedRequest.forwardOverriddenRequest;
   import static org.mockserver.model.HttpRequest.request;
   import static org.mockserver.model.HttpResponse.response;
   
  import org.junit.jupiter.api.AfterEach;
  import org.junit.jupiter.api.BeforeEach;
  import org.mockserver.integration.ClientAndServer;
  import org.mockserver.matchers.TimeToLive;
  import org.mockserver.matchers.Times;
  import org.mockserver.mock.action.ExpectationForwardAndResponseCallback;
  import org.mockserver.model.HttpOverrideForwardedRequest;
  import org.mockserver.model.HttpRequest;
  import org.mockserver.model.HttpResponse;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.cache.Cache;
  import org.springframework.cache.concurrent.ConcurrentMapCache;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.http.HttpStatus;
  import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
  import org.springframework.util.StringUtils;
  import org.testcontainers.containers.NginxContainer;
  import org.testcontainers.containers.wait.strategy.HttpWaitStrategy;
  import org.testcontainers.shaded.org.apache.commons.lang.NotImplementedException;
  
  import java.time.*;
  import java.time.format.DateTimeFormatter;
  import java.util.Locale;
  
  
  /**
   * This class starts a
   * {@link https://www.testcontainers.org/modules/nginx/ NginX-Webserver}
   * via a {@link https://www.testcontainers.org/ Testcontainer} and a
   * standalone {@link http://www.mock-server.com/#what-is-mockserver MockServer},
   * that can be used to intercept requests for assertions / verifications.
   * <p>
   * We use the {@link
   * https://www.testcontainers.org/test_framework_integration/manual_lifecycle_control/#singleton-containers
   * Singleton Pattern} to start the NginX-Testcontainer and start the MockServer
   * programmatically via the {@link
   * http://www.mock-server.com/mock_server/running_mock_server.html#client_api
   * Client-API}.
   * @author Kai Moritz
   */
  public abstract class IntegrationTestBase
  {
    private final static Logger LOG =
        LoggerFactory.getLogger(IntegrationTestBase.class);
  
    public static ClockStub CLOCK = new ClockStub();
    public static DateTimeFormatter formatter =
        DateTimeFormatter
            .ofPattern("EEE, dd MMM yyyy HH:mm:ss z", Locale.ENGLISH)
            .withZone(ZoneId.of("GMT"));
  
    public static final NginxContainer NGINX;
  
    static
    {
      NGINX =
          new ConfigurableNginxContainer()
              .withConfiguration("src/test/resources/nginx/nginx.conf")
              .withCustomContent("src/test/resources/remote/");
      NGINX.waitingFor(new HttpWaitStrategy()).start();
    }
  
  
    public static String NGINIX_IP()
    {
      return NGINX.getContainerIpAddress();
    }
  
    public static int NGINX_PORT()
    {
      return NGINX.getMappedPort(DEFAULT_NGINX_PORT);
    }
  
    public static String NGINX_URI()
    {
      return "http://" + NGINIX_IP() + ":" + NGINX_PORT();
    }
  
    public static HttpRequest FETCH(String path)
    {
      return request().withPath(path);
    }
  
    public static HttpResponse RESPONSE()
    {
      CLOCK.tick();
      HttpResponse response =
         response().withHeader("Date", formatter.format(CLOCK.instant()));
     CLOCK.tick();
     return response;
   }
 
   public static HttpOverrideForwardedRequest NGINX()
   {
     return NGINX(null);
   }
 
   public static HttpOverrideForwardedRequest NGINX(String path)
   {
     HttpRequest request = request().withSocketAddress(NGINIX_IP(),NGINX_PORT());
     if (StringUtils.hasText(path))
       request = request.withPath(path);
     return forwardOverriddenRequest(request, RESPONSE());
   }
 
   public static HttpResponse NOT_FOUND()
   {
     return RESPONSE().withStatusCode(HttpStatus.NOT_FOUND.value());
   }
 
   public static HttpResponse INTERNAL_SERVER_ERROR()
   {
     return RESPONSE().withStatusCode(HttpStatus.INTERNAL_SERVER_ERROR.value());
   }
 
 
   @Configuration
   public static class IntegrationTestConfiguration
   {
     @Bean(destroyMethod = "stop")
     public ClientAndServer server()
     {
       return ClientAndServer.startClientAndServer();
     }
 
     @Bean
     public HttpResourceFetcher fetcher(Cache cache)
     {
       return
           new HttpResourceFetcher(
               new HttpComponentsClientHttpRequestFactory(),
               cache,
               CLOCK);
     }
 
     @Bean
     public Cache cache()
     {
       return new ConcurrentMapCache("TEST");
     }
 
     @Bean
     public HttpResources httpResources(HttpResourceFetcher fetcher)
     {
       return new HttpResources(fetcher, CLOCK);
     }
   }
 
   @Autowired
   public ClientAndServer server;
 
 
   /**
    * Prepares the mock-server to forward any request to the NginX-server,
    * for which no more specific expectation was specified.
    */
   @BeforeEach
   public void prepareMockServer()
   {
     CLOCK.now = ZonedDateTime.now();
     server
         .when(request(), Times.unlimited(), TimeToLive.unlimited(), Integer.MIN_VALUE)
         .forward(callback().withCallbackClass(Callback.class));
   }
 
   @AfterEach
   public void clearMockServer()
   {
     server.reset();
   }
 
 
   public int getMockServerPort()
   {
     return server.getLocalPort();
   }
 
   public String getMockServerUri()
   {
     return "http://localhost:" + getMockServerPort();
   }
 
 
   public String address(String path)
   {
     return getMockServerUri() + path;
   }
 
   public static class Callback implements ExpectationForwardAndResponseCallback
   {
     @Override
     public HttpRequest handle(HttpRequest request) throws Exception
     {
       return request.withSocketAddress(NGINIX_IP(),NGINX_PORT());
     }
 
     @Override
     public HttpResponse handle(HttpRequest request, HttpResponse response) throws Exception
     {
       CLOCK.tick();
       HttpResponse modifiedResponse = response.replaceHeader("Date", formatter.format(CLOCK.instant()));
       CLOCK.tick();
       return modifiedResponse;
     }
   }
 
   public static class ClockStub extends Clock
   {
     public final static Duration DEFAULT_TICK = Duration.ofMillis(100);
 
     public ZonedDateTime now = ZonedDateTime.now();
 
 
     public void tick()
     {
       now = now.plus(DEFAULT_TICK);
     }
 
     public void timetravel(Duration duration)
     {
       now = now.plus(duration);
     }
 
     @Override
     public ZoneId getZone()
     {
       return now.getZone();
     }
 
     @Override
     public Clock withZone(ZoneId zone)
     {
       throw new NotImplementedException();
     }
 
     @Override
     public Instant instant()
     {
       return now.toInstant();
     }
   };
 }