/*

  * Copyright 1999-2001,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.jelly;

 import java.io.IOException;

 import java.net.URL;

 import org.apache.commons.jelly.JellyTagException;

 import org.apache.commons.jelly.TagSupport;

 import org.apache.commons.jelly.XMLOutput;

 import org.apache.commons.latka.LatkaException;

 import org.apache.commons.latka.event.LatkaEventInfo;

 import org.apache.commons.latka.event.RequestErrorEvent;

 import org.apache.commons.latka.event.RequestSkippedEvent;

 import org.apache.commons.latka.event.RequestSucceededEvent;

 import org.apache.commons.latka.http.Proxy;

 import org.apache.commons.latka.http.Request;

 import org.apache.commons.latka.http.Response;

 import org.apache.commons.latka.http.Session;

 import org.apache.commons.latka.http.SessionImpl;

 import org.apache.log4j.Category;

 /**

  *

  * @author  Morgan Delagrange

  */

 public class RequestTag extends TagSupport {

     protected String  _host = null;

     protected int     _port = -1;

     protected String  _proxyHost = null;

     protected int     _proxyPort = -1;

     protected String  _label = null;

     protected int  _method = Request.HTTP_METHOD_GET;

     protected String  _path = null;

     protected boolean _secure = false;

     protected boolean _followRedirects = true;

     protected String  _httpVersion = "1.1";

     protected Request  _request  = null;

     protected Response _response = null;

     protected Session  _session  = null;

     protected boolean  _requestExecuted = false;

     protected static final Category _log = Category.getInstance(RequestTag.class);

     /**

      *  Wraps Latka tests, provides some defaults for host, port etc.

      *

      * @param xmlOutput a place to write output

      * @throws JellyTagException if an HTTP request could not be created

      */

     public void doTag(XMLOutput xmlOutput) throws JellyTagException {

         try {

             _request = createRequest();

         } catch (LatkaException e) {

             throw new JellyTagException("could not create HTTP request",e);

         }

         LatkaEventInfo listener =

             JellyUtils.getInstance().getLatkaEventInfo(getContext());

         if (listener.didSessionSucceed(findSession()) == false) {

             listener.requestSkipped(new RequestSkippedEvent(_request,null));

             return;

         }

         // may set headers and such

         invokeBody(xmlOutput);

         // even when there are no validations, we execute the request

         // to make sure the URL is accessible

         // will throw an unrecoverable LatkaException if the request could not

         // be created, typically because of a malformed URL

         Response response = null;

         try {

             response = getResponse();

         } catch (LatkaException e) {

             throw new JellyTagException("could not obtain HTTP response",e);

         }

         // if there's been a response, and the request has a label

         // make the response available to the jelly context

         if (response != null && _label != null) {

             getContext().setVariable(_label, response);

         }

         if (listener.didRequestSucceed(_request)) {

             listener.requestSucceeded(new RequestSucceededEvent(

               response.getRequest(), response));            

         }

     }

     /**

      * 

      * @return Request

      * @exception IOException

      *                   Error creating the request (unrecoverable, the script

      *                   must fail)

      */

     private Request createRequest() throws LatkaException {

         String host = _host;

         int port    = _port;

         String proxyHost = _proxyHost;

         int proxyPort    = _proxyPort;

         if (host == null || port == -1 || proxyHost == null || proxyPort == -1) {

             SuiteSettings settings = getSuiteSettings();

             if (host == null) {

                 host = settings.getDefaultHost();

             }

             if (port == -1) {

                 port = settings.getDefaultPort();

             }

             if (proxyHost == null) {

                 proxyHost = settings.getDefaultProxyHost();

             }

             if (proxyPort == -1) {

                 proxyPort = settings.getDefaultProxyPort();

             }

         }

         Session session = findSession();

         Proxy proxy = null;

         if (proxyHost != null) {

             proxy = new Proxy(proxyHost,proxyPort);

         }

         URL url = null;

         try {

             url = new URL(_secure ? "https" : "http", host, port, _path);

         } catch (IOException e) {

             throw new LatkaException(e);

         }

         return session.createRequest(_label,url,_method,_httpVersion,_followRedirects,proxy);

     }

     public Request getRequest() {

         return _request;

     }

     protected Session findSession() {

         if (_session == null) {

             SessionTag tag = (SessionTag) findAncestorWithClass(SessionTag.class);

             if (tag == null) {

                 _session = new SessionImpl();

             } else {

                 _session = tag.getSession();

             }

         }

         return _session;

     }

     public boolean getRequestExecuted() {

         return _requestExecuted;

     }

     /**

      * The first time this method is called, a live HTTP

      * call will be made to the server, returning null

      * if the response cannot be obtained.  Subsequent

      * calls return a cached response.

      * 

      * @return Response for the request specified by the Latka script

      * @exception LatkaException

      *                   error creating the Request (unrecoverable)

      */

     public Response getResponse() throws LatkaException {

         if (_requestExecuted == false) {

             _requestExecuted = true;

             LatkaEventInfo listener = 

                 JellyUtils.getInstance().getLatkaEventInfo(getContext());

             try {

                 _response = _request.execute();

                 _log.warn("Eventually this debug needs to go.");

                 if (_log.isDebugEnabled()) {

                   _log.debug(_response.getResource());

                 }            

             } catch (IOException e) {

                 listener.requestError(new RequestErrorEvent(_request, null, e));

                 return null;

             }

             // hack because sometimes we need to generate a new request after

             // a redirect

             _request = _response.getRequest();

         }

         return _response;

     }

     /**

      * get the suite settings from SuiteTag

      * 

      * @return SuiteSettings object

      */

     protected SuiteSettings getSuiteSettings() {

         SuiteTag tag = 

         (SuiteTag) findAncestorWithClass(org.apache.commons.latka.jelly.SuiteTag.class);

         return tag.getSuiteSettings();

     }

     /**

      * Setter for host

      * 

      * @param host

      *               host for the request

      */

     public void setHost(String host) {

         _host = host;

     }

     /**

      * Setter for port

      * 

      * @param port

      *               port for all requests 

      */

     public void setPort(int port) {

         _port = port;

     }

     /**

      * Setter for defaultProxyHost

      * 

      * @param defaultHost

      *               defaultProxyHost for all requests

      */

     public void setProxyHost(String host) {

         _proxyHost = host;

     }

     /**

      * Setter for defaultProxyPort

      * 

      * @param defaultPort

      *               defaultProxyPort for all requests

      * @return 

      */

     public void setProxyPort(int port) {

         _proxyPort = port;

     }

     /**

      * Set the label for this suite

      * 

      * @param label  suite label

      */

     public void setLabel(String label) {

         _label = label;

     }

     /**

      * Sets the HTTP method to use.  Supports post, get,

      * and head.  Default is "get".

      * 

      * @param method set method to post, get or head

      * @exception UnsupportedOperationException

      *                   if an unsupported HTTP method is set

      */

     public void setMethod(String method) throws UnsupportedOperationException {

         if (method.equals("get")) {

             _method = Request.HTTP_METHOD_GET;

         } else if (method.equals("post")) {

             _method = Request.HTTP_METHOD_POST;

         } else if (method.equals("head")) {

             _method = Request.HTTP_METHOD_HEAD;

         } else {

             throw new UnsupportedOperationException("Unkonwn HTTP method: " + method);

         }

     }

     /**

      * Sets the path of the document on the server, combined

      * with the host and port

      * 

      * @param path   Path to the document on the server

      */

     public void setPath(String path) {

         _path = path;

     }

     /**

      * Sets whether or not to transmit the request over

      * SSL.

      * 

      * @param secure whether or not this request is SSL

      */

     public void setSecure(String secure) {

         _secure = Boolean.valueOf(secure).booleanValue();

     }

     /**

      * Sets whether or not to transmit the request over

      * SSL.

      * 

      * @param secure whether or not this request is SSL

      */

     public void setFollowRedirects(String followRedirects) {

         _followRedirects = Boolean.valueOf(followRedirects).booleanValue();

     }

     /**

      * HTTP version to use.  Legal values are 1.0 and 1.1.

      * 1.1 is the default.

      * 

      * @param version HTTP specification version

      */

     public void setVersion(String version) {

         _httpVersion = version;

     }

 }