//
//  ========================================================================
//  Copyright (c) 1995-2014 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.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.util.concurrent.atomic.AtomicInteger;

import org.eclipse.jetty.client.security.SecurityListener;
import org.eclipse.jetty.http.HttpFields;
import org.eclipse.jetty.http.HttpHeaders;
import org.eclipse.jetty.http.HttpMethods;
import org.eclipse.jetty.http.HttpSchemes;
import org.eclipse.jetty.http.HttpURI;
import org.eclipse.jetty.http.HttpVersions;
import org.eclipse.jetty.io.Buffer;
import org.eclipse.jetty.io.BufferCache.CachedBuffer;
import org.eclipse.jetty.io.ByteArrayBuffer;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.EndPoint;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
import org.eclipse.jetty.util.thread.Timeout;

/**
 * <p>
 * An HTTP client API that encapsulates an exchange (a request and its response) with a HTTP server.
 * </p>
 *
 * This object encapsulates:
 * <ul>
 * <li>The HTTP server address, see {@link #setAddress(Address)}, or {@link #setURI(URI)}, or {@link #setURL(String)})
 * <li>The HTTP request method, URI and HTTP version (see {@link #setMethod(String)}, {@link #setRequestURI(String)}, and {@link #setVersion(int)})
 * <li>The request headers (see {@link #addRequestHeader(String, String)} or {@link #setRequestHeader(String, String)})
 * <li>The request content (see {@link #setRequestContent(Buffer)} or {@link #setRequestContentSource(InputStream)})
 * <li>The status of the exchange (see {@link #getStatus()})
 * <li>Callbacks to handle state changes (see the onXxx methods such as {@link #onRequestComplete()} or {@link #onResponseComplete()})
 * <li>The ability to intercept callbacks (see {@link #setEventListener(HttpEventListener)}
 * </ul>
 *
 * <p>
 * The HttpExchange class is intended to be used by a developer wishing to have close asynchronous interaction with the the exchange.<br />
 * Typically a developer will extend the HttpExchange class with a derived class that overrides some or all of the onXxx callbacks. <br />
 * There are also some predefined HttpExchange subtypes that can be used as a basis, see {@link org.eclipse.jetty.client.ContentExchange} and
 * {@link org.eclipse.jetty.client.CachedExchange}.
 * </p>
 *
 * <p>
 * Typically the HttpExchange is passed to the {@link HttpClient#send(HttpExchange)} method, which in turn selects a {@link HttpDestination} and calls its
 * {@link HttpDestination#send(HttpExchange)}, which then creates or selects a {@link AbstractHttpConnection} and calls its {@link AbstractHttpConnection#send(HttpExchange)}. A
 * developer may wish to directly call send on the destination or connection if they wish to bypass some handling provided (eg Cookie handling in the
 * HttpDestination).
 * </p>
 *
 * <p>
 * In some circumstances, the HttpClient or HttpDestination may wish to retry a HttpExchange (eg. failed pipeline request, authentication retry or redirection).
 * In such cases, the HttpClient and/or HttpDestination may insert their own HttpExchangeListener to intercept and filter the call backs intended for the
 * HttpExchange.
 * </p>
 */
public class HttpExchange
{
    static final Logger LOG = Log.getLogger(HttpExchange.class);

    public static final int STATUS_START = 0;
    public static final int STATUS_WAITING_FOR_CONNECTION = 1;
    public static final int STATUS_WAITING_FOR_COMMIT = 2;
    public static final int STATUS_SENDING_REQUEST = 3;
    public static final int STATUS_WAITING_FOR_RESPONSE = 4;
    public static final int STATUS_PARSING_HEADERS = 5;
    public static final int STATUS_PARSING_CONTENT = 6;
    public static final int STATUS_COMPLETED = 7;
    public static final int STATUS_EXPIRED = 8;
    public static final int STATUS_EXCEPTED = 9;
    public static final int STATUS_CANCELLING = 10;
    public static final int STATUS_CANCELLED = 11;

