/*
    * $Id: RestfulClient.java 1529 2011-06-22 16:37:19Z hoheisel $
    *
    * Copyright 2008 Fraunhofer Gesellschaft, Munich, Germany,
    * for its Fraunhofer Institute for Computer Architecture and Software Technology (FIRST), Berlin, Germany
    * All rights reserved.
    *
    * See http://www.first.fraunhofer.de and http://www.gridworkflow.org/gwes for more details.
    */
  
  package net.kwfgrid.gwes.restfulclient;
  
  import net.kwfgrid.gwes.exception.GWESException;
  import org.apache.log4j.Logger;
  import org.xmlpull.v1.XmlPullParser;
  import org.xmlpull.v1.XmlPullParserFactory;
  import org.xmlpull.v1.XmlPullParserException;
  
  import java.net.HttpURLConnection;
  import java.net.URL;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.ByteArrayInputStream;
  import java.util.ArrayList;
  import java.util.List;
  import java.rmi.RemoteException;
  
  import net.kwfgrid.gwes.util.StringUtils;
  
  /**
   * Class for generating REST requests.
   * @author Andreas Hoheisel
   *         (<a href="http://www.andreas-hoheisel.de">www.andreas-hoheisel.de</a>)
   * @version $Id: RestfulClient.java 1529 2011-06-22 16:37:19Z hoheisel $
   */
  public class RestfulClient {
  
      final static Logger logger = Logger.getLogger(RestfulClient.class);
      private static final String ELEMENT_RETURN = "ns:return";
  
      /**
       * HTTP RESTful method.
       */
      public static enum Method {
          GET,
          POST,
          HEAD,
          OPTIONS,
          PUT,
          DELETE,
          TRACE
      }
  
      private static final String GET = "GET";
      private static final String POST = "POST";
      private static final String HEAD = "HEAD";
      private static final String OPTIONS = "OPTIONS";
      private static final String PUT = "PUT";
      private static final String DELETE = "DELETE";
      private static final String TRACE = "TRACE";
  
      /**
       * Invoke a RESTful GET request and return the response as list of strings.
       * @param url The target URL
       * @return A list of Strings containing the TEXT values of the XML response message.
       * @throws RemoteException If a parsing or IO exception of the response message occurrs.
       */
      public String[] httpGET(String url) throws RemoteException {
          try {
              List response = request(new URL(url), Method.GET, null);
              return (String[]) response.toArray(new String[0]);
          } catch (IOException e) {
              throw new RemoteException("exception during HTTP GET "+url+": " + e, e);
          } catch (XmlPullParserException e) {
              throw new RemoteException("exception during HTTP GET "+url+": " + e, e);
          }
      }
  
      /**
       * Invoke a RESTful GET request and return the response as list of strings.
       * @param url The target URL
       * @return A list of Strings containing the TEXT values of the XML response message.
       * @throws RemoteException If a parsing or IO exception of the response message occurrs.
       */
      public String[][] httpGETArray(String url) throws RemoteException {
          try {
              List<List<String>> response = requestArray(new URL(url), Method.GET, null);
              return StringUtils.convertListListToStringArrayArray(response);
          } catch (IOException e) {
              throw new RemoteException("exception during HTTP GET "+url+": " + e, e);
          } catch (XmlPullParserException e) {
              throw new RemoteException("exception during HTTP GET "+url+": " + e, e);
          }
      }
  
      /**
       * Invoke a RESTful PUT request and return the response as list of strings.
       * @param url The target URL
      * @return A list of Strings containing the TEXT values of the XML response message.
      * @throws RemoteException If a parsing or IO exception of the response message occurrs.
      */
     public String[] httpPUT(String url, String payload) throws RemoteException {
         try {
             InputStream in = null;
             if (payload != null) {
                 in = new ByteArrayInputStream(payload.getBytes("UTF-8"));
             }
             List response = request(new URL(url), Method.PUT, in);
             return (String[]) response.toArray(new String[0]);
         } catch (IOException e) {
             throw new RemoteException("exception during HTTP PUT "+url+": " + e, e);
         } catch (XmlPullParserException e) {
             throw new RemoteException("exception during HTTP PUT "+url+": " + e, e);
         }
     }
 
     /**
      * Invoke a RESTful POST request and return the response as list of strings.
      * @param url The target URL
      * @return A list of Strings containing the TEXT values of the XML response message.
      * @throws RemoteException If a parsing or IO exception of the response message occurs.
      */
     public String[] httpPOST(String url, String payload) throws RemoteException {
         try {
             InputStream in = null;
             if (payload != null) {
                 in = new ByteArrayInputStream(payload.getBytes("UTF-8"));
             }
             List response = request(new URL(url), Method.POST, in);
             return (String[]) response.toArray(new String[0]);
         } catch (IOException e) {
             throw new RemoteException("exception during HTTP POST "+url+": " + e, e);
         } catch (XmlPullParserException e) {
             throw new RemoteException("exception during HTTP POST "+url+": " + e, e);
         }
     }
 
     /**
      * Invoke a RESTful DELETE request and return the response as list of strings.
      * @param url The target URL
      * @return A list of Strings containing the TEXT values of the XML response message.
      * @throws RemoteException If a parsing or IO exception of the response message occurs.
      */
     public String[] httpDELETE(String url) throws RemoteException {
         try {
             List response = request(new URL(url), Method.DELETE, null);
             return (String[]) response.toArray(new String[0]);
         } catch (IOException e) {
             throw new RemoteException("exception during HTTP DELETE "+url+": " + e, e);
         } catch (XmlPullParserException e) {
             throw new RemoteException("exception during HTTP DELETE "+url+": " + e, e);
         }
     }
 
     /**
      * Invoke a restful request and return the response as list of strings.
      * @param url The target URL.
      * @param method The method (GET, PUT, ...).
      * @param payload The payload body used with POST and PUT
      * @return A list of Strings containing the TEXT values of the XML response message.
      * @throws IOException
      * @throws XmlPullParserException
      */
     public static List<String> request(URL url, Method method, InputStream payload) throws XmlPullParserException, IOException {
 
         if (logger.isDebugEnabled()) {
             logger.debug("trying to connect to "+url.toString()+" using method "+getMethodAsString(method)+"...");
         }
 
         HttpURLConnection connection = (HttpURLConnection)url.openConnection();
         connection.setRequestMethod(getMethodAsString(method));
 
 //        // write auth header
 //        BASE64Encoder encoder = new BASE64Encoder();
 //        String encodedCredential = encoder.encode( (username + ":" + password).getBytes() );
 //        connection.setRequestProperty("Authorization", "BASIC " + encodedCredential);
 
         writeBodyToConnection(payload, connection);
 
         ArrayList<String> list = new ArrayList<String>();
         try {
             // do request
             connection.connect();
             parseXmlTextToStringList(connection.getInputStream(), list);
         } catch (IOException e) {
             throw new RemoteException("Error message returned by server: \n"+ StringUtils.convertStreamToString(connection.getErrorStream()),e);
         }
 
         connection.disconnect();
 
 //        // look at headers
 //        // the 0th header has a null key, and the value is the response line ("HTTP/1.1 200 OK" or whatever)
 //        String header = null;
 //        String headerValue = null;
 //        int index = 0;
 //        while ((headerValue = connection.getHeaderField(index)) != null)
 //        {
 //            header = connection.getHeaderFieldKey(index);
 //
 //            if (header == null)
 //                System.out.println(headerValue);
 //            else
 //                System.out.println(header + ": " + headerValue);
 //
 //            index++;
 //        }
 //        System.out.println("");
 
         return list;
     }
 
     /**
      * Invoke a restful request and return the response as list of list of strings.
      * @param url The target URL.
      * @param method The method (GET, PUT, ...).
      * @param payload The payload body used with POST and PUT
      * @return A list of list of Strings containing the TEXT values of the XML response message array.
      * @throws IOException
      * @throws XmlPullParserException
      */
     public static List<List<String>> requestArray(URL url, Method method, InputStream payload) throws XmlPullParserException, IOException {
 
         if (logger.isDebugEnabled()) {
             logger.debug("trying to connect to "+url.toString()+" using method "+getMethodAsString(method)+"...");
         }
 
         HttpURLConnection connection = (HttpURLConnection)url.openConnection();
         connection.setRequestMethod(getMethodAsString(method));
         writeBodyToConnection(payload, connection);
 
         List<List<String>> listList = new ArrayList<List<String>>();
         try {
             // do request
             connection.connect();
             parseXmlTextToStringListList(connection.getInputStream(), listList);
         } catch (IOException e) {
             throw new RemoteException("Error message returned by server: \n"+ StringUtils.convertStreamToString(connection.getErrorStream()),e);
         }
 
         connection.disconnect();
         return listList;
     }
 
     private static void writeBodyToConnection(InputStream payload, HttpURLConnection connection) throws IOException {
         // write body if we're doing POST or PUT
         int read = 0;
         if (payload != null) {
             byte buffer[] = new byte[8192];
             connection.setDoOutput(true);
             OutputStream output = connection.getOutputStream();
             while ((read = payload.read(buffer)) != -1) {
                 output.write(buffer, 0, read);
             }
         }
     }
 
     private static void parseXmlTextToStringList(InputStream in, List<String> list) throws XmlPullParserException, IOException {
         XmlPullParser parser = getParser(in);
         int event = parser.next();
         int lastEvent;
         while (event != XmlPullParser.END_DOCUMENT) {
             boolean startTag = false;
             if (event == XmlPullParser.TEXT) {
                 list.add(parser.getText());
             }
             lastEvent = event;
             event = parser.next();
             // detect empty element
             if (lastEvent == XmlPullParser.START_TAG && event == XmlPullParser.END_TAG) {
                 list.add("");
             }
         }
     }
 
     /**
      * parse XML and put text contents into nested list of list of strings.
      * Example input XML:
      * <pre>
      * &lt;ns:getModificationsForUpdateResponse xmlns:ns=&quot;http://gwes.kwfgrid.net&quot;
      *   &lt;ns:return&gt;
      *     &lt;ns:array&gt;27&lt;/ns:array&gt;
      *     &lt;ns:array&gt;MODIFICATION&lt;/ns:array&gt;
      *   &lt;/ns:return&gt;
      *   &lt;ns:return&gt;
      *     &lt;ns:array&gt;28&lt;/ns:array&gt;
      *     &lt;ns:array&gt;MODIFICATION&lt;/ns:array&gt;
      *   &lt;/ns:return&gt;
      * &lt;/ns:getModificationsForUpdateResponse&gt;
      * </pre>
      * @param in
      * @param listList
      * @throws XmlPullParserException
      * @throws IOException
      */
     private static void parseXmlTextToStringListList(InputStream in, List<List<String>> listList) throws XmlPullParserException, IOException {
         //        <ns:getModificationsForUpdateResponse xmlns:ns="http://gwes.kwfgrid.net"
         //           <ns:return>
         //             <ns:array>27</ns:array>
         //             <ns:array>MODIFICATION</ns:array>
         //           </ns:return>
         //           <ns:return>
         //             <ns:array>28</ns:array>
         //             <ns:array>MODIFICATION</ns:array>
         //           </ns:return>
         //        </ns:getModificationsForUpdateResponse>
 
         List<String> list = null;
 
         XmlPullParser parser = getParser(in);
         int event = parser.next();
         int lastEvent = -1;
         while (event != XmlPullParser.END_DOCUMENT) {
             // <ns:return>
             if (event == XmlPullParser.START_TAG && parser.getName().equals(ELEMENT_RETURN)) {
                 list = new ArrayList<String>();
             }
             else if (event == XmlPullParser.TEXT && list != null) {
                 list.add(parser.getText());
             }
             else if (event == XmlPullParser.END_TAG && list != null) {
                 // detect empty element
                 if (lastEvent == XmlPullParser.START_TAG) {
                     list.add("");
                 }
                 // </ns:return>
                 if (parser.getName().equals(ELEMENT_RETURN)) {
                     listList.add(list);
                     list = null;
                 }
             }
             lastEvent = event;
             event = parser.next();
         }
     }
 
     /**
      * Get HTTP REST method as String.
      * @param method The REST method.
      * @return A String representing the REST method, e.g., "GET", "PUT", ....
      */
     public static String getMethodAsString(Method method) {
         switch (method) {
             case DELETE:
                 return DELETE;
             case GET:
                 return GET;
             case HEAD:
                 return HEAD;
             case OPTIONS:
                 return OPTIONS;
             case POST:
                 return POST;
             case PUT:
                 return PUT;
             case TRACE:
                 return TRACE;
         }
         return null;
     }
 
     private static XmlPullParser getParser(InputStream inputStream) throws XmlPullParserException {
         XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
         XmlPullParser parser = factory.newPullParser();
         parser.setInput(inputStream,null);
         return parser;
     }
 
 }