/*

  * Copyright 2005-2007 The Kuali Foundation

  *

  *

  * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php

  *

  * 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.kuali.rice.kew.edl;

 import java.io.ByteArrayOutputStream;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.InterruptedIOException;

 import java.io.OutputStream;

 import java.io.StringReader;

 import java.lang.reflect.Method;

 import java.net.Socket;

 import java.net.URL;

 import java.util.Timer;

 import java.util.TimerTask;

 import javax.xml.parsers.DocumentBuilder;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.transform.TransformerException;

 import javax.xml.xpath.XPath;

 import javax.xml.xpath.XPathConstants;

 import javax.xml.xpath.XPathExpressionException;

 import javax.xml.xpath.XPathFactory;

 import org.apache.log4j.Logger;

 import org.kuali.rice.kew.postprocessor.ActionTakenEvent;

 import org.kuali.rice.kew.postprocessor.DefaultPostProcessor;

 import org.kuali.rice.kew.postprocessor.DeleteEvent;

 import org.kuali.rice.kew.postprocessor.DocumentRouteLevelChange;

 import org.kuali.rice.kew.postprocessor.DocumentRouteStatusChange;

 import org.kuali.rice.kew.postprocessor.ProcessDocReport;

 import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue;

 import org.kuali.rice.kew.service.KEWServiceLocator;

 import org.kuali.rice.kew.util.Utilities;

 import org.kuali.rice.kew.util.XmlHelper;

 import org.w3c.dom.Document;

 import org.w3c.dom.Element;

 import org.xml.sax.InputSource;

 /**

  * PostProcessor responsible for posting events to a url defined in the EDL doc definition.

  * @author Kuali Rice Team (rice.collab@kuali.org)

  */

 public class EDocLitePostProcessor extends DefaultPostProcessor {

     private static final Logger LOG = Logger.getLogger(EDocLitePostProcessor.class);

     private static final Timer TIMER = new Timer();

     public static final int SUBMIT_URL_MILLISECONDS_WAIT = 60000;

     public static final String EVENT_TYPE_ACTION_TAKEN = "actionTaken";

     public static final String EVENT_TYPE_DELETE_ROUTE_HEADER = "deleteRouteHeader";

     public static final String EVENT_TYPE_ROUTE_LEVEL_CHANGE = "routeLevelChange";

     public static final String EVENT_TYPE_ROUTE_STATUS_CHANGE = "statusChange";

     private static String getURL(Document edlDoc) throws XPathExpressionException {

         XPath xpath = XPathFactory.newInstance().newXPath();

         return (String) xpath.evaluate("//edlContent/edl/eventNotificationURL", edlDoc, XPathConstants.STRING);

     }

     /**

      * @param urlstring

      * @param eventDoc

      */

     private static void submitURL(String urlstring, Document eventDoc) throws IOException, TransformerException {

         String content;

         try {

             content = XmlHelper.writeNode(eventDoc, true);

         } catch (TransformerException te) {

             LOG.error("Error writing serializing event doc: " + eventDoc);

             throw te;

         }

         byte[] contentBytes = content.getBytes("UTF-8");

         LOG.debug("submitURL: " + urlstring);

         URL url = new URL(urlstring);

         String message = "POST " + url.getFile() + " HTTP/1.0\r\n" +

                          "Content-Length: " + contentBytes.length + "\r\n" +

                          "Cache-Control: no-cache\r\n" +

                          "Pragma: no-cache\r\n" +

                          "User-Agent: Java/1.4.2; EDocLitePostProcessor\r\n" +

                          "Host: " + url.getHost() + "\r\n" +

                          "Connection: close\r\n" +

                          "Content-Type: application/x-www-form-urlencoded\r\n\r\n" +

                          content;

         byte[] buf = message.getBytes("UTF-8");

         Socket s = new Socket(url.getHost(), url.getPort());

         /*URLConnection con = url.openConnection();

         LOG.debug("got connection: " + con);

         con.setDoOutput(true);

         con.setDoInput(true);

         LOG.debug("setDoOutput(true)");

         con.setRequestProperty("Connection", "close");

         con.setRequestProperty("Content-Length", String.valueOf(buf.length));*/

         OutputStream os = s.getOutputStream();

         try {

             try {

                 os.write(buf, 0, buf.length);

                 os.flush();

             } catch (InterruptedIOException ioe) {

                 LOG.error("IO was interrupted while posting event to url " + urlstring + ": " + ioe.getMessage());

             } catch (IOException ioe) {

                 LOG.error("Error posting EDocLite content to url " + urlstring + ioe.getMessage());

             } finally {

                 try {

                     LOG.debug("Shutting down output stream");

                     s.shutdownOutput();

                 } catch (IOException ioe) {

                     LOG.error("Error shutting down output stream for url " + urlstring + ": " + ioe.getMessage());

                 }

             }

             InputStream is = s.getInputStream();

             try {

                 buf = new byte[1024];

                 ByteArrayOutputStream baos = new ByteArrayOutputStream();

                 // this is what actually forces the write on the URLConnection!

                 int read = is.read(buf);

                 if (read != -1) {

                     baos.write(buf, 0, read);

                 }

                 LOG.debug("EDocLite post processor response:\n" + new String(baos.toByteArray()));

             } catch (InterruptedIOException ioe) {

                 LOG.error("IO was interrupted while reading response from url " + urlstring + ": " + ioe.getMessage());

             } catch (IOException ioe) {

                 LOG.error("Error reading response from EDocLite handler url " + urlstring + ioe.getMessage());

             } finally {

                 try {

                     LOG.debug("Shutting down input stream");

                     s.shutdownInput();

                 } catch (IOException ioe) {

                     LOG.error("Error shutting down input stream for url " + urlstring + ": " + ioe.getMessage());

                 }

             }

         } finally {

             try {

                 s.close();

             } catch (IOException ioe) {

                 LOG.error("Error closing socket", ioe);

             }

         }

     }

     protected static void postEvent(Long docId, Object event, String eventName) throws Exception {

         DocumentRouteHeaderValue val = KEWServiceLocator.getRouteHeaderService().getRouteHeader(docId);

         Document doc = getEDLContent(val);

         if(LOG.isDebugEnabled()){

                 LOG.debug("Submitting doc: " + XmlHelper.jotNode(doc));

         }

         String urlstring = getURL(doc);

         if (Utilities.isEmpty(urlstring)) {

             LOG.warn("No eventNotificationURL defined in EDLContent");

             return;

         }

         Document eventDoc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();

         Element eventE = eventDoc.createElement("event");

         eventE.setAttribute("type", eventName);

         eventDoc.appendChild(eventE);

         Element infoE = (Element) eventDoc.importNode(propertiesToXml(event, "info"), true);

         Element docIdE = eventDoc.createElement("docId");

         docIdE.appendChild(eventDoc.createTextNode(String.valueOf(docId)));

         infoE.appendChild(docIdE);

         eventE.appendChild(infoE);

         eventE.appendChild(eventDoc.importNode(doc.getDocumentElement(), true));

         String query = "docId=" + docId;

         if (urlstring.indexOf('?') != -1) {

             urlstring += "&" + query;

         } else {

             urlstring += "?" + query;

         }

         final String _urlstring = urlstring;

         final Document _eventDoc = eventDoc;

         // a super cheesy way to enforce asynchronicity/timeout follows:

         final Thread t = new Thread(new Runnable() {

             public void run() {

                 try {

                     LOG.debug("Post Event calling url: " + _urlstring);

                     submitURL(_urlstring, _eventDoc);

                     LOG.debug("Post Event done calling url: " + _urlstring);

                 } catch (Exception e) {

                     LOG.error(e);

                 }

             }

         });

         t.setDaemon(true);

         t.start();

         // kill the submission thread if it hasn't completed after 1 minute

         TIMER.schedule(new TimerTask() {

             public void run() {

                 t.interrupt();

             }

         }, SUBMIT_URL_MILLISECONDS_WAIT);

     }

     public ProcessDocReport doRouteStatusChange(DocumentRouteStatusChange event) throws Exception {

         LOG.debug("doRouteStatusChange: " + event);

         postEvent(event.getRouteHeaderId(), event, EVENT_TYPE_ROUTE_STATUS_CHANGE);

         return super.doRouteStatusChange(event);

     }

     public ProcessDocReport doActionTaken(ActionTakenEvent event) throws Exception {

         LOG.debug("doActionTaken: " + event);

         postEvent(event.getRouteHeaderId(), event, EVENT_TYPE_ACTION_TAKEN);

         return super.doActionTaken(event);

     }

     public ProcessDocReport doDeleteRouteHeader(DeleteEvent event) throws Exception {

         LOG.debug("doDeleteRouteHeader: " + event);

         postEvent(event.getRouteHeaderId(), event, EVENT_TYPE_DELETE_ROUTE_HEADER);

         return super.doDeleteRouteHeader(event);

     }

     public ProcessDocReport doRouteLevelChange(DocumentRouteLevelChange event) throws Exception {

         LOG.debug("doRouteLevelChange: " + event);

         postEvent(event.getRouteHeaderId(), event, EVENT_TYPE_ROUTE_LEVEL_CHANGE);

         return super.doRouteLevelChange(event);

     }

     public static Document getEDLContent(DocumentRouteHeaderValue routeHeader) throws Exception {

         String content = routeHeader.getDocContent();

         Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new InputSource(new StringReader(content)));

         return doc;

     }

     public static DocumentBuilder getDocumentBuilder() throws Exception {

         return DocumentBuilderFactory.newInstance().newDocumentBuilder();

     }

     private static String lowerCaseFirstChar(String s) {

         if (s.length() == 0 || Character.isLowerCase(s.charAt(0)))

             return s;

         StringBuffer sb = new StringBuffer(s.length());

         sb.append(Character.toLowerCase(s.charAt(0)));

         if (s.length() > 1) {

             sb.append(s.substring(1));

         }

         return sb.toString();

     }

     public static Element propertiesToXml(Object o, String elementName) throws Exception {

         Class c = o.getClass();

         Document doc = getDocumentBuilder().newDocument();

         Element wrapper = doc.createElement(elementName);

         Method[] methods = c.getMethods();

         for (int i = 0; i < methods.length; i++) {

             String name = methods[i].getName();

             if ("getClass".equals(name))

                 continue;

             if (!name.startsWith("get") || methods[i].getParameterTypes().length > 0)

                 continue;

             name = name.substring("get".length());

             name = lowerCaseFirstChar(name);

             String value = null;

             try {

                 Object result = methods[i].invoke(o, null);

                 if (result == null) {

                     LOG.debug("value of " + name + " method on object " + o.getClass() + " is null");

                     value = "";

                 } else {

                     value = result.toString();

                 }

                 Element fieldE = doc.createElement(name);

                 fieldE.appendChild(doc.createTextNode(value));

                 wrapper.appendChild(fieldE);

             } catch (RuntimeException e) {

                 LOG.error("Error accessing method '" + methods[i].getName() + " of instance of " + c);

                 throw e;

             } catch (Exception e) {

                 LOG.error("Error accessing method '" + methods[i].getName() + " of instance of " + c);

             }

         }

         return wrapper;

     }

 }