    // HTTP protocol fields
    private String _method = HttpMethods.GET;
    private Buffer _scheme = HttpSchemes.HTTP_BUFFER;
    private String _uri;
    private int _version = HttpVersions.HTTP_1_1_ORDINAL;
    private Address _address;
    private final HttpFields _requestFields = new HttpFields();
    private Buffer _requestContent;
    private InputStream _requestContentSource;

    private AtomicInteger _status = new AtomicInteger(STATUS_START);
    private boolean _retryStatus = false;
    // controls if the exchange will have listeners autoconfigured by the destination
    private boolean _configureListeners = true;
    private HttpEventListener _listener = new Listener();
    private volatile AbstractHttpConnection _connection;

    private Address _localAddress = null;

    // a timeout for this exchange
    private long _timeout = -1;
    private volatile Timeout.Task _timeoutTask;
    private long _lastStateChange=System.currentTimeMillis();
    private long _sent=-1;
    private int _lastState=-1;
    private int _lastStatePeriod=-1;

    boolean _onRequestCompleteDone;
    boolean _onResponseCompleteDone;
    boolean _onDone; // == onConnectionFail || onException || onExpired || onCancelled || onResponseCompleted && onRequestCompleted

    protected void expire(HttpDestination destination)
    {
        AbstractHttpConnection connection = _connection;
        if (getStatus() < HttpExchange.STATUS_COMPLETED)
            setStatus(HttpExchange.STATUS_EXPIRED);
        destination.exchangeExpired(this);
        if (connection != null)
            connection.exchangeExpired(this);
    }

    public int getStatus()
    {
        return _status.get();
    }

    /**
     * @param status
     *            the status to wait for
     * @throws InterruptedException
     *             if the waiting thread is interrupted
     * @deprecated Use {@link #waitForDone()} instead
     */
    @Deprecated
    public void waitForStatus(int status) throws InterruptedException
    {
        throw new UnsupportedOperationException();
    }

    /**
     * Wait until the exchange is "done". Done is defined as when a final state has been passed to the HttpExchange via the associated onXxx call. Note that an
     * exchange can transit a final state when being used as part of a dialog (eg {@link SecurityListener}. Done status is thus defined as:
     *
     * <pre>
     * done == onConnectionFailed || onException || onExpire || onRequestComplete &amp;&amp; onResponseComplete
     * </pre>
     *
     * @return the done status
     * @throws InterruptedException
     */
    public int waitForDone() throws InterruptedException
    {
        synchronized (this)
        {
            while (!isDone())
                this.wait();
            return _status.get();
        }
    }

    public void reset()
    {
        // TODO - this should do a cancel and wakeup everybody that was waiting.
        // might need a version number concept
        synchronized (this)
        {
            _timeoutTask = null;
            _onRequestCompleteDone = false;
            _onResponseCompleteDone = false;
            _onDone = false;
            setStatus(STATUS_START);
        }
    }

