/*
    * Copyright 2016 The Netty Project
    *
    * The Netty Project 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.
   */
  package io.netty.handler.codec.http;
  
  import io.netty.channel.ChannelDuplexHandler;
  import io.netty.channel.ChannelFutureListener;
  import io.netty.channel.ChannelHandlerContext;
  import io.netty.channel.ChannelPipeline;
  import io.netty.channel.ChannelPromise;
  
  import static io.netty.handler.codec.http.HttpHeaders.*;
  
  /**
   * HttpServerKeepAliveHandler helps close persistent connections when appropriate.
   * <p>
   * The server channel is expected to set the proper 'Connection' header if it can handle persistent connections. {@link
   * HttpServerKeepAliveHandler} will automatically close the channel for any LastHttpContent that corresponds to a client
   * request for closing the connection, or if the HttpResponse associated with that LastHttpContent requested closing the
   * connection or didn't have a self defined message length.
   * <p>
   * Since {@link HttpServerKeepAliveHandler} expects {@link HttpObject}s it should be added after {@link HttpServerCodec}
   * but before any other handlers that might send a {@link HttpResponse}. <blockquote>
   * <pre>
   *  {@link ChannelPipeline} p = ...;
   *  ...
   *  p.addLast("serverCodec", new {@link HttpServerCodec}());
   *  p.addLast("httpKeepAlive", <b>new {@link HttpServerKeepAliveHandler}()</b>);
   *  p.addLast("aggregator", new {@link HttpObjectAggregator}(1048576));
   *  ...
   *  p.addLast("handler", new HttpRequestHandler());
   *  </pre>
   * </blockquote>
   */
  public class HttpServerKeepAliveHandler extends ChannelDuplexHandler {
      private static final String MULTIPART_PREFIX = "multipart";
  
      private boolean persistentConnection = true;
      // Track pending responses to support client pipelining: https://tools.ietf.org/html/rfc7230#section-6.3.2
      private int pendingResponses;
  
      @Override
      public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
          // read message and track if it was keepAlive
          if (msg instanceof HttpRequest) {
              final HttpRequest request = (HttpRequest) msg;
              if (persistentConnection) {
                  pendingResponses += 1;
                  persistentConnection = isKeepAlive(request);
              }
          }
          super.channelRead(ctx, msg);
      }
  
      @Override
      public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
          // modify message on way out to add headers if needed
          if (msg instanceof HttpResponse) {
              final HttpResponse response = (HttpResponse) msg;
              trackResponse(response);
              // Assume the response writer knows if they can persist or not and sets isKeepAlive on the response
              if (!isKeepAlive(response) || !isSelfDefinedMessageLength(response)) {
                  // No longer keep alive as the client can't tell when the message is done unless we close connection
                  pendingResponses = 0;
                  persistentConnection = false;
              }
              // Server might think it can keep connection alive, but we should fix response header if we know better
              if (!shouldKeepAlive()) {
                  setKeepAlive(response, false);
              }
          }
          if (msg instanceof LastHttpContent && !shouldKeepAlive()) {
              promise.addListener(ChannelFutureListener.CLOSE);
          }
          super.write(ctx, msg, promise);
      }
  
      private void trackResponse(HttpResponse response) {
          if (!isInformational(response)) {
              pendingResponses -= 1;
          }
      }
  
      private boolean shouldKeepAlive() {
          return pendingResponses != 0 || persistentConnection;
      }
  
     /**
      * Keep-alive only works if the client can detect when the message has ended without relying on the connection being
      * closed.
      * <p>
      * <ul>
      *     <li>See <a href="https://tools.ietf.org/html/rfc7230#section-6.3"/></li>
      *     <li>See <a href="https://tools.ietf.org/html/rfc7230#section-3.3.2"/></li>
      *     <li>See <a href="https://tools.ietf.org/html/rfc7230#section-3.3.3"/></li>
      * </ul>
      *
      * @param response The HttpResponse to check
      *
      * @return true if the response has a self defined message length.
      */
     private static boolean isSelfDefinedMessageLength(HttpResponse response) {
         return isContentLengthSet(response) || isTransferEncodingChunked(response) || isMultipart(response) ||
                isInformational(response) || response.getStatus().code() == HttpResponseStatus.NO_CONTENT.code();
     }
 
     private static boolean isInformational(HttpResponse response) {
         int status = response.getStatus().code();
         return status >= 100 && status <= 199;
     }
 
     private static boolean isMultipart(HttpResponse response) {
         String contentType = response.headers().get(Names.CONTENT_TYPE);
         return contentType != null &&
                contentType.regionMatches(true, 0, MULTIPART_PREFIX, 0, MULTIPART_PREFIX.length());
     }
 }