//
   //  ========================================================================
   //  Copyright (c) 1995-2016 Mort Bay Consulting Pty. Ltd.
   //  ------------------------------------------------------------------------
   //  All rights reserved. This program and the accompanying materials
   //  are made available under the terms of the Eclipse Public License v1.0
   //  and Apache License v2.0 which accompanies this distribution.
   //
   //      The Eclipse Public License is available at
  //      http://www.eclipse.org/legal/epl-v10.html
  //
  //      The Apache License v2.0 is available at
  //      http://www.opensource.org/licenses/apache2.0.php
  //
  //  You may elect to redistribute this code under either of these licenses.
  //  ========================================================================
  //
  
  package org.eclipse.jetty.client.util;
  
  import java.util.concurrent.CancellationException;
  import java.util.concurrent.CountDownLatch;
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.Future;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.TimeoutException;
  
  import org.eclipse.jetty.client.HttpContentResponse;
  import org.eclipse.jetty.client.api.ContentResponse;
  import org.eclipse.jetty.client.api.Request;
  import org.eclipse.jetty.client.api.Result;
  
  /**
   * A {@link BufferingResponseListener} that is also a {@link Future}, to allow applications
   * to block (indefinitely or for a timeout) until {@link #onComplete(Result)} is called,
   * or to {@link #cancel(boolean) abort} the request/response conversation.
   * <p>
   * Typical usage is:
   * <pre>
   * Request request = httpClient.newRequest(...)...;
   * FutureResponseListener listener = new FutureResponseListener(request);
   * request.send(listener); // Asynchronous send
   * ContentResponse response = listener.get(5, TimeUnit.SECONDS); // Timed block
   * </pre>
   */
  public class FutureResponseListener extends BufferingResponseListener implements Future<ContentResponse>
  {
      private final CountDownLatch latch = new CountDownLatch(1);
      private final Request request;
      private ContentResponse response;
      private Throwable failure;
      private volatile boolean cancelled;
  
      public FutureResponseListener(Request request)
      {
          this(request, 2 * 1024 * 1024);
      }
  
      public FutureResponseListener(Request request, int maxLength)
      {
          super(maxLength);
          this.request = request;
      }
  
      public Request getRequest()
      {
          return request;
      }
  
      @Override
      public void onComplete(Result result)
      {
          response = new HttpContentResponse(result.getResponse(), getContent(), getMediaType(), getEncoding());
          failure = result.getFailure();
          latch.countDown();
      }
  
      @Override
      public boolean cancel(boolean mayInterruptIfRunning)
      {
          cancelled = true;
          return request.abort(new CancellationException());
      }
  
      @Override
      public boolean isCancelled()
      {
          return cancelled;
      }
  
      @Override
      public boolean isDone()
      {
          return latch.getCount() == 0 || isCancelled();
      }
  
      @Override
      public ContentResponse get() throws InterruptedException, ExecutionException
      {
         latch.await();
         return getResult();
     }
 
     @Override
     public ContentResponse get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException
     {
         boolean expired = !latch.await(timeout, unit);
         if (expired)
             throw new TimeoutException();
         return getResult();
     }
 
     private ContentResponse getResult() throws ExecutionException
     {
         if (isCancelled())
             throw (CancellationException)new CancellationException().initCause(failure);
         if (failure != null)
             throw new ExecutionException(failure);
         return response;
     }
 }