    /* ------------------------------------------------------------ */
    /**
     * @param newStatus
     * @return True if the status was actually set.
     */
    boolean setStatus(int newStatus)
    {
        boolean set = false;
        try
        {
            int oldStatus = _status.get();
            boolean ignored = false;
            if (oldStatus != newStatus)
            {
                long now = System.currentTimeMillis();
                _lastStatePeriod=(int)(now-_lastStateChange);
                _lastState=oldStatus;
                _lastStateChange=now;
                if (newStatus==STATUS_SENDING_REQUEST)
                    _sent=_lastStateChange;
            }
            
            // State machine: from which old status you can go into which new status
            switch (oldStatus)
            {
                case STATUS_START:
                    switch (newStatus)
                    {
                        case STATUS_START:
                        case STATUS_WAITING_FOR_CONNECTION:
                        case STATUS_WAITING_FOR_COMMIT:
                        case STATUS_CANCELLING:
                        case STATUS_EXCEPTED:
                            set = _status.compareAndSet(oldStatus,newStatus);
                            break;
                        case STATUS_EXPIRED:
                            set = setStatusExpired(newStatus,oldStatus);
                            break;
                    }
                    break;
                case STATUS_WAITING_FOR_CONNECTION:
                    switch (newStatus)
                    {
                        case STATUS_WAITING_FOR_COMMIT:
                        case STATUS_CANCELLING:
                        case STATUS_EXCEPTED:
                            set = _status.compareAndSet(oldStatus,newStatus);
                            break;
                        case STATUS_EXPIRED:
                            set = setStatusExpired(newStatus,oldStatus);
                            break;
                    }
                    break;
                case STATUS_WAITING_FOR_COMMIT:
                    switch (newStatus)
                    {
                        case STATUS_SENDING_REQUEST:
                        case STATUS_CANCELLING:
                        case STATUS_EXCEPTED:
                            set = _status.compareAndSet(oldStatus,newStatus);
                            break;
                        case STATUS_EXPIRED:
                            set = setStatusExpired(newStatus,oldStatus);
                            break;
                    }
                    break;
                case STATUS_SENDING_REQUEST:
                    switch (newStatus)
                    {
                        case STATUS_WAITING_FOR_RESPONSE:
                            if (set = _status.compareAndSet(oldStatus,newStatus))
                                getEventListener().onRequestCommitted();
                            break;
                        case STATUS_CANCELLING:
                        case STATUS_EXCEPTED:
                            set = _status.compareAndSet(oldStatus,newStatus);
                            break;
                        case STATUS_EXPIRED:
                            set = setStatusExpired(newStatus,oldStatus);
                            break;
                    }
                    break;
                case STATUS_WAITING_FOR_RESPONSE:
                    switch (newStatus)
                    {
                        case STATUS_PARSING_HEADERS:
                        case STATUS_CANCELLING:
                        case STATUS_EXCEPTED:
                            set = _status.compareAndSet(oldStatus,newStatus);
                            break;
                        case STATUS_EXPIRED:
                            set = setStatusExpired(newStatus,oldStatus);
                            break;
                    }
                    break;
                case STATUS_PARSING_HEADERS:
                    switch (newStatus)
                    {
                        case STATUS_PARSING_CONTENT:
                            if (set = _status.compareAndSet(oldStatus,newStatus))
                                getEventListener().onResponseHeaderComplete();
                            break;
                        case STATUS_CANCELLING:
                        case STATUS_EXCEPTED:
                            set = _status.compareAndSet(oldStatus,newStatus);
                            break;
                        case STATUS_EXPIRED:
                            set = setStatusExpired(newStatus,oldStatus);
                            break;
                    }
                    break;
                case STATUS_PARSING_CONTENT:
                    switch (newStatus)
                    {
                        case STATUS_COMPLETED:
                            if (set = _status.compareAndSet(oldStatus,newStatus))
                                getEventListener().onResponseComplete();
                            break;
                        case STATUS_CANCELLING:
                        case STATUS_EXCEPTED:
                            set = _status.compareAndSet(oldStatus,newStatus);
                            break;
                        case STATUS_EXPIRED:
                            set = setStatusExpired(newStatus,oldStatus);
                            break;
                    }
                    break;
                case STATUS_COMPLETED:
                    switch (newStatus)
                    {
                        case STATUS_START:
                        case STATUS_EXCEPTED:
                        case STATUS_WAITING_FOR_RESPONSE:
                            set = _status.compareAndSet(oldStatus,newStatus);
                            break;
                        case STATUS_CANCELLING:
                        case STATUS_EXPIRED:
                            // Don't change the status, it's too late
                            ignored = true;
                            break;
                    }
                    break;
                case STATUS_CANCELLING:
                    switch (newStatus)
                    {
                        case STATUS_EXCEPTED:
                        case STATUS_CANCELLED:
                            if (set = _status.compareAndSet(oldStatus,newStatus))
                                done();
                            break;
                        default:
                            // Ignore other statuses, we're cancelling
                            ignored = true;
                            break;
                    }
                    break;
                case STATUS_EXCEPTED:
                case STATUS_EXPIRED:
                case STATUS_CANCELLED:
                    switch (newStatus)
                    {
                        case STATUS_START:
                            set = _status.compareAndSet(oldStatus,newStatus);
                            break;
                            
                        case STATUS_COMPLETED:
                            ignored = true;
                            done();
                            break; 
                            
                        default:
                            ignored = true;
                            break;
                    }
                    break;
                default:
                    // Here means I allowed to set a state that I don't recognize
                    throw new AssertionError(oldStatus + " => " + newStatus);
            }

            if (!set && !ignored)
                throw new IllegalStateException(toState(oldStatus) + " => " + toState(newStatus));
            LOG.debug("setStatus {} {}",newStatus,this);
        }
        catch (IOException x)
        {
            LOG.warn(x);
        }
        return set;
    }

