/*
    * ====================================================================
    * 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.IOException;
  import java.util.concurrent.Future;
  import java.util.concurrent.RejectedExecutionException;
  import java.util.concurrent.ScheduledExecutorService;
  import java.util.concurrent.atomic.AtomicReference;
  
  import org.apache.hc.client5.http.async.AsyncExecCallback;
  import org.apache.hc.client5.http.schedule.SchedulingStrategy;
  import org.apache.hc.core5.concurrent.CompletedFuture;
  import org.apache.hc.core5.http.EntityDetails;
  import org.apache.hc.core5.http.HttpException;
  import org.apache.hc.core5.http.HttpResponse;
  import org.apache.hc.core5.http.HttpStatus;
  import org.apache.hc.core5.http.nio.AsyncDataConsumer;
  import org.apache.hc.core5.util.TimeValue;
  import org.apache.hc.core5.util.Timeout;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Class used for asynchronous revalidations to be used when the {@code stale-while-revalidate}
   * directive is present
   */
  class DefaultAsyncCacheRevalidator extends CacheRevalidatorBase {
  
      private static final Logger LOG = LoggerFactory.getLogger(DefaultAsyncCacheRevalidator.class);
  
      interface RevalidationCall {
  
          void execute(AsyncExecCallback asyncExecCallback);
      }
  
      static class InternalScheduledExecutor implements ScheduledExecutor {
  
          private final ScheduledExecutor executor;
  
          InternalScheduledExecutor(final ScheduledExecutor executor) {
              this.executor = executor;
          }
  
          @Override
          public Future<?> schedule(final Runnable command, final TimeValue timeValue) throws RejectedExecutionException {
              if (timeValue.toMilliseconds() <= 0) {
                  command.run();
                  return new CompletedFuture<>(null);
              }
              return executor.schedule(command, timeValue);
          }
  
          @Override
          public void shutdown() {
              executor.shutdown();
          }
  
          @Override
          public void awaitTermination(final Timeout timeout) throws InterruptedException {
              executor.awaitTermination(timeout);
          }
  
      }
  
      /**
       * Create DefaultCacheRevalidator which will make ache revalidation requests
       * using the supplied {@link SchedulingStrategy} and {@link ScheduledExecutor}.
       */
      public DefaultAsyncCacheRevalidator(
              final ScheduledExecutor scheduledExecutor,
              final SchedulingStrategy schedulingStrategy) {
          super(new InternalScheduledExecutor(scheduledExecutor), schedulingStrategy);
      }
  
     /**
      * Create CacheValidator which will make ache revalidation requests
      * using the supplied {@link SchedulingStrategy} and {@link ScheduledExecutorService}.
      */
     public DefaultAsyncCacheRevalidator(
             final ScheduledExecutorService executorService,
             final SchedulingStrategy schedulingStrategy) {
         this(wrap(executorService), schedulingStrategy);
     }
 
     /**
      * Schedules an asynchronous re-validation
      */
     public void revalidateCacheEntry(
             final String cacheKey ,
             final AsyncExecCallback asyncExecCallback,
             final RevalidationCall call) {
         scheduleRevalidation(cacheKey, () -> call.execute(new AsyncExecCallback() {
 
             private final AtomicReference<HttpResponse> responseRef = new AtomicReference<>();
 
             @Override
             public AsyncDataConsumer handleResponse(
                     final HttpResponse response,
                     final EntityDetails entityDetails) throws HttpException, IOException {
                 responseRef.set(response);
                 return asyncExecCallback.handleResponse(response, entityDetails);
             }
 
             @Override
             public void handleInformationResponse(
                     final HttpResponse response) throws HttpException, IOException {
                 asyncExecCallback.handleInformationResponse(response);
             }
 
             @Override
             public void completed() {
                 final HttpResponse httpResponse = responseRef.getAndSet(null);
                 if (httpResponse != null && httpResponse.getCode() < HttpStatus.SC_SERVER_ERROR) {
                     jobSuccessful(cacheKey);
                 } else {
                     jobFailed(cacheKey);
                 }
                 asyncExecCallback.completed();
             }
 
             @Override
             public void failed(final Exception cause) {
                 if (cause instanceof IOException) {
                     LOG.debug("Asynchronous revalidation failed due to I/O error", cause);
                 } else if (cause instanceof HttpException) {
                     LOG.error("HTTP protocol exception during asynchronous revalidation", cause);
                 } else {
                     LOG.error("Unexpected runtime exception thrown during asynchronous revalidation", cause);
                 }
                 try {
                     jobFailed(cacheKey);
                 } finally {
                     asyncExecCallback.failed(cause);
                 }
             }
 
         }));
     }
 
 }