/*

  * Copyright 1999-2002,2004 The Apache Software Foundation.

  * 

  * Licensed 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 org.apache.commons.latka.http;

 // java imports

 import java.net.URL;

 import java.io.ByteArrayInputStream;

 import java.io.InputStream;

 import java.io.IOException;

 import java.util.List;

 import java.util.LinkedList;

 // latka imports

 import org.apache.commons.httpclient.HostConfiguration;

 import org.apache.commons.httpclient.UsernamePasswordCredentials;

 import org.apache.commons.httpclient.HttpClient;

 import org.apache.commons.httpclient.HttpException;

 import org.apache.commons.httpclient.HttpMethod;

 import org.apache.commons.httpclient.HttpState;

 import org.apache.commons.httpclient.HttpMethodBase;

 import org.apache.commons.httpclient.methods.PostMethod;

 // log4j imports

 import org.apache.log4j.Category;

 /**

  * An implementation of a Latka Request interface based on the Apache Commons

  * HttpClient package.

  *

  * @todo pass proxy host and port to httpclient

  * @author <a href="mailto:dsale@us.britannica.com">Doug Sale</a>

  * @author <a href="mailto:mdelagra@us.britannica.com">Morgan Delagrange</a>

  * @author dIon Gillard

  * @version $Id: RequestImpl.java 561366 2007-07-31 15:58:29Z rahul $

  * @see Request

  */

 public class RequestImpl implements Request {

     /** Standard HTTP Port */

     public static final int HTTP_PORT = 80;

     /** Standard HTTPS Port */

     public static final int HTTPS_PORT = 443;

     /** host the request is being made on */

     protected String  _host   = null;

     /** port the request is being made on */

     protected int     _port   = -1;

     /** http method being used to make the request */

     protected int     _method = -1;

     /** http session the request is part of */

     protected SessionImpl _session    = null;

     /** credentials for the request */

     protected Credentials _credentials = null;

     /** http method implementation */

     protected HttpMethod  _httpMethod = null;

     /** URL being requested */

     protected URL         _targetURL  = null;

     /** query string portion of the URL */

     protected String      _query      = null;

     /** time taken for the request in milliseconds */

     protected long        _requestTiming = -1;

     /** name given to the request */

     protected String      _label      = null;

     /** headers sent with this request */

     protected RequestHeaders _requestHeaders = new RequestHeadersImpl();

     /** parameters sent with this request */

     protected Parameters _parameters = new ParametersImpl();

     /** manually constructed post body */

     protected String _requestBody = null;

     /** whether or not redirect responses should be followed as part of the

         request processing*/

     protected boolean _followRedirects = true;

     /** object used to perform the http requests */

     protected HttpClient _httpClient = new HttpClient();

     /** proxy used to perform the requests */

     private Proxy _proxy = null;

     /** log4j category used when logging messages */

     protected static final Category _log = 

         Category.getInstance(RequestImpl.class);

     /**

      * HTTP Version 1.0

      */

     private static final String HTTP_10 = "1.0";

     /**

      * HTTP Version 1.1

      */    

     private static final String HTTP_11 = "1.1";

     protected String _httpVersion = HTTP_11;

     protected List _visitedURLs = new LinkedList();

     /**

      * Create a request for the specified URL, process using the supplied method

      * and use the supplied state and session for persistent data

      * @param url the URL to send the request to

      * @param httpMethod the http method to use in sending the request, as 

      *        defined in {@link Request}

      * @param state shared information across requests

      * @param session state shared across servers and requests

      */

     protected RequestImpl(URL url, int httpMethod, HttpState state,

         SessionImpl session) {

         this(null, url, httpMethod, state, session, true);

     }

     /**

      * Create a RequestImpl

      *

      * @param label       a name for the request

      * @param url         the url that this request embodies

      * @param httpMethod  the method by which this request should be executed

      * @param state       shared information across requests

      * @param session     the session that the request should be executed in

      * @param followRedirects whether http redirect responses should be honoured

      */

     protected RequestImpl(String label, URL url, int httpMethod, 

         HttpState state, SessionImpl session, boolean followRedirects) {

         _followRedirects = followRedirects;

         _method = httpMethod;

         _httpClient.setState(state);

         _label = label;

         _query = url.getQuery();

         _session = session;

         _targetURL = url;

         _httpMethod = MethodFactory.getInstance(httpMethod, url);

         if (_query != null) {

             _httpMethod.setQueryString(_query);

         }

         _httpMethod.setFollowRedirects(followRedirects);

     }

     /**

      * Returns the object implementing the HttpMethod

      * (get, post, etc.) for this request.

      *

      * @return the underlying HttpMethod object representing the request/

      *      response pair.

      */

     protected HttpMethod getHttpMethod() {

         return _httpMethod;

     }

     /**

      * Defined in the implemented interface

      * @return the headers used for this request

      * @see Request#getHeaders()

      */

     public RequestHeaders getHeaders() {

         return _requestHeaders;

     }

     /**

      * Defined in the implemented interface

      * @param requestHeaders new value for the headers property

      * @see Request#setHeaders(RequestHeaders)

      */

     public void setHeaders(RequestHeaders requestHeaders) {

         _requestHeaders = requestHeaders;

     }

     /**

      * Defined in the implemented interface

      * @return the parameters property

      * @see Request#getParameters()

      */

     public Parameters getParameters() {

         return _parameters;

     }

     /**

      * Defined in the implemented interface

      * @see Request#setRequestBody(String)

      */

     public void setRequestBody(String body) {

         _requestBody = body;

     }

     /**

      * Defined in the implemented interface

      * @param parameters new value for parameters property

      * @see Request#setParameters(Parameters)

      */

     public void setParameters(Parameters parameters) {

         _parameters = parameters;

     }

     /**

      * Defined in the implemented interface

      * @param credentials username and password to use

      * @see Request#setCredentials(Credentials)

      */

     public void setCredentials(Credentials credentials) {

         // null implies that this credential is the default (vs. specifying a 

         // realm)

         UsernamePasswordCredentials creds = new UsernamePasswordCredentials(

             credentials.getUserName(), credentials.getPassword());

         _session._state.setCredentials(null, creds);

         _credentials = credentials;

     }

     public Credentials getCredentials() {

         return _credentials;

     }

     /**

      * Execute the request - perform the http interaction.

      * Since HttpClient doesn't follow off-server

      * redirects, execute() may have to construct further 

      * requests that call this method.

      * 

      * @return a {@link Response} detailing the html etc

      * @exception IOException

      *                   when there are problems reading and writing

      * @see Request#execute()

      */

     protected Response executeRequestPerHost() throws IOException {

         // set the request headers in HTTPClient

         List headers = _requestHeaders.getHeaders();

         for (int i = 0; i < headers.size(); ++i) {

             String[] header = (String[]) headers.get(i);

             _httpMethod.addRequestHeader(header[0], header[1]);

         }

         if (_requestBody != null) {

             InputStream  is = new ByteArrayInputStream(

                 _requestBody.getBytes("ISO-8859-1"));

             ((PostMethod) _httpMethod).setRequestBody(is);

         } else {

             List parameters = _parameters.getParameters();

             for (int i = 0; i < parameters.size(); ++i) {

                 String[] parameter = (String[]) parameters.get(i);

                 addHttpClientParameter(parameter[0], parameter[1]);

             }

         }

         // for timing

         long startDate = System.currentTimeMillis();

         Response response = null;

         try {

             // open the connection

             openConnection();

             _log.debug("executing request");

             _httpClient.executeMethod(_httpMethod);

             _log.debug("request executed");

             response = new ResponseImpl(this);

             // Cache the response body to allow it to be accessed

             // after the http connection is closed.

             String sideEffectOnly = response.getResource();

             // set the referer

             // note: If followRedirects

             // is enabled, HTTPClient may return a path

             // that is different from the initial request.

             // HTTPClient will not follow redirects to another

             // host, port, or protocol; in that event, it will always

             // return a 301 or 302.

             _session.setReferer(new URL(_targetURL.getProtocol(), _host, _port,

                 _httpMethod.getPath()));

         } catch (HttpException e) {

             throw new IOException(e.toString());

         } catch (IOException e) {

             // rethrow it after closing the connection

             throw e;

         } finally {

             try {

                 closeConnection(); 

                 // FIXME: Shouldn't use Exception here.

             } catch (Exception e) {

                 e.printStackTrace();

             }

         }

         _requestTiming = System.currentTimeMillis() - startDate;

         if (_log.isInfoEnabled()) {

             _log.info("response obtained (response logging disabled because "

                 + "some responses are binary)");

         }

         return response;

     }

     /**

      * Executes the request.  In the event of a 301 or 302,

      * this method may need to create a new Request, 

      * due to an idiosyncracy of

      * HttpClient.  In that case, the Response.getRequest()

      * method will return the actual Request that was executed.

      */

     public Response execute() throws IOException {

         Response response = executeRequestPerHost();

         if (followRedirects() == false) {

             return response;

         }

         Request lastRequest = this;

         // execute the request until either we get a non-redirect response, or

         // we visit a URL we have already visited

         while (response.getStatusCode() == 301 || response.getStatusCode() == 302) {

             // follow the redirect

             URL url = new URL(response.getHeader("location"));

             if (_visitedURLs.contains(url.toString())) {

                 return response;

             }

             Request request = _session.createRequest(lastRequest.getLabel(), url,

                 lastRequest.getMethod(), lastRequest.getVersion(), true, getProxy());

             request.setParameters(lastRequest.getParameters());

             request.setHeaders(lastRequest.getHeaders());

             Credentials credentials = lastRequest.getCredentials();

             if (credentials != null) {

                 request.setCredentials(credentials);

             }

             response = request.execute();

             _visitedURLs.add(url.toString());

             lastRequest = request;

         }

         return response;

     }

     /**

      * Get the URL used for the request

      * @return the {@link URL} of the request

      * @see Request#getURL

      */

     public URL getURL() {

         return _targetURL;

     }

     /**

      * Get the label used for the request

      * @return the label used to create the request

      * @see Request#getLabel

      */

     public String getLabel() {

         return _label;

     }

     /**

      * Add a parameter (name and value) to the request

      * @param name the name of the parameter to be added

      * @param value the value of the parameter to be added

      * @see Request#addParameter(String,String)

      */

     public void addParameter(String name, String value) {

         _parameters.addParameter(name, value);

     }

     /**

      * Associate a parameter with this request.

      *

      * @param name  the lvalue of the parameter - must not be null

      * @param value  the rvalue of the parameter - must not be null

      */

     protected void addHttpClientParameter(String name, String value) {

         if (name == null) {

             throw new NullPointerException("name parameter is null");

         }

         if (value == null) {

             throw new NullPointerException("value parameter is null");

         }

         _log.info("adding parameter, name: " + name + ", value: " + value);

         if (_httpMethod instanceof PostMethod) {

             // addParameter adds to POST Entity, not URL

             ((PostMethod) _httpMethod).addParameter(name, value);

         } else {

             StringBuffer query = new StringBuffer();

             // setParameter adds to URL as query string

             if (_query == null || _query.equals("")) {

                 query.append(name);

                 query.append("=");

                 query.append(value);

             } else {

                 query.append(_query);

                 query.append("&");

                 query.append(name);

                 query.append("=");

                 query.append(value);

             }

             _query = query.toString();

             ((HttpMethod) _httpMethod).setQueryString(_query);

         }

     }

     /**

      * Set a header in the request

      *

      * @param headerName name of any HTTP request header

      * @param headerValue value of that header

      */

     public void addHeader(String headerName, String headerValue) {

         _requestHeaders.addHeader(headerName, headerValue);

     }

     /**

      * Retrieve the session associated with this request.

      *

      * @return a <code>Session</code> object

      */

     public Session getSession() {

         return _session;

     }

     /**

      * @return the time it took to execute this request in milliseconds

      * or -1 if the request has not yet been executed

      */

     public int getRequestTiming() {

         return (int) _requestTiming;

     }

     /**

      * opens an HTTP connection.  This method is called

      * before executing the method.

      *

      * @exception IOException

      *                   if the server could not be contacted

      */

     protected void openConnection() throws IOException {

         _log.debug("Opening connection");

         URL url = getURL();

         String protocol = url.getProtocol();

         String host = url.getHost();

         int port = url.getPort();

         // explicitly set port if not in url,

         // just for storing away and comparison

         if (port == -1) {

             if (protocol.equals("http")) {

                 port = HTTP_PORT;

             } else if (protocol.equals("https")) {

                 port = HTTPS_PORT;

             } else {

                 throw new IllegalArgumentException("Unsupported Protocol");

             }

         }

         // save session values

         _host = host;

         _port = port;

         HostConfiguration hostConfiguration = _httpClient.getHostConfiguration();

         hostConfiguration.setHost(host, port, protocol);

         if (getProxy() != null) {

             hostConfiguration.setProxy(getProxy().getHost(), getProxy().getPort());

         }

         _log.debug("connection open");

     }

     /**

      * Closes the http connection associated with the request

      * @throws IOException if there are problems closing the connection

      */

     protected void closeConnection() throws IOException {

         _log.debug("closing connection");

         _httpMethod.releaseConnection();

         _log.debug("connection closed");

     }

     /**

      * Defined in the interface

      * @return whether the request will honour http redirect status codes

      * @see Request#followRedirects()

      */

     public boolean followRedirects() {

         return _followRedirects;

     }

     /**

      * Defined in the interface

      * @return the http method being used for the request, as defined in the

      *      interface

      * @see Request#getMethod

      */

     public int getMethod() {

         return _method;

     }

     /** Getter for property proxy.

      * @return Value of property proxy.

      */

     public Proxy getProxy() {

         return _proxy;

     }

     /** Setter for property proxy.

      * @param proxy New value of property proxy.

      */

     public void setProxy(Proxy proxy) {

         _proxy = proxy;

     }

     /**

      * Sets the HTTP version for this request.  If

      * the version provided is not 1.0 or 1.1, then

      * 1.1 will be used.

      *

      * @param version  HTTP version

      */

     public void setVersion(String version) {

         ((HttpMethodBase) _httpMethod).setHttp11(!HTTP_10.equals(version));

         _httpVersion = version;

     }

     /**

      * Get the HTTP version to use in this request.

      * 

      * @return HTTP version for the request

      */

     public String getVersion() {

         return _httpVersion;

     }

 }