    private boolean setStatusExpired(int newStatus, int oldStatus)
    {
        boolean set;
        if (set = _status.compareAndSet(oldStatus,newStatus))
            getEventListener().onExpire();
        return set;
    }

    public boolean isDone()
    {
        synchronized (this)
        {
            return _onDone;
        }
    }

    /**
     * @deprecated
     */
    @Deprecated
    public boolean isDone(int status)
    {
        return isDone();
    }

    public HttpEventListener getEventListener()
    {
        return _listener;
    }

    public void setEventListener(HttpEventListener listener)
    {
        _listener = listener;
    }

    public void setTimeout(long timeout)
    {
        _timeout = timeout;
    }

    public long getTimeout()
    {
        return _timeout;
    }

    /**
     * @param url
     *            an absolute URL (for example 'http://localhost/foo/bar?a=1')
     */
    public void setURL(String url)
    {
        setURI(URI.create(url));
    }

    /**
     * @param address
     *            the address of the server
     */
    public void setAddress(Address address)
    {
        _address = address;
    }

    /**
     * @return the address of the server
     */
    public Address getAddress()
    {
        return _address;
    }

    /**
     * the local address used by the connection
     *
     * Note: this method will not be populated unless the exchange has been executed by the HttpClient
     *
     * @return the local address used for the running of the exchange if available, null otherwise.
     */
    public Address getLocalAddress()
    {
        return _localAddress;
    }

    /**
     * @param scheme
     *            the scheme of the URL (for example 'http')
     */
    public void setScheme(Buffer scheme)
    {
        _scheme = scheme;
    }

    /**
     * @param scheme
     *            the scheme of the URL (for example 'http')
     */
    public void setScheme(String scheme)
    {
        if (scheme != null)
        {
            if (HttpSchemes.HTTP.equalsIgnoreCase(scheme))
                setScheme(HttpSchemes.HTTP_BUFFER);
            else if (HttpSchemes.HTTPS.equalsIgnoreCase(scheme))
                setScheme(HttpSchemes.HTTPS_BUFFER);
            else
                setScheme(new ByteArrayBuffer(scheme));
        }
    }

    /**
     * @return the scheme of the URL
     */
    public Buffer getScheme()
    {
        return _scheme;
    }

    /**
     * @param version
     *            the HTTP protocol version as integer, 9, 10 or 11 for 0.9, 1.0 or 1.1
     */
    public void setVersion(int version)
    {
        _version = version;
    }

    /**
     * @param version
     *            the HTTP protocol version as string
     */
    public void setVersion(String version)
    {
        CachedBuffer v = HttpVersions.CACHE.get(version);
        if (v == null)
            _version = 10;
        else
            _version = v.getOrdinal();
    }

    /**
     * @return the HTTP protocol version as integer
     * @see #setVersion(int)
     */
    public int getVersion()
    {
        return _version;
    }

    /**
     * @param method
     *            the HTTP method (for example 'GET')
     */
    public void setMethod(String method)
    {
        _method = method;
    }

    /**
     * @return the HTTP method
     */
    public String getMethod()
    {
        return _method;
    }

