package httpcorenioserver;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.util.Locale;

import config.SocketConfigurationConstants;
import org.apache.http.HttpException;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.HttpResponseInterceptor;
import org.apache.http.HttpVersion;
import org.apache.http.client.protocol.ResponseContentEncoding;
import org.apache.http.client.protocol.ResponseProcessCookies;
import org.apache.http.config.ConnectionConfig;
import org.apache.http.entity.BasicHttpEntity;
import org.apache.http.entity.ContentType;
import org.apache.http.impl.nio.DefaultHttpServerIODispatch;
import org.apache.http.impl.nio.reactor.DefaultListeningIOReactor;
import org.apache.http.impl.nio.reactor.IOReactorConfig;
import org.apache.http.message.BasicHttpResponse;
import org.apache.http.nio.ContentDecoder;
import org.apache.http.nio.ContentEncoder;
import org.apache.http.nio.IOControl;
import org.apache.http.nio.entity.NStringEntity;
import org.apache.http.nio.protocol.BasicAsyncRequestConsumer;
import org.apache.http.nio.protocol.BasicAsyncResponseProducer;
import org.apache.http.nio.protocol.HttpAsyncExchange;
import org.apache.http.nio.protocol.HttpAsyncRequestConsumer;
import org.apache.http.nio.protocol.HttpAsyncRequestHandler;
import org.apache.http.nio.protocol.HttpAsyncResponseProducer;
import org.apache.http.nio.protocol.HttpAsyncService;
import org.apache.http.nio.protocol.UriHttpAsyncRequestHandlerMapper;
import org.apache.http.nio.reactor.IOEventDispatch;
import org.apache.http.nio.reactor.ListeningIOReactor;
import org.apache.http.protocol.HttpContext;
import org.apache.http.protocol.HttpProcessor;
import org.apache.http.protocol.ImmutableHttpProcessor;
import org.apache.http.protocol.ResponseConnControl;
import org.apache.http.protocol.ResponseContent;
import org.apache.http.protocol.ResponseDate;
import org.apache.http.protocol.ResponseServer;

public class AsyncHttpCoreNIOServer
{

    public AsyncHttpCoreNIOServer() throws IOException, InterruptedException
    {
        final HttpProcessor httpproc = new ImmutableHttpProcessor(new HttpResponseInterceptor[] {
                new ResponseDate(),
                new ResponseServer("HttpCore-NIO-Test/1.1"),
                new ResponseContent(),
                new ResponseConnControl()
        });

        final UriHttpAsyncRequestHandlerMapper registry = new UriHttpAsyncRequestHandlerMapper();
        registry.register("*", new AsyncHttpHandler());

        final HttpAsyncService handler = new HttpAsyncService(httpproc, registry);

        final IOReactorConfig reactorConfig = IOReactorConfig.custom()
                .setSoReuseAddress(true)
                .setTcpNoDelay(true)
                .build();
        final ListeningIOReactor ioReactor = new DefaultListeningIOReactor(reactorConfig);
        final ConnectionConfig connectionConfig = ConnectionConfig.custom()
                .setBufferSize(8 * 1024)
                .setFragmentSizeHint(8 * 1024)
                .build();
        final IOEventDispatch ioEventDispatch = new DefaultHttpServerIODispatch(handler,
                                                                                connectionConfig);

        ioReactor.listen(new InetSocketAddress(SocketConfigurationConstants.HTTP_SERVER_PORT));
        ioReactor.execute(ioEventDispatch);
    }

    public static void main(final String[] args) throws Exception
    {
        new AsyncHttpCoreNIOServer();
    }

    class AsyncHttpHandler implements HttpAsyncRequestHandler<HttpRequest>
    {
        @Override
        public HttpAsyncRequestConsumer<HttpRequest> processRequest(
                final HttpRequest request,
                final HttpContext context) throws HttpException, IOException
        {
            Echoer echoer = new Echoer();
            context.setAttribute("echoer", echoer);
            return echoer;
        }

        @Override
        public void handle(
                final HttpRequest request,
                final HttpAsyncExchange httpexchange,
                final HttpContext context) throws HttpException, IOException
        {
            httpexchange.submitResponse((HttpAsyncResponseProducer) context.getAttribute("echoer"));
        }
    }

    class Echoer implements HttpAsyncResponseProducer, HttpAsyncRequestConsumer
    {

        private volatile HttpRequest request;
        private volatile ByteBuffer buffer = ByteBuffer.allocate(2048);

        private volatile boolean requestCompleted;
        private volatile boolean responseCompleted;


        public HttpResponse generateResponse()
        {
            System.out.println("GENERATE RESPONSE");
            HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, 200, "OK");
            BasicHttpEntity entity = new BasicHttpEntity();
            entity.setContentType("text/plain");
            entity.setChunked(false);
            entity.setContent(null);
            response.setEntity(entity);
            return response;
        }

        public void produceContent(ContentEncoder encoder, IOControl ioctrl) throws IOException
        {
            System.out.println("PRODUCE CONTENT");
            buffer.flip();
            encoder.write(buffer);
            buffer.compact();
            if (buffer.hasRemaining() && !requestCompleted)
            {
                ioctrl.requestInput();
                System.out.println(" request client input");
            }
            if (buffer.position() == 0)
            {
                if (requestCompleted)
                {
                    encoder.complete();
                    System.out.println("content fully written");
                }
                else
                {
                    // Input buffer is empty. Wait until the client fills up
                    // the buffer
                    ioctrl.suspendOutput();
                    System.out.println(" suspend origin output");
                }
            }
        }

        public void responseCompleted(HttpContext context)
        {
            System.out.println("RESPONSE COMPLETE");
            this.responseCompleted = true;
        }

        public void failed(Exception ex)
        {
            ex.printStackTrace();
        }

        public void requestReceived(HttpRequest request) throws HttpException, IOException
        {
            System.out.println("REQUEST RECEIVED");
            this.request = request;
        }

        public void consumeContent(ContentDecoder decoder, IOControl ioctrl) throws IOException
        {
            System.out.println("CONSUME CONTENT");

            decoder.read(buffer);
            if (decoder.isCompleted()) {
                System.out.println("Content fully read");
            }
            if (!buffer.hasRemaining())
            {
                ioctrl.suspendInput();
                System.out.println("suspend client input");
            }
            if (buffer.position() > 0)
            {
                System.out.println("request output");
                ioctrl.requestOutput();
            }
        }

        public void requestCompleted(HttpContext context)
        {
            System.out.println("REQUEST COMPLETED");
            requestCompleted = true;
        }

        public Exception getException()
        {
            return null;
        }

        public Object getResult()
        {
            System.out.println("GET RESULT");
            return request;
        }

        public boolean isDone()
        {
            return requestCompleted;
        }

        public void close() throws IOException
        {
            System.out.println("CLOSE");
        }
    }

}