/*
    * Copyright 2012 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:
    *
    *   https://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.spdy;
  
  import io.netty.channel.ChannelHandlerContext;
  import io.netty.handler.codec.MessageToMessageEncoder;
  import io.netty.handler.codec.UnsupportedMessageTypeException;
  import io.netty.handler.codec.http.FullHttpMessage;
  import io.netty.handler.codec.http.HttpContent;
  import io.netty.handler.codec.http.HttpHeaderNames;
  import io.netty.handler.codec.http.HttpHeaders;
  import io.netty.handler.codec.http.HttpMessage;
  import io.netty.handler.codec.http.HttpObject;
  import io.netty.handler.codec.http.HttpRequest;
  import io.netty.handler.codec.http.HttpResponse;
  import io.netty.handler.codec.http.LastHttpContent;
  import io.netty.util.AsciiString;
  import io.netty.util.internal.ObjectUtil;
  
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  
  /**
   * Encodes {@link HttpRequest}s, {@link HttpResponse}s, and {@link HttpContent}s
   * into {@link SpdySynStreamFrame}s and {@link SpdySynReplyFrame}s.
   *
   * <h3>Request Annotations</h3>
   *
   * SPDY specific headers must be added to {@link HttpRequest}s:
   * <table border=1>
   * <tr>
   * <th>Header Name</th><th>Header Value</th>
   * </tr>
   * <tr>
   * <td>{@code "X-SPDY-Stream-ID"}</td>
   * <td>The Stream-ID for this request.
   * Stream-IDs must be odd, positive integers, and must increase monotonically.</td>
   * </tr>
   * <tr>
   * <td>{@code "X-SPDY-Priority"}</td>
   * <td>The priority value for this request.
   * The priority should be between 0 and 7 inclusive.
   * 0 represents the highest priority and 7 represents the lowest.
   * This header is optional and defaults to 0.</td>
   * </tr>
   * </table>
   *
   * <h3>Response Annotations</h3>
   *
   * SPDY specific headers must be added to {@link HttpResponse}s:
   * <table border=1>
   * <tr>
   * <th>Header Name</th><th>Header Value</th>
   * </tr>
   * <tr>
   * <td>{@code "X-SPDY-Stream-ID"}</td>
   * <td>The Stream-ID of the request corresponding to this response.</td>
   * </tr>
   * </table>
   *
   * <h3>Pushed Resource Annotations</h3>
   *
   * SPDY specific headers must be added to pushed {@link HttpRequest}s:
   * <table border=1>
   * <tr>
   * <th>Header Name</th><th>Header Value</th>
   * </tr>
   * <tr>
   * <td>{@code "X-SPDY-Stream-ID"}</td>
   * <td>The Stream-ID for this resource.
   * Stream-IDs must be even, positive integers, and must increase monotonically.</td>
   * </tr>
   * <tr>
   * <td>{@code "X-SPDY-Associated-To-Stream-ID"}</td>
   * <td>The Stream-ID of the request that initiated this pushed resource.</td>
   * </tr>
   * <tr>
   * <td>{@code "X-SPDY-Priority"}</td>
   * <td>The priority value for this resource.
   * The priority should be between 0 and 7 inclusive.
   * 0 represents the highest priority and 7 represents the lowest.
   * This header is optional and defaults to 0.</td>
   * </tr>
   * </table>
  *
  * <h3>Required Annotations</h3>
  *
  * SPDY requires that all Requests and Pushed Resources contain
  * an HTTP "Host" header.
  *
  * <h3>Optional Annotations</h3>
  *
  * Requests and Pushed Resources must contain a SPDY scheme header.
  * This can be set via the {@code "X-SPDY-Scheme"} header but otherwise
  * defaults to "https" as that is the most common SPDY deployment.
  *
  * <h3>Chunked Content</h3>
  *
  * This encoder associates all {@link HttpContent}s that it receives
  * with the most recently received 'chunked' {@link HttpRequest}
  * or {@link HttpResponse}.
  *
  * <h3>Pushed Resources</h3>
  *
  * All pushed resources should be sent before sending the response
  * that corresponds to the initial request.
  */
 public class SpdyHttpEncoder extends MessageToMessageEncoder<HttpObject> {
 
     private int currentStreamId;
 
     private final boolean validateHeaders;
     private final boolean headersToLowerCase;
 
     /**
      * Creates a new instance.
      *
      * @param version the protocol version
      */
     public SpdyHttpEncoder(SpdyVersion version) {
         this(version, true, true);
     }
 
     /**
      * Creates a new instance.
      *
      * @param version            the protocol version
      * @param headersToLowerCase convert header names to lowercase. In a controlled environment,
      *                           one can disable the conversion.
      * @param validateHeaders    validate the header names and values when adding them to the {@link SpdyHeaders}
      */
     public SpdyHttpEncoder(SpdyVersion version, boolean headersToLowerCase, boolean validateHeaders) {
         ObjectUtil.checkNotNull(version, "version");
         this.headersToLowerCase = headersToLowerCase;
         this.validateHeaders = validateHeaders;
     }
 
     @Override
     protected void encode(ChannelHandlerContext ctx, HttpObject msg, List<Object> out) throws Exception {
 
         boolean valid = false;
         boolean last = false;
 
         if (msg instanceof HttpRequest) {
 
             HttpRequest httpRequest = (HttpRequest) msg;
             SpdySynStreamFrame spdySynStreamFrame = createSynStreamFrame(httpRequest);
             out.add(spdySynStreamFrame);
 
             last = spdySynStreamFrame.isLast() || spdySynStreamFrame.isUnidirectional();
             valid = true;
         }
         if (msg instanceof HttpResponse) {
 
             HttpResponse httpResponse = (HttpResponse) msg;
             SpdyHeadersFrame spdyHeadersFrame = createHeadersFrame(httpResponse);
             out.add(spdyHeadersFrame);
 
             last = spdyHeadersFrame.isLast();
             valid = true;
         }
         if (msg instanceof HttpContent && !last) {
 
             HttpContent chunk = (HttpContent) msg;
 
             chunk.content().retain();
             SpdyDataFrame spdyDataFrame = new DefaultSpdyDataFrame(currentStreamId, chunk.content());
             if (chunk instanceof LastHttpContent) {
                 LastHttpContent trailer = (LastHttpContent) chunk;
                 HttpHeaders trailers = trailer.trailingHeaders();
                 if (trailers.isEmpty()) {
                     spdyDataFrame.setLast(true);
                     out.add(spdyDataFrame);
                 } else {
                     // Create SPDY HEADERS frame out of trailers
                     SpdyHeadersFrame spdyHeadersFrame = new DefaultSpdyHeadersFrame(currentStreamId, validateHeaders);
                     spdyHeadersFrame.setLast(true);
                     Iterator<Entry<CharSequence, CharSequence>> itr = trailers.iteratorCharSequence();
                     while (itr.hasNext()) {
                         Map.Entry<CharSequence, CharSequence> entry = itr.next();
                         final CharSequence headerName =
                                 headersToLowerCase ? AsciiString.of(entry.getKey()).toLowerCase() : entry.getKey();
                         spdyHeadersFrame.headers().add(headerName, entry.getValue());
                     }
 
                     // Write DATA frame and append HEADERS frame
                     out.add(spdyDataFrame);
                     out.add(spdyHeadersFrame);
                 }
             } else {
                 out.add(spdyDataFrame);
             }
 
             valid = true;
         }
 
         if (!valid) {
             throw new UnsupportedMessageTypeException(msg);
         }
     }
 
     @SuppressWarnings("deprecation")
     private SpdySynStreamFrame createSynStreamFrame(HttpRequest httpRequest) throws Exception {
         // Get the Stream-ID, Associated-To-Stream-ID, Priority, and scheme from the headers
         final HttpHeaders httpHeaders = httpRequest.headers();
         int streamId = httpHeaders.getInt(SpdyHttpHeaders.Names.STREAM_ID);
         int associatedToStreamId = httpHeaders.getInt(SpdyHttpHeaders.Names.ASSOCIATED_TO_STREAM_ID, 0);
         byte priority = (byte) httpHeaders.getInt(SpdyHttpHeaders.Names.PRIORITY, 0);
         CharSequence scheme = httpHeaders.get(SpdyHttpHeaders.Names.SCHEME);
         httpHeaders.remove(SpdyHttpHeaders.Names.STREAM_ID);
         httpHeaders.remove(SpdyHttpHeaders.Names.ASSOCIATED_TO_STREAM_ID);
         httpHeaders.remove(SpdyHttpHeaders.Names.PRIORITY);
         httpHeaders.remove(SpdyHttpHeaders.Names.SCHEME);
 
         // The Connection, Keep-Alive, Proxy-Connection, and Transfer-Encoding
         // headers are not valid and MUST not be sent.
         httpHeaders.remove(HttpHeaderNames.CONNECTION);
         httpHeaders.remove("Keep-Alive");
         httpHeaders.remove("Proxy-Connection");
         httpHeaders.remove(HttpHeaderNames.TRANSFER_ENCODING);
 
         SpdySynStreamFrame spdySynStreamFrame =
                 new DefaultSpdySynStreamFrame(streamId, associatedToStreamId, priority, validateHeaders);
 
         // Unfold the first line of the message into name/value pairs
         SpdyHeaders frameHeaders = spdySynStreamFrame.headers();
         frameHeaders.set(SpdyHeaders.HttpNames.METHOD, httpRequest.method().name());
         frameHeaders.set(SpdyHeaders.HttpNames.PATH, httpRequest.uri());
         frameHeaders.set(SpdyHeaders.HttpNames.VERSION, httpRequest.protocolVersion().text());
 
         // Replace the HTTP host header with the SPDY host header
         CharSequence host = httpHeaders.get(HttpHeaderNames.HOST);
         httpHeaders.remove(HttpHeaderNames.HOST);
         frameHeaders.set(SpdyHeaders.HttpNames.HOST, host);
 
         // Set the SPDY scheme header
         if (scheme == null) {
             scheme = "https";
         }
         frameHeaders.set(SpdyHeaders.HttpNames.SCHEME, scheme);
 
         // Transfer the remaining HTTP headers
         Iterator<Entry<CharSequence, CharSequence>> itr = httpHeaders.iteratorCharSequence();
         while (itr.hasNext()) {
             Map.Entry<CharSequence, CharSequence> entry = itr.next();
             final CharSequence headerName =
                     headersToLowerCase ? AsciiString.of(entry.getKey()).toLowerCase() : entry.getKey();
             frameHeaders.add(headerName, entry.getValue());
         }
         currentStreamId = spdySynStreamFrame.streamId();
         if (associatedToStreamId == 0) {
             spdySynStreamFrame.setLast(isLast(httpRequest));
         } else {
             spdySynStreamFrame.setUnidirectional(true);
         }
 
         return spdySynStreamFrame;
     }
 
     @SuppressWarnings("deprecation")
     private SpdyHeadersFrame createHeadersFrame(HttpResponse httpResponse) throws Exception {
         // Get the Stream-ID from the headers
         final HttpHeaders httpHeaders = httpResponse.headers();
         int streamId = httpHeaders.getInt(SpdyHttpHeaders.Names.STREAM_ID);
         httpHeaders.remove(SpdyHttpHeaders.Names.STREAM_ID);
 
         // The Connection, Keep-Alive, Proxy-Connection, and Transfer-Encoding
         // headers are not valid and MUST not be sent.
         httpHeaders.remove(HttpHeaderNames.CONNECTION);
         httpHeaders.remove("Keep-Alive");
         httpHeaders.remove("Proxy-Connection");
         httpHeaders.remove(HttpHeaderNames.TRANSFER_ENCODING);
 
         SpdyHeadersFrame spdyHeadersFrame;
         if (SpdyCodecUtil.isServerId(streamId)) {
             spdyHeadersFrame = new DefaultSpdyHeadersFrame(streamId, validateHeaders);
         } else {
             spdyHeadersFrame = new DefaultSpdySynReplyFrame(streamId, validateHeaders);
         }
         SpdyHeaders frameHeaders = spdyHeadersFrame.headers();
         // Unfold the first line of the response into name/value pairs
         frameHeaders.set(SpdyHeaders.HttpNames.STATUS, httpResponse.status().codeAsText());
         frameHeaders.set(SpdyHeaders.HttpNames.VERSION, httpResponse.protocolVersion().text());
 
         // Transfer the remaining HTTP headers
         Iterator<Entry<CharSequence, CharSequence>> itr = httpHeaders.iteratorCharSequence();
         while (itr.hasNext()) {
             Map.Entry<CharSequence, CharSequence> entry = itr.next();
             final CharSequence headerName =
                     headersToLowerCase ? AsciiString.of(entry.getKey()).toLowerCase() : entry.getKey();
             spdyHeadersFrame.headers().add(headerName, entry.getValue());
         }
 
         currentStreamId = streamId;
         spdyHeadersFrame.setLast(isLast(httpResponse));
 
         return spdyHeadersFrame;
     }
 
     /**
      * Checks if the given HTTP message should be considered as a last SPDY frame.
      *
      * @param httpMessage check this HTTP message
      * @return whether the given HTTP message should generate a <em>last</em> SPDY frame.
      */
     private static boolean isLast(HttpMessage httpMessage) {
         if (httpMessage instanceof FullHttpMessage) {
             FullHttpMessage fullMessage = (FullHttpMessage) httpMessage;
             if (fullMessage.trailingHeaders().isEmpty() && !fullMessage.content().isReadable()) {
                 return true;
             }
         }
 
         return false;
     }
 }