    /**
     * @return request URI
     * @see #getRequestURI()
     * @deprecated
     */
    @Deprecated
    public String getURI()
    {
        return getRequestURI();
    }

    /**
     * @return request URI
     */
    public String getRequestURI()
    {
        return _uri;
    }

    /**
     * Set the request URI
     *
     * @param uri
     *            new request URI
     * @see #setRequestURI(String)
     * @deprecated
     */
    @Deprecated
    public void setURI(String uri)
    {
        setRequestURI(uri);
    }

    /**
     * Set the request URI
     *
     * Per RFC 2616 sec5, Request-URI = "*" | absoluteURI | abs_path | authority<br/>
     * where:<br/>
     * <br/>
     * "*" - request applies to server itself<br/>
     * absoluteURI - required for proxy requests, e.g. http://localhost:8080/context<br/>
     * (this form is generated automatically by HttpClient)<br/>
     * abs_path - used for most methods, e.g. /context<br/>
     * authority - used for CONNECT method only, e.g. localhost:8080<br/>
     * <br/>
     * For complete definition of URI components, see RFC 2396 sec3.<br/>
     *
     * @param uri
     *            new request URI
     */
    public void setRequestURI(String uri)
    {
        _uri = uri;
    }

    /* ------------------------------------------------------------ */
    /**
     * @param uri
     *            an absolute URI (for example 'http://localhost/foo/bar?a=1')
     */
    public void setURI(URI uri)
    {
        if (!uri.isAbsolute())
            throw new IllegalArgumentException("!Absolute URI: " + uri);

        if (uri.isOpaque())
            throw new IllegalArgumentException("Opaque URI: " + uri);

        if (LOG.isDebugEnabled())
            LOG.debug("URI = {}",uri.toASCIIString());

        String scheme = uri.getScheme();
        int port = uri.getPort();
        if (port <= 0)
            port = "https".equalsIgnoreCase(scheme)?443:80;

        setScheme(scheme);
        setAddress(new Address(uri.getHost(),port));

        HttpURI httpUri = new HttpURI(uri);
        String completePath = httpUri.getCompletePath();
        setRequestURI(completePath == null?"/":completePath);
    }

    /**
     * Adds the specified request header
     *
     * @param name
     *            the header name
     * @param value
     *            the header value
     */
    public void addRequestHeader(String name, String value)
    {
        getRequestFields().add(name,value);
    }

    /**
     * Adds the specified request header
     *
     * @param name
     *            the header name
     * @param value
     *            the header value
     */
    public void addRequestHeader(Buffer name, Buffer value)
    {
        getRequestFields().add(name,value);
    }

    /**
     * Sets the specified request header
     *
     * @param name
     *            the header name
     * @param value
     *            the header value
     */
    public void setRequestHeader(String name, String value)
    {
        getRequestFields().put(name,value);
    }

    /**
     * Sets the specified request header
     *
     * @param name
     *            the header name
     * @param value
     *            the header value
     */
    public void setRequestHeader(Buffer name, Buffer value)
    {
        getRequestFields().put(name,value);
    }

    /**
     * @param value
     *            the content type of the request
     */
    public void setRequestContentType(String value)
    {
        getRequestFields().put(HttpHeaders.CONTENT_TYPE_BUFFER,value);
    }

    /**
     * @return the request headers
     */
    public HttpFields getRequestFields()
    {
        return _requestFields;
    }

    /**
     * @param requestContent
     *            the request content
     */
    public void setRequestContent(Buffer requestContent)
    {
        _requestContent = requestContent;
    }

    /**
     * @param stream
     *            the request content as a stream
     */
    public void setRequestContentSource(InputStream stream)
    {
        _requestContentSource = stream;
        if (_requestContentSource != null && _requestContentSource.markSupported())
            _requestContentSource.mark(Integer.MAX_VALUE);
    }

    /**
     * @return the request content as a stream
     */
    public InputStream getRequestContentSource()
    {
        return _requestContentSource;
    }

