/*
    * ====================================================================
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
    * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   *
   */
  package org.apache.hc.client5.http.impl.cache;
  
  import java.io.InputStream;
  import java.time.Duration;
  import java.time.Instant;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.Objects;
  import java.util.Random;
  import java.util.concurrent.CountDownLatch;
  import java.util.function.Consumer;
  
  import org.apache.hc.client5.http.cache.HttpCacheEntry;
  import org.apache.hc.client5.http.cache.Resource;
  import org.apache.hc.client5.http.utils.DateUtils;
  import org.apache.hc.core5.concurrent.FutureCallback;
  import org.apache.hc.core5.http.ClassicHttpRequest;
  import org.apache.hc.core5.http.ClassicHttpResponse;
  import org.apache.hc.core5.http.Header;
  import org.apache.hc.core5.http.HttpEntity;
  import org.apache.hc.core5.http.HttpMessage;
  import org.apache.hc.core5.http.HttpRequest;
  import org.apache.hc.core5.http.HttpResponse;
  import org.apache.hc.core5.http.HttpStatus;
  import org.apache.hc.core5.http.HttpVersion;
  import org.apache.hc.core5.http.Method;
  import org.apache.hc.core5.http.ProtocolVersion;
  import org.apache.hc.core5.http.io.entity.ByteArrayEntity;
  import org.apache.hc.core5.http.message.BasicClassicHttpRequest;
  import org.apache.hc.core5.http.message.BasicClassicHttpResponse;
  import org.apache.hc.core5.http.message.BasicHeader;
  import org.apache.hc.core5.http.message.HeaderGroup;
  import org.apache.hc.core5.http.message.MessageSupport;
  import org.apache.hc.core5.util.ByteArrayBuffer;
  import org.junit.jupiter.api.Assertions;
  
  public class HttpTestUtils {
  
      /*
       * Assertions.asserts that two request or response bodies are byte-equivalent.
       */
      public static boolean equivalent(final HttpEntity e1, final HttpEntity e2) throws Exception {
          final InputStream i1 = e1.getContent();
          final InputStream i2 = e2.getContent();
          if (i1 == null && i2 == null) {
              return true;
          }
          if (i1 == null || i2 == null) {
              return false; // avoid possible NPEs below
          }
          int b1 = -1;
          while ((b1 = i1.read()) != -1) {
              if (b1 != i2.read()) {
                  return false;
              }
          }
          return (-1 == i2.read());
      }
  
      /*
       * Retrieves the full header value by combining multiple headers and
       * separating with commas, canonicalizing whitespace along the way.
       */
      public static String getCanonicalHeaderValue(final HttpMessage r, final String name) {
          final int n = r.countHeaders(name);
          r.getFirstHeader(name);
          if (n == 0) {
              return null;
          } else if (n == 1) {
              final Header h = r.getFirstHeader(name);
              return h != null ? h.getValue() : null;
          } else {
              final StringBuilder buf = new StringBuilder();
             for (final Iterator<Header> it = r.headerIterator(name); it.hasNext(); ) {
                 if (buf.length() > 0) {
                     buf.append(", ");
                 }
                 final Header header = it.next();
                 if (header != null) {
                     buf.append(header.getValue().trim());
                 }
             }
             return buf.toString();
         }
     }
 
     /*
      * Assertions.asserts that all the headers appearing in r1 also appear in r2
      * with the same canonical header values.
      */
     public static boolean isEndToEndHeaderSubset(final HttpMessage r1, final HttpMessage r2) {
         for (final Header h : r1.getHeaders()) {
             if (!MessageSupport.isHopByHop(h.getName())) {
                 final String r1val = getCanonicalHeaderValue(r1, h.getName());
                 final String r2val = getCanonicalHeaderValue(r2, h.getName());
                 if (!Objects.equals(r1val, r2val)) {
                     return false;
                 }
             }
         }
         return true;
     }
 
     /*
      * Assertions.asserts that message {@code r2} represents exactly the same
      * message as {@code r1}, except for hop-by-hop headers. "When a cache
      * is semantically transparent, the client receives exactly the same
      * response (except for hop-by-hop headers) that it would have received had
      * its request been handled directly by the origin server."
      */
     public static boolean semanticallyTransparent(
             final ClassicHttpResponse r1, final ClassicHttpResponse r2) throws Exception {
         final boolean statusLineEquivalent = Objects.equals(r1.getReasonPhrase(), r2.getReasonPhrase())
                 && r1.getCode() == r2.getCode();
         if (!statusLineEquivalent) {
             return false;
         }
         final boolean headerEquivalent = isEndToEndHeaderSubset(r1, r2);
         if (!headerEquivalent) {
             return false;
         }
         final boolean entityEquivalent = equivalent(r1.getEntity(), r2.getEntity());
         if (!entityEquivalent) {
             return false;
         }
         return true;
     }
 
     /* Assertions.asserts that protocol versions equivalent. */
     public static boolean equivalent(final ProtocolVersion v1, final ProtocolVersion v2) {
         return Objects.equals(v1 != null ? v1 : HttpVersion.DEFAULT, v2 != null ? v2 : HttpVersion.DEFAULT );
     }
 
     /* Assertions.asserts that two requests are morally equivalent. */
     public static boolean equivalent(final HttpRequest r1, final HttpRequest r2) {
         return equivalent(r1.getVersion(), r2.getVersion()) &&
                 Objects.equals(r1.getMethod(), r2.getMethod()) &&
                 Objects.equals(r1.getRequestUri(), r2.getRequestUri()) &&
                 isEndToEndHeaderSubset(r1, r2);
     }
 
     /* Assertions.asserts that two requests are morally equivalent. */
     public static boolean equivalent(final HttpResponse r1, final HttpResponse r2) {
         return equivalent(r1.getVersion(), r2.getVersion()) &&
                 r1.getCode() == r2.getCode() &&
                 Objects.equals(r1.getReasonPhrase(), r2.getReasonPhrase()) &&
                 isEndToEndHeaderSubset(r1, r2);
     }
 
     public static byte[] makeRandomBytes(final int nbytes) {
         final byte[] bytes = new byte[nbytes];
         new Random().nextBytes(bytes);
         return bytes;
     }
 
     public static Resource makeRandomResource(final int nbytes) {
         final byte[] bytes = new byte[nbytes];
         new Random().nextBytes(bytes);
         return new HeapResource(bytes);
     }
 
     public static Resource makeNullResource() {
         return null;
     }
 
     public static ByteArrayBuffer makeRandomBuffer(final int nbytes) {
         final ByteArrayBuffer buf = new ByteArrayBuffer(nbytes);
         buf.setLength(nbytes);
         new Random().nextBytes(buf.array());
         return buf;
     }
 
     /** Generates a response body with random content.
      *  @param nbytes length of the desired response body
      *  @return an {@link HttpEntity}
      */
     public static HttpEntity makeBody(final int nbytes) {
         return new ByteArrayEntity(makeRandomBytes(nbytes), null);
     }
 
     public static HeaderGroup headers(final Header... headers) {
         final HeaderGroup headerGroup = new HeaderGroup();
         if (headers != null && headers.length > 0) {
             headerGroup.setHeaders(headers);
         }
         return headerGroup;
     }
 
     public static HttpCacheEntry makeCacheEntry(final Instant requestDate,
                                                 final Instant responseDate,
                                                 final Method method,
                                                 final String requestUri,
                                                 final Header[] requestHeaders,
                                                 final int status,
                                                 final Header[] responseHeaders,
                                                 final Collection<String> variants) {
         return new HttpCacheEntry(
                 requestDate,
                 responseDate,
                 method.name(), requestUri, headers(requestHeaders),
                 status, headers(responseHeaders),
                 null,
                 variants);
     }
 
     public static HttpCacheEntry makeCacheEntry(final Instant requestDate,
                                                 final Instant responseDate,
                                                 final Method method,
                                                 final String requestUri,
                                                 final Header[] requestHeaders,
                                                 final int status,
                                                 final Header[] responseHeaders,
                                                 final Resource resource) {
         return new HttpCacheEntry(
                 requestDate,
                 responseDate,
                 method.name(), requestUri, headers(requestHeaders),
                 status, headers(responseHeaders),
                 resource,
                 null);
     }
 
     public static HttpCacheEntry makeCacheEntry(final Instant requestDate,
                                                 final Instant responseDate,
                                                 final int status,
                                                 final Header[] responseHeaders,
                                                 final Collection<String> variants) {
         return makeCacheEntry(
                 requestDate,
                 responseDate,
                 Method.GET, "/", null,
                 status, responseHeaders,
                 variants);
     }
 
     public static HttpCacheEntry makeCacheEntry(final Instant requestDate,
                                                 final Instant responseDate,
                                                 final int status,
                                                 final Header[] responseHeaders,
                                                 final Resource resource) {
         return makeCacheEntry(
                 requestDate,
                 responseDate,
                 Method.GET, "/", null,
                 status, responseHeaders,
                 resource);
     }
 
     public static Header[] getStockHeaders(final Instant when) {
         return new Header[] {
                 new BasicHeader("Date", DateUtils.formatStandardDate(when)),
                 new BasicHeader("Server", "MockServer/1.0")
         };
     }
 
     public static HttpCacheEntry makeCacheEntry(final Instant requestDate, final Instant responseDate) {
         final Duration diff = Duration.between(requestDate, responseDate);
         final Instant when = requestDate.plusMillis(diff.toMillis() / 2);
         return makeCacheEntry(requestDate, responseDate, getStockHeaders(when));
     }
 
     public static HttpCacheEntry makeCacheEntry(final Instant requestDate,
                                                 final Instant responseDate,
                                                 final Header[] headers,
                                                 final byte[] bytes) {
         return makeCacheEntry(requestDate, responseDate, HttpStatus.SC_OK, headers, new HeapResource(bytes));
     }
 
     public static HttpCacheEntry makeCacheEntry(final Instant requestDate,
                                                 final Instant responseDate,
                                                 final Header... headers) {
         return makeCacheEntry(requestDate, responseDate, headers, makeRandomBytes(128));
     }
 
     public static HttpCacheEntry makeCacheEntry(final Instant requestDate,
                                                 final Instant responseDate,
                                                 final Header[] headers,
                                                 final Collection<String> variants) {
         return makeCacheEntry(requestDate, responseDate, Method.GET, "/", null, HttpStatus.SC_OK, headers, variants);
     }
 
     public static HttpCacheEntry makeCacheEntry(final Collection<String> variants) {
         final Instant now = Instant.now();
         return makeCacheEntry(now, now, new Header[] {}, variants);
     }
 
     public static HttpCacheEntry makeCacheEntry(final Header[] headers, final byte[] bytes) {
         final Instant now = Instant.now();
         return makeCacheEntry(now, now, headers, bytes);
     }
 
     public static HttpCacheEntry makeCacheEntry(final byte[] bytes) {
         final Instant now = Instant.now();
         return makeCacheEntry(getStockHeaders(now), bytes);
     }
 
     public static HttpCacheEntry makeCacheEntry(final Header... headers) {
         return makeCacheEntry(headers, makeRandomBytes(128));
     }
 
     public static HttpCacheEntry makeCacheEntry() {
         final Instant now = Instant.now();
         return makeCacheEntry(now, now);
     }
 
     public static ClassicHttpResponse make200Response() {
         final ClassicHttpResponse out = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
         out.setHeader("Date", DateUtils.formatStandardDate(Instant.now()));
         out.setHeader("Server", "MockOrigin/1.0");
         out.setHeader("Content-Length", "128");
         out.setEntity(makeBody(128));
         return out;
     }
 
     public static final ClassicHttpResponse make200Response(final Instant date, final String cacheControl) {
         final ClassicHttpResponse response = HttpTestUtils.make200Response();
         response.setHeader("Date", DateUtils.formatStandardDate(date));
         response.setHeader("Cache-Control",cacheControl);
         response.setHeader("Etag","\"etag\"");
         return response;
     }
 
     public static ClassicHttpResponse make304Response() {
         return new BasicClassicHttpResponse(HttpStatus.SC_NOT_MODIFIED, "Not modified");
     }
 
     public static ClassicHttpRequest makeDefaultRequest() {
         return new BasicClassicHttpRequest(Method.GET.toString(), "/");
     }
 
     public static ClassicHttpRequest makeDefaultHEADRequest() {
         return new BasicClassicHttpRequest(Method.HEAD.toString(), "/");
     }
 
     public static ClassicHttpResponse make500Response() {
         return new BasicClassicHttpResponse(HttpStatus.SC_INTERNAL_SERVER_ERROR, "Internal Server Error");
     }
 
     public static <T> FutureCallback<T> countDown(final CountDownLatch latch, final Consumer<T> consumer) {
         return new FutureCallback<T>() {
 
             @Override
             public void completed(final T result) {
                 if (consumer != null) {
                     consumer.accept(result);
                 }
                 latch.countDown();
             }
 
             @Override
             public void failed(final Exception ex) {
                 latch.countDown();
                 Assertions.fail(ex);
             }
 
             @Override
             public void cancelled() {
                 latch.countDown();
                 Assertions.fail("Unexpected cancellation");
             }
 
         };
 
     }
 
     public static <T> FutureCallback<T> countDown(final CountDownLatch latch) {
         return countDown(latch, null);
     }
 
 }