//
   //  ========================================================================
   //  Copyright (c) 1995-2013 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;
  
  import java.nio.ByteBuffer;
  import java.util.Iterator;
  import java.util.List;
  
  import org.eclipse.jetty.client.api.ContentResponse;
  import org.eclipse.jetty.client.api.Request;
  import org.eclipse.jetty.client.api.Response;
  import org.eclipse.jetty.client.api.Result;
  import org.eclipse.jetty.http.HttpField;
  import org.eclipse.jetty.util.log.Log;
  import org.eclipse.jetty.util.log.Logger;
  
  public class ResponseNotifier
  {
      private static final Logger LOG = Log.getLogger(ResponseNotifier.class);
      private final HttpClient client;
  
      public ResponseNotifier(HttpClient client)
      {
          this.client = client;
      }
  
      @SuppressWarnings("ForLoopReplaceableByForEach")
      public void notifyBegin(List<Response.ResponseListener> listeners, Response response)
      {
          // Optimized to avoid allocations of iterator instances
          for (int i = 0; i < listeners.size(); ++i)
          {
              Response.ResponseListener listener = listeners.get(i);
              if (listener instanceof Response.BeginListener)
                  notifyBegin((Response.BeginListener)listener, response);
          }
      }
  
      private void notifyBegin(Response.BeginListener listener, Response response)
      {
          try
          {
              listener.onBegin(response);
          }
          catch (Exception x)
          {
              LOG.info("Exception while notifying listener " + listener, x);
          }
      }
  
      @SuppressWarnings("ForLoopReplaceableByForEach")
      public boolean notifyHeader(List<Response.ResponseListener> listeners, Response response, HttpField field)
      {
          boolean result = true;
          // Optimized to avoid allocations of iterator instances
          for (int i = 0; i < listeners.size(); ++i)
          {
              Response.ResponseListener listener = listeners.get(i);
              if (listener instanceof Response.HeaderListener)
                  result &= notifyHeader((Response.HeaderListener)listener, response, field);
          }
          return result;
      }
  
      private boolean notifyHeader(Response.HeaderListener listener, Response response, HttpField field)
      {
          try
          {
              return listener.onHeader(response, field);
          }
          catch (Exception x)
          {
              LOG.info("Exception while notifying listener " + listener, x);
              return false;
          }
      }
  
      @SuppressWarnings("ForLoopReplaceableByForEach")
      public void notifyHeaders(List<Response.ResponseListener> listeners, Response response)
      {
          // Optimized to avoid allocations of iterator instances
          for (int i = 0; i < listeners.size(); ++i)
          {
             Response.ResponseListener listener = listeners.get(i);
             if (listener instanceof Response.HeadersListener)
                 notifyHeaders((Response.HeadersListener)listener, response);
         }
     }
 
     private void notifyHeaders(Response.HeadersListener listener, Response response)
     {
         try
         {
             listener.onHeaders(response);
         }
         catch (Exception x)
         {
             LOG.info("Exception while notifying listener " + listener, x);
         }
     }
 
     @SuppressWarnings("ForLoopReplaceableByForEach")
     public void notifyContent(List<Response.ResponseListener> listeners, Response response, ByteBuffer buffer)
     {
         // Slice the buffer to avoid that listeners peek into data they should not look at.
         buffer = buffer.slice();
         // Optimized to avoid allocations of iterator instances
         for (int i = 0; i < listeners.size(); ++i)
         {
             Response.ResponseListener listener = listeners.get(i);
             if (listener instanceof Response.ContentListener)
             {
                 // The buffer was sliced, so we always clear it (position=0, limit=capacity)
                 // before passing it to the listener that may consume it.
                 buffer.clear();
                 notifyContent((Response.ContentListener)listener, response, buffer);
             }
         }
     }
 
     private void notifyContent(Response.ContentListener listener, Response response, ByteBuffer buffer)
     {
         try
         {
             listener.onContent(response, buffer);
         }
         catch (Exception x)
         {
             LOG.info("Exception while notifying listener " + listener, x);
         }
     }
 
     @SuppressWarnings("ForLoopReplaceableByForEach")
     public void notifySuccess(List<Response.ResponseListener> listeners, Response response)
     {
         // Optimized to avoid allocations of iterator instances
         for (int i = 0; i < listeners.size(); ++i)
         {
             Response.ResponseListener listener = listeners.get(i);
             if (listener instanceof Response.SuccessListener)
                 notifySuccess((Response.SuccessListener)listener, response);
         }
     }
 
     private void notifySuccess(Response.SuccessListener listener, Response response)
     {
         try
         {
             listener.onSuccess(response);
         }
         catch (Exception x)
         {
             LOG.info("Exception while notifying listener " + listener, x);
         }
     }
 
     @SuppressWarnings("ForLoopReplaceableByForEach")
     public void notifyFailure(List<Response.ResponseListener> listeners, Response response, Throwable failure)
     {
         // Optimized to avoid allocations of iterator instances
         for (int i = 0; i < listeners.size(); ++i)
         {
             Response.ResponseListener listener = listeners.get(i);
             if (listener instanceof Response.FailureListener)
                 notifyFailure((Response.FailureListener)listener, response, failure);
         }
     }
 
     private void notifyFailure(Response.FailureListener listener, Response response, Throwable failure)
     {
         try
         {
             listener.onFailure(response, failure);
         }
         catch (Exception x)
         {
             LOG.info("Exception while notifying listener " + listener, x);
         }
     }
 
     @SuppressWarnings("ForLoopReplaceableByForEach")
     public void notifyComplete(List<Response.ResponseListener> listeners, Result result)
     {
         // Optimized to avoid allocations of iterator instances
         for (int i = 0; i < listeners.size(); ++i)
         {
             Response.ResponseListener listener = listeners.get(i);
             if (listener instanceof Response.CompleteListener)
                 notifyComplete((Response.CompleteListener)listener, result);
         }
     }
 
     private void notifyComplete(Response.CompleteListener listener, Result result)
     {
         try
         {
             listener.onComplete(result);
         }
         catch (Exception x)
         {
             LOG.info("Exception while notifying listener " + listener, x);
         }
     }
 
     public void forwardSuccess(List<Response.ResponseListener> listeners, Response response)
     {
         notifyBegin(listeners, response);
         for (Iterator<HttpField> iterator = response.getHeaders().iterator(); iterator.hasNext();)
         {
             HttpField field = iterator.next();
             if (!notifyHeader(listeners, response, field))
                 iterator.remove();
         }
         notifyHeaders(listeners, response);
         if (response instanceof ContentResponse)
             notifyContent(listeners, response, ByteBuffer.wrap(((ContentResponse)response).getContent()));
         notifySuccess(listeners, response);
     }
 
     public void forwardSuccessComplete(List<Response.ResponseListener> listeners, Request request, Response response)
     {
         HttpConversation conversation = client.getConversation(request.getConversationID(), false);
         forwardSuccess(listeners, response);
         conversation.complete();
         notifyComplete(listeners, new Result(request, response));
     }
 
     public void forwardFailure(List<Response.ResponseListener> listeners, Response response, Throwable failure)
     {
         notifyBegin(listeners, response);
         for (Iterator<HttpField> iterator = response.getHeaders().iterator(); iterator.hasNext();)
         {
             HttpField field = iterator.next();
             if (!notifyHeader(listeners, response, field))
                 iterator.remove();
         }
         notifyHeaders(listeners, response);
         if (response instanceof ContentResponse)
             notifyContent(listeners, response, ByteBuffer.wrap(((ContentResponse)response).getContent()));
         notifyFailure(listeners, response, failure);
     }
 
     public void forwardFailureComplete(List<Response.ResponseListener> listeners, Request request, Throwable requestFailure, Response response, Throwable responseFailure)
     {
         HttpConversation conversation = client.getConversation(request.getConversationID(), false);
         forwardFailure(listeners, response, responseFailure);
         conversation.complete();
         notifyComplete(listeners, new Result(request, requestFailure, response, responseFailure));
     }
 }