    public Buffer getRequestContentChunk(Buffer buffer) throws IOException
    {
        synchronized (this)
        {
            if (_requestContentSource!=null)
            {
                if (buffer == null)
                    buffer = new ByteArrayBuffer(8192); // TODO configure

                int space = buffer.space();
                int length = _requestContentSource.read(buffer.array(),buffer.putIndex(),space);
                if (length >= 0)
                {
                    buffer.setPutIndex(buffer.putIndex()+length);
                    return buffer;
                }
            }
            return null;
        }
    }

    /**
     * @return the request content
     */
    public Buffer getRequestContent()
    {
        return _requestContent;
    }

    /**
     * @return whether a retry will be attempted or not
     */
    public boolean getRetryStatus()
    {
        return _retryStatus;
    }

    /**
     * @param retryStatus
     *            whether a retry will be attempted or not
     */
    public void setRetryStatus(boolean retryStatus)
    {
        _retryStatus = retryStatus;
    }

    /**
     * Initiates the cancelling of this exchange. The status of the exchange is set to {@link #STATUS_CANCELLING}. Cancelling the exchange is an asynchronous
     * operation with respect to the request/response, and as such checking the request/response status of a cancelled exchange may return undefined results
     * (for example it may have only some of the response headers being sent by the server). The cancelling of the exchange is completed when the exchange
     * status (see {@link #getStatus()}) is {@link #STATUS_CANCELLED}, and this can be waited using {@link #waitForDone()}.
     */
    public void cancel()
    {
        setStatus(STATUS_CANCELLING);
        abort();
    }

    private void done()
    {
        synchronized (this)
        {
            disassociate();
            _onDone = true;
            notifyAll();
        }
    }

    private void abort()
    {
        AbstractHttpConnection httpConnection = _connection;
        if (httpConnection != null)
        {
            try
            {
                // Closing the connection here will cause the connection
                // to be returned in HttpConnection.handle()
                httpConnection.close();
            }
            catch (IOException x)
            {
                LOG.debug(x);
            }
            finally
            {
                disassociate();
            }
        }
    }

    void associate(AbstractHttpConnection connection)
    {
        if (connection.getEndPoint().getLocalAddr() != null)
            _localAddress = new Address(connection.getEndPoint().getLocalAddr(),connection.getEndPoint().getLocalPort());

        _connection = connection;
        if (getStatus() == STATUS_CANCELLING)
            abort();
    }

    boolean isAssociated()
    {
        return this._connection != null;
    }

    AbstractHttpConnection disassociate()
    {
        AbstractHttpConnection result = _connection;
        this._connection = null;
        if (getStatus() == STATUS_CANCELLING)
            setStatus(STATUS_CANCELLED);
        return result;
    }

    public static String toState(int s)
    {
        String state;
        switch (s)
        {
            case STATUS_START:
                state = "START";
                break;
            case STATUS_WAITING_FOR_CONNECTION:
                state = "CONNECTING";
                break;
            case STATUS_WAITING_FOR_COMMIT:
                state = "CONNECTED";
                break;
            case STATUS_SENDING_REQUEST:
                state = "SENDING";
                break;
            case STATUS_WAITING_FOR_RESPONSE:
                state = "WAITING";
                break;
            case STATUS_PARSING_HEADERS:
                state = "HEADERS";
                break;
            case STATUS_PARSING_CONTENT:
                state = "CONTENT";
                break;
            case STATUS_COMPLETED:
                state = "COMPLETED";
                break;
            case STATUS_EXPIRED:
                state = "EXPIRED";
                break;
            case STATUS_EXCEPTED:
                state = "EXCEPTED";
                break;
            case STATUS_CANCELLING:
                state = "CANCELLING";
                break;
            case STATUS_CANCELLED:
                state = "CANCELLED";
                break;
            default:
                state = "UNKNOWN";
        }
        return state;
    }

