/*
    * ====================================================================
    * 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.http.impl.nio;
  
  import java.io.IOException;
  import java.nio.channels.SelectionKey;
  import java.nio.charset.CharsetDecoder;
  import java.nio.charset.CharsetEncoder;
  
  import org.apache.http.HttpEntity;
  import org.apache.http.HttpEntityEnclosingRequest;
  import org.apache.http.HttpException;
  import org.apache.http.HttpRequest;
  import org.apache.http.HttpRequestFactory;
  import org.apache.http.HttpResponse;
  import org.apache.http.annotation.NotThreadSafe;
  import org.apache.http.config.MessageConstraints;
  import org.apache.http.entity.ContentLengthStrategy;
  import org.apache.http.impl.entity.DisallowIdentityContentLengthStrategy;
  import org.apache.http.impl.entity.LaxContentLengthStrategy;
  import org.apache.http.impl.entity.StrictContentLengthStrategy;
  import org.apache.http.impl.nio.codecs.DefaultHttpRequestParser;
  import org.apache.http.impl.nio.codecs.DefaultHttpRequestParserFactory;
  import org.apache.http.impl.nio.codecs.DefaultHttpResponseWriter;
  import org.apache.http.impl.nio.codecs.DefaultHttpResponseWriterFactory;
  import org.apache.http.nio.NHttpMessageParser;
  import org.apache.http.nio.NHttpMessageParserFactory;
  import org.apache.http.nio.NHttpMessageWriter;
  import org.apache.http.nio.NHttpMessageWriterFactory;
  import org.apache.http.nio.NHttpServerConnection;
  import org.apache.http.nio.NHttpServerEventHandler;
  import org.apache.http.nio.NHttpServerIOTarget;
  import org.apache.http.nio.NHttpServiceHandler;
  import org.apache.http.nio.reactor.EventMask;
  import org.apache.http.nio.reactor.IOSession;
  import org.apache.http.nio.reactor.SessionInputBuffer;
  import org.apache.http.nio.reactor.SessionOutputBuffer;
  import org.apache.http.nio.util.ByteBufferAllocator;
  import org.apache.http.nio.util.HeapByteBufferAllocator;
  import org.apache.http.params.HttpParamConfig;
  import org.apache.http.params.HttpParams;
  import org.apache.http.util.Args;
  
  /**
   * Default implementation of the {@link NHttpServerConnection} interface.
   *
   * @since 4.0
   */
  @SuppressWarnings("deprecation")
  @NotThreadSafe
  public class DefaultNHttpServerConnection
      extends NHttpConnectionBase implements NHttpServerIOTarget {
  
      protected final NHttpMessageParser<HttpRequest> requestParser;
      protected final NHttpMessageWriter<HttpResponse> responseWriter;
  
      /**
       * Creates a new instance of this class given the underlying I/O session.
       *
       * @param session the underlying I/O session.
       * @param requestFactory HTTP request factory.
       * @param allocator byte buffer allocator.
       * @param params HTTP parameters.
       *
       * @deprecated (4.3) use {@link DefaultNHttpServerConnection#DefaultNHttpServerConnection(
       *   IOSession, int, int, ByteBufferAllocator, CharsetDecoder, CharsetEncoder,
       *   MessageConstraints, ContentLengthStrategy, ContentLengthStrategy,
       *   NHttpMessageParserFactory, NHttpMessageWriterFactory)}
       */
      @Deprecated
      public DefaultNHttpServerConnection(
              final IOSession session,
              final HttpRequestFactory requestFactory,
              final ByteBufferAllocator allocator,
             final HttpParams params) {
         super(session, allocator, params);
         Args.notNull(requestFactory, "Request factory");
         this.requestParser = createRequestParser(this.inbuf, requestFactory, params);
         this.responseWriter = createResponseWriter(this.outbuf, params);
     }
 
     /**
      * Creates new instance DefaultNHttpServerConnection given the underlying I/O session.
      *
      * @param session the underlying I/O session.
      * @param buffersize buffer size. Must be a positive number.
      * @param fragmentSizeHint fragment size hint.
      * @param allocator memory allocator.
      *   If <code>null</code> {@link HeapByteBufferAllocator#INSTANCE} will be used.
      * @param chardecoder decoder to be used for decoding HTTP protocol elements.
      *   If <code>null</code> simple type cast will be used for byte to char conversion.
      * @param charencoder encoder to be used for encoding HTTP protocol elements.
      *   If <code>null</code> simple type cast will be used for char to byte conversion.
      * @param constraints Message constraints. If <code>null</code>
      *   {@link MessageConstraints#DEFAULT} will be used.
      * @param incomingContentStrategy incoming content length strategy. If <code>null</code>
      *   {@link DisallowIdentityContentLengthStrategy#INSTANCE} will be used.
      * @param outgoingContentStrategy outgoing content length strategy. If <code>null</code>
      *   {@link StrictContentLengthStrategy#INSTANCE} will be used.
      * @param requestParserFactory request parser factory. If <code>null</code>
      *   {@link DefaultHttpRequestParserFactory#INSTANCE} will be used.
      * @param responseWriterFactory response writer factory. If <code>null</code>
      *   {@link DefaultHttpResponseWriterFactory#INSTANCE} will be used.
      *
      * @since 4.3
      */
     public DefaultNHttpServerConnection(
             final IOSession session,
             final int buffersize,
             final int fragmentSizeHint,
             final ByteBufferAllocator allocator,
             final CharsetDecoder chardecoder,
             final CharsetEncoder charencoder,
             final MessageConstraints constraints,
             final ContentLengthStrategy incomingContentStrategy,
             final ContentLengthStrategy outgoingContentStrategy,
             final NHttpMessageParserFactory<HttpRequest> requestParserFactory,
             final NHttpMessageWriterFactory<HttpResponse> responseWriterFactory) {
         super(session, buffersize, fragmentSizeHint, allocator, chardecoder, charencoder,
                 constraints,
                 incomingContentStrategy != null ? incomingContentStrategy :
                     DisallowIdentityContentLengthStrategy.INSTANCE,
                 outgoingContentStrategy != null ? outgoingContentStrategy :
                     StrictContentLengthStrategy.INSTANCE);
         this.requestParser = (requestParserFactory != null ? requestParserFactory :
             DefaultHttpRequestParserFactory.INSTANCE).create(this.inbuf, constraints);
         this.responseWriter = (responseWriterFactory != null ? responseWriterFactory :
             DefaultHttpResponseWriterFactory.INSTANCE).create(this.outbuf);
     }
 
     /**
      * @since 4.3
      */
     public DefaultNHttpServerConnection(
             final IOSession session,
             final int buffersize,
             final CharsetDecoder chardecoder,
             final CharsetEncoder charencoder,
             final MessageConstraints constraints) {
         this(session, buffersize, buffersize, null, chardecoder, charencoder, constraints,
                 null, null, null, null);
     }
 
     /**
      * @since 4.3
      */
     public DefaultNHttpServerConnection(final IOSession session, final int buffersize) {
         this(session, buffersize, buffersize, null, null, null, null, null, null, null, null);
     }
 
     /**
      * @deprecated (4.3) use constructor.
      */
     @Override
     @Deprecated
     protected ContentLengthStrategy createIncomingContentStrategy() {
         return new DisallowIdentityContentLengthStrategy(new LaxContentLengthStrategy(0));
     }
 
     /**
      * Creates an instance of {@link NHttpMessageParser} to be used
      * by this connection for parsing incoming {@link HttpRequest} messages.
      * <p>
      * This method can be overridden in a super class in order to provide
      * a different implementation of the {@link NHttpMessageParser} interface.
      *
      * @return HTTP response parser.
      *
      * @deprecated (4.3) use constructor.
      */
     @Deprecated
     protected NHttpMessageParser<HttpRequest> createRequestParser(
             final SessionInputBuffer buffer,
             final HttpRequestFactory requestFactory,
             final HttpParams params) {
         final MessageConstraints constraints = HttpParamConfig.getMessageConstraints(params);
         return new DefaultHttpRequestParser(buffer, null, requestFactory, constraints);
     }
 
     /**
      * Creates an instance of {@link NHttpMessageWriter} to be used
      * by this connection for writing out outgoing {@link HttpResponse}
      * messages.
      * <p>
      * This method can be overridden by a super class in order to provide
      * a different implementation of the {@link NHttpMessageWriter} interface.
      *
      * @return HTTP response parser.
      *
      * @deprecated (4.3) use constructor.
      */
     @Deprecated
     protected NHttpMessageWriter<HttpResponse> createResponseWriter(
             final SessionOutputBuffer buffer,
             final HttpParams params) {
         // override in derived class to specify a line formatter
         return new DefaultHttpResponseWriter(buffer, null);
     }
 
     /**
      * @since 4.2
      */
     protected void onRequestReceived(final HttpRequest request) {
     }
 
     /**
      * @since 4.2
      */
     protected void onResponseSubmitted(final HttpResponse response) {
     }
 
     public void resetInput() {
         this.request = null;
         this.contentDecoder = null;
         this.requestParser.reset();
     }
 
     public void resetOutput() {
         this.response = null;
         this.contentEncoder = null;
         this.responseWriter.reset();
     }
 
     public void consumeInput(final NHttpServerEventHandler handler) {
         if (this.status != ACTIVE) {
             this.session.clearEvent(EventMask.READ);
             return;
         }
         try {
             if (this.request == null) {
                 int bytesRead;
                 do {
                     bytesRead = this.requestParser.fillBuffer(this.session.channel());
                     if (bytesRead > 0) {
                         this.inTransportMetrics.incrementBytesTransferred(bytesRead);
                     }
                     this.request = this.requestParser.parse();
                 } while (bytesRead > 0 && this.request == null);
                 if (this.request != null) {
                     if (this.request instanceof HttpEntityEnclosingRequest) {
                         // Receive incoming entity
                         final HttpEntity entity = prepareDecoder(this.request);
                         ((HttpEntityEnclosingRequest)this.request).setEntity(entity);
                     }
                     this.connMetrics.incrementRequestCount();
                     onRequestReceived(this.request);
                     handler.requestReceived(this);
                     if (this.contentDecoder == null) {
                         // No request entity is expected
                         // Ready to receive a new request
                         resetInput();
                     }
                 }
                 if (bytesRead == -1) {
                     handler.endOfInput(this);
                 }
             }
             if (this.contentDecoder != null && (this.session.getEventMask() & SelectionKey.OP_READ) > 0) {
                 handler.inputReady(this, this.contentDecoder);
                 if (this.contentDecoder.isCompleted()) {
                     // Request entity received
                     // Ready to receive a new request
                     resetInput();
                 }
             }
         } catch (final HttpException ex) {
             resetInput();
             handler.exception(this, ex);
         } catch (final Exception ex) {
             handler.exception(this, ex);
         } finally {
             // Finally set buffered input flag
             this.hasBufferedInput = this.inbuf.hasData();
         }
     }
 
     public void produceOutput(final NHttpServerEventHandler handler) {
         try {
             if (this.status == ACTIVE) {
                 if (this.contentEncoder == null) {
                     handler.responseReady(this);
                 }
                 if (this.contentEncoder != null) {
                     handler.outputReady(this, this.contentEncoder);
                     if (this.contentEncoder.isCompleted()) {
                         resetOutput();
                     }
                 }
             }
             if (this.outbuf.hasData()) {
                 final int bytesWritten = this.outbuf.flush(this.session.channel());
                 if (bytesWritten > 0) {
                     this.outTransportMetrics.incrementBytesTransferred(bytesWritten);
                 }
             }
             if (!this.outbuf.hasData()) {
                 if (this.status == CLOSING) {
                     this.session.close();
                     this.status = CLOSED;
                     resetOutput();
                 }
                 if (this.contentEncoder == null && this.status != CLOSED) {
                     this.session.clearEvent(EventMask.WRITE);
                 }
             }
         } catch (final Exception ex) {
             handler.exception(this, ex);
         } finally {
             // Finally set the buffered output flag
             this.hasBufferedOutput = this.outbuf.hasData();
         }
     }
 
     public void submitResponse(final HttpResponse response) throws IOException, HttpException {
         Args.notNull(response, "HTTP response");
         assertNotClosed();
         if (this.response != null) {
             throw new HttpException("Response already submitted");
         }
         onResponseSubmitted(response);
         this.responseWriter.write(response);
         this.hasBufferedOutput = this.outbuf.hasData();
 
         if (response.getStatusLine().getStatusCode() >= 200) {
             this.connMetrics.incrementResponseCount();
             if (response.getEntity() != null) {
                 this.response = response;
                 prepareEncoder(response);
             }
         }
 
         this.session.setEvent(EventMask.WRITE);
     }
 
     public boolean isResponseSubmitted() {
         return this.response != null;
     }
 
     public void consumeInput(final NHttpServiceHandler handler) {
         consumeInput(new NHttpServerEventHandlerAdaptor(handler));
     }
 
     public void produceOutput(final NHttpServiceHandler handler) {
         produceOutput(new NHttpServerEventHandlerAdaptor(handler));
     }
 
 }