    @Override
    public String toString()
    {
        String state=toState(getStatus());
        long now=System.currentTimeMillis();
        long forMs = now -_lastStateChange;
        String s= _lastState>=0
            ?String.format("%s@%x=%s//%s%s#%s(%dms)->%s(%dms)",getClass().getSimpleName(),hashCode(),_method,_address,_uri,toState(_lastState),_lastStatePeriod,state,forMs)
            :String.format("%s@%x=%s//%s%s#%s(%dms)",getClass().getSimpleName(),hashCode(),_method,_address,_uri,state,forMs);
        if (getStatus()>=STATUS_SENDING_REQUEST && _sent>0)
            s+="sent="+(now-_sent)+"ms";
        return s;
    }

    /**
     */
    protected Connection onSwitchProtocol(EndPoint endp) throws IOException
    {
        return null;
    }

    /**
     * Callback called when the request headers have been sent to the server. This implementation does nothing.
     *
     * @throws IOException
     *             allowed to be thrown by overriding code
     */
    protected void onRequestCommitted() throws IOException
    {
    }

    /**
     * Callback called when the request and its body have been sent to the server. This implementation does nothing.
     *
     * @throws IOException
     *             allowed to be thrown by overriding code
     */
    protected void onRequestComplete() throws IOException
    {
    }

    /**
     * Callback called when a response status line has been received from the server. This implementation does nothing.
     *
     * @param version
     *            the HTTP version
     * @param status
     *            the HTTP status code
     * @param reason
     *            the HTTP status reason string
     * @throws IOException
     *             allowed to be thrown by overriding code
     */
    protected void onResponseStatus(Buffer version, int status, Buffer reason) throws IOException
    {
    }

    /**
     * Callback called for each response header received from the server. This implementation does nothing.
     *
     * @param name
     *            the header name
     * @param value
     *            the header value
     * @throws IOException
     *             allowed to be thrown by overriding code
     */
    protected void onResponseHeader(Buffer name, Buffer value) throws IOException
    {
    }

    /**
     * Callback called when the response headers have been completely received from the server. This implementation does nothing.
     *
     * @throws IOException
     *             allowed to be thrown by overriding code
     */
    protected void onResponseHeaderComplete() throws IOException
    {
    }

    /**
     * Callback called for each chunk of the response content received from the server. This implementation does nothing.
     *
     * @param content
     *            the buffer holding the content chunk
     * @throws IOException
     *             allowed to be thrown by overriding code
     */
    protected void onResponseContent(Buffer content) throws IOException
    {
    }

    /**
     * Callback called when the entire response has been received from the server This implementation does nothing.
     *
     * @throws IOException
     *             allowed to be thrown by overriding code
     */
    protected void onResponseComplete() throws IOException
    {
    }

    /**
     * Callback called when an exception was thrown during an attempt to establish the connection with the server (for example the server is not listening).
     * This implementation logs a warning.
     *
     * @param x
     *            the exception thrown attempting to establish the connection with the server
     */
    protected void onConnectionFailed(Throwable x)
    {
        LOG.warn("CONNECTION FAILED " + this,x);
    }

    /**
     * Callback called when any other exception occurs during the handling of this exchange. This implementation logs a warning.
     *
     * @param x
     *            the exception thrown during the handling of this exchange
     */
    protected void onException(Throwable x)
    {
        LOG.warn("EXCEPTION " + this,x);
    }

    /**
     * Callback called when no response has been received within the timeout. This implementation logs a warning.
     */
    protected void onExpire()
    {
        LOG.warn("EXPIRED " + this);
    }

    /**
     * Callback called when the request is retried (due to failures or authentication). Implementations must reset any consumable content that needs to be sent.
     *
     * @throws IOException
     *             allowed to be thrown by overriding code
     */
    protected void onRetry() throws IOException
    {
        if (_requestContentSource != null)
        {
            if (_requestContentSource.markSupported())
            {
                _requestContent = null;
                _requestContentSource.reset();
            }
            else
            {
                throw new IOException("Unsupported retry attempt");
            }
        }
    }

    /**
     * @return true if the exchange should have listeners configured for it by the destination, false if this is being managed elsewhere
     * @see #setConfigureListeners(boolean)
     */
    public boolean configureListeners()
    {
        return _configureListeners;
    }

    /**
     * @param autoConfigure
     *            whether the listeners are configured by the destination or elsewhere
     */
    public void setConfigureListeners(boolean autoConfigure)
    {
        this._configureListeners = autoConfigure;
    }

    protected void scheduleTimeout(final HttpDestination destination)
    {
        assert _timeoutTask == null;

        _timeoutTask = new Timeout.Task()
        {
            @Override
            public void expired()
            {
                HttpExchange.this.expire(destination);
            }
        };

        HttpClient httpClient = destination.getHttpClient();
        long timeout = getTimeout();
        if (timeout > 0)
            httpClient.schedule(_timeoutTask,timeout);
        else
            httpClient.schedule(_timeoutTask);
    }

    protected void cancelTimeout(HttpClient httpClient)
    {
        Timeout.Task task = _timeoutTask;
        if (task != null)
            httpClient.cancel(task);
        _timeoutTask = null;
    }

    private class Listener implements HttpEventListener
    {
        public void onConnectionFailed(Throwable ex)
        {
            try
            {
                HttpExchange.this.onConnectionFailed(ex);
            }
            finally
            {
                done();
            }
        }

        public void onException(Throwable ex)
        {
            try
            {
                HttpExchange.this.onException(ex);
            }
            finally
            {
                done();
            }
        }

        public void onExpire()
        {
            try
            {
                HttpExchange.this.onExpire();
            }
            finally
            {
                done();
            }
        }

        public void onRequestCommitted() throws IOException
        {
            HttpExchange.this.onRequestCommitted();
        }

        public void onRequestComplete() throws IOException
        {
            try
            {
                HttpExchange.this.onRequestComplete();
            }
            finally
            {
                synchronized (HttpExchange.this)
                {
                    _onRequestCompleteDone = true;
                    // Member _onDone may already be true, for example
                    // because the exchange expired or has been canceled
                    _onDone |= _onResponseCompleteDone;
                    if (_onDone)
                        disassociate();
                    HttpExchange.this.notifyAll();
                }
            }
        }

        public void onResponseComplete() throws IOException
        {
            try
            {
                HttpExchange.this.onResponseComplete();
            }
            finally
            {
                synchronized (HttpExchange.this)
                {
                    _onResponseCompleteDone = true;
                    // Member _onDone may already be true, for example
                    // because the exchange expired or has been canceled
                    _onDone |= _onRequestCompleteDone;
                    if (_onDone)
                        disassociate();
                    HttpExchange.this.notifyAll();
                }
            }
        }

        public void onResponseContent(Buffer content) throws IOException
        {
            HttpExchange.this.onResponseContent(content);
        }

        public void onResponseHeader(Buffer name, Buffer value) throws IOException
        {
            HttpExchange.this.onResponseHeader(name,value);
        }

        public void onResponseHeaderComplete() throws IOException
        {
            HttpExchange.this.onResponseHeaderComplete();
        }

        public void onResponseStatus(Buffer version, int status, Buffer reason) throws IOException
        {
            HttpExchange.this.onResponseStatus(version,status,reason);
        }

        public void onRetry()
        {
            HttpExchange.this.setRetryStatus(true);
            try
            {
                HttpExchange.this.onRetry();
            }
            catch (IOException e)
            {
                LOG.debug(e);
            }
        }
    }

    /**
     * @deprecated use {@link org.eclipse.jetty.client.CachedExchange} instead
     */
    @Deprecated
    public static class CachedExchange extends org.eclipse.jetty.client.CachedExchange
    {
        public CachedExchange(boolean cacheFields)
        {
            super(cacheFields);
        }
    }

    /**
     * @deprecated use {@link org.eclipse.jetty.client.ContentExchange} instead
     */
    @Deprecated
    public static class ContentExchange extends org.eclipse.jetty.client.ContentExchange
    {
    }
}