/*

  * 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.mail.service.impl;

 import org.apache.commons.lang.StringUtils;

 import org.apache.log4j.Logger;

 import org.kuali.rice.core.api.style.StyleService;

 import org.kuali.rice.core.mail.EmailContent;

 import org.kuali.rice.core.util.RiceConstants;

 import org.kuali.rice.core.util.xml.XmlHelper;

 import org.kuali.rice.core.util.xml.XmlJotter;

 import org.kuali.rice.kew.actionitem.ActionItem;

 import org.kuali.rice.kew.api.WorkflowRuntimeException;

 import org.kuali.rice.kew.doctype.bo.DocumentType;

 import org.kuali.rice.kew.feedback.web.FeedbackForm;

 import org.kuali.rice.kew.mail.CustomEmailAttribute;

 import org.kuali.rice.kew.mail.EmailStyleHelper;

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

 import org.kuali.rice.kew.routeheader.service.RouteHeaderService;

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

 import org.kuali.rice.kew.user.UserUtils;

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

 import org.kuali.rice.kim.api.identity.principal.Principal;

 import org.kuali.rice.kim.api.services.KimApiServiceLocator;

 import org.kuali.rice.kim.bo.Person;

 import org.kuali.rice.krad.util.GlobalVariables;

 import org.springframework.core.io.DefaultResourceLoader;

 import org.w3c.dom.Document;

 import org.w3c.dom.Element;

 import org.w3c.dom.Node;

 import javax.xml.parsers.DocumentBuilder;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.parsers.ParserConfigurationException;

 import javax.xml.transform.Templates;

 import javax.xml.transform.TransformerConfigurationException;

 import javax.xml.transform.TransformerException;

 import javax.xml.transform.TransformerFactory;

 import javax.xml.transform.dom.DOMSource;

 import javax.xml.transform.stream.StreamResult;

 import javax.xml.transform.stream.StreamSource;

 import java.io.StringWriter;

 import java.sql.Timestamp;

 import java.util.Collection;

 import java.util.Map;

 /**

  * EmailContentService that serves EmailContent customizable via XSLT style sheets

  * The global email style name is: kew.email.style

  * If this style is not found, the resource 'defaultEmailStyle.xsl' will be retrieved

  * relative to this class.

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

  */

 public class StyleableEmailContentServiceImpl extends BaseEmailContentServiceImpl {

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

     protected final String DEFAULT_EMAIL_STYLESHEET_RESOURCE_LOC = "defaultEmailStyle.xsl";

     protected StyleService styleService;

     protected EmailStyleHelper styleHelper = new EmailStyleHelper();

     protected String globalEmailStyleSheet = KEWConstants.EMAIL_STYLESHEET_NAME;

     protected RouteHeaderService routeHeaderService;

     public void setStyleService(StyleService styleService) {

         this.styleService = styleService;

     }

     public void setGlobalEmailStyleSheet(String globalEmailStyleSheet) {

         this.globalEmailStyleSheet = globalEmailStyleSheet;

     }

     protected static DocumentBuilder getDocumentBuilder(boolean coalesce) {

         try {

             DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

             dbf.setCoalescing(coalesce);

             return dbf.newDocumentBuilder();

         } catch (ParserConfigurationException e) {

             String message = "Error constructing document builder";

             LOG.error(message, e);

             throw new WorkflowRuntimeException(message, e);

         }

     }

     protected static void addObjectXML(Document doc, Object o, Node node, String name) throws Exception {

         Element element = XmlHelper.propertiesToXml(doc, o, name);

         if (LOG.isDebugEnabled()) {

             LOG.debug(XmlJotter.jotNode(element));

         }

         if (node == null) {

             node = doc;

         }

         node.appendChild(element);

     }

     protected static void addTextElement(Document doc, Element baseElement, String elementName, Object elementData) {

         Element element = doc.createElement(elementName);

         String dataValue = "";

         if (elementData != null) {

                 dataValue = elementData.toString();

         }

         element.appendChild(doc.createTextNode(dataValue));

         baseElement.appendChild(element);

     }

     protected static void addCDataElement(Document doc, Element baseElement, String elementName, Object elementData) {

         Element element = doc.createElement(elementName);

         String dataValue = "";

         if (elementData != null) {

             dataValue = elementData.toString();

         }

         element.appendChild(doc.createCDATASection(dataValue));

         baseElement.appendChild(element);

     }

     protected static void addTimestampElement(Document doc, Element baseElement, String elementName, Timestamp elementData) {

         addTextElement(doc, baseElement, elementName, RiceConstants.getDefaultDateFormat().format(elementData));

     }

     protected static void addDelegatorElement(Document doc, Element baseElement, ActionItem actionItem) {

         Element delegatorElement = doc.createElement("delegator");

         if ( (actionItem.getDelegatorWorkflowId() != null) && (actionItem.getDelegatorWorkflowId() != null) ) {

             // add empty delegator element

             baseElement.appendChild(delegatorElement);

             return;

         }

         String delegatorType = "";

         String delegatorId = "";

         String delegatorDisplayValue = "";

         if (actionItem.getDelegatorWorkflowId() != null) {

             delegatorType = "user";

             delegatorId = actionItem.getDelegatorWorkflowId();

             Principal delegator = KimApiServiceLocator.getIdentityService().getPrincipal(delegatorId);

             if (delegator == null) {

                     LOG.error("Cannot find user for id " + delegatorId);

                     delegatorDisplayValue = "USER NOT FOUND";

             } else {

                     delegatorDisplayValue = UserUtils.getTransposedName(GlobalVariables.getUserSession(), delegator);

             }

         } else if (actionItem.getDelegatorWorkflowId() != null) {

             delegatorType = "workgroup";

             delegatorId = actionItem.getDelegatorGroupId().toString();

             delegatorDisplayValue = KimApiServiceLocator.getGroupService().getGroup(actionItem.getDelegatorGroupId()).getName();

         }

         delegatorElement.setAttribute("type", delegatorType);

         // add the id element

         Element idElement = doc.createElement("id");

         idElement.appendChild(doc.createTextNode(delegatorId));

         delegatorElement.appendChild(idElement);

         // add the display value element

         Element displayValElement = doc.createElement("displayValue");

         displayValElement.appendChild(doc.createTextNode(delegatorDisplayValue));

         delegatorElement.appendChild(displayValElement);

         baseElement.appendChild(delegatorElement);

     }

     protected static void addWorkgroupRequestElement(Document doc, Element baseElement, ActionItem actionItem) {

         Element workgroupElement = doc.createElement("workgroupRequest");

         if (actionItem.isWorkgroupItem()) {

             // add the id element

             Element idElement = doc.createElement("id");

             idElement.appendChild(doc.createTextNode(actionItem.getGroupId()));

             workgroupElement.appendChild(idElement);

             // add the display value element

             Element displayValElement = doc.createElement("displayValue");

             displayValElement.appendChild(doc.createTextNode(actionItem.getGroupId()));

             workgroupElement.appendChild(displayValElement);

         }

         baseElement.appendChild(workgroupElement);

     }

     /**

      * This method is used to add the given {@link ActionItem} to the given {@link org.w3c.dom.Document} in a summarized

      * form for use in weekly or daily type reminder e-mails.

      *

      * @param doc - Document to have the ActionItem added to

      * @param actionItem - the action item being added

      * @param user - the current user

      * @param node - the node object to add the actionItem XML to (defaults to the doc variable if null is passed in)

      * @throws Exception

      */

     protected void addSummarizedActionItem(Document doc, ActionItem actionItem, Person user, Node node, DocumentRouteHeaderValue routeHeader) throws Exception {

         if (node == null) {

             node = doc;

         }

         Element root = doc.createElement("summarizedActionItem");

         // add in all items from action list as preliminary default dataset

         addTextElement(doc, root, "documentId", actionItem.getDocumentId());

         addTextElement(doc, root, "docName", actionItem.getDocName());

         addCDataElement(doc, root, "docLabel", actionItem.getDocLabel());

         addCDataElement(doc, root, "docTitle", actionItem.getDocTitle());

         //DocumentRouteHeaderValue routeHeader = getRouteHeader(actionItem);

         addTextElement(doc, root, "docRouteStatus", routeHeader.getDocRouteStatus());

         addCDataElement(doc, root, "routeStatusLabel", routeHeader.getRouteStatusLabel());

         addTextElement(doc, root, "actionRequestCd", actionItem.getActionRequestCd());

         addTextElement(doc, root, "actionRequestLabel", actionItem.getActionRequestLabel());

         addDelegatorElement(doc, root, actionItem);

         addTimestampElement(doc, root, "createDate", routeHeader.getCreateDate());

         addWorkgroupRequestElement(doc, root, actionItem);

         addTimestampElement(doc, root, "dateAssigned", actionItem.getDateAssigned());

         node.appendChild(root);

     }

     public DocumentRouteHeaderValue getRouteHeader(ActionItem actionItem) {

             if (routeHeaderService == null) {

                     routeHeaderService = KEWServiceLocator.getRouteHeaderService();

             }

         return routeHeaderService.getRouteHeader(actionItem.getDocumentId());

     }

     protected Map<String,DocumentRouteHeaderValue> getRouteHeaders(Collection<ActionItem> actionItems) {

             if (routeHeaderService == null) {

                     routeHeaderService = KEWServiceLocator.getRouteHeaderService();

             }

             return routeHeaderService.getRouteHeadersForActionItems(actionItems);

     }

     protected static String transform(Templates style, Document doc) {

         StringWriter writer = new StringWriter();

         StreamResult result = new StreamResult(writer);

         try {

             style.newTransformer().transform(new DOMSource(doc), result);

             return writer.toString();

         } catch (TransformerException te) {

             String message = "Error transforming DOM";

             LOG.error(message, te);

             throw new WorkflowRuntimeException(message, te);

         }

     }

     /**

      * This method retrieves the style from the system using the given name. If none is found the default style xsl file

      * defined by {@link #DEFAULT_EMAIL_STYLESHEET_RESOURCE_LOC} is used.

      *

      * @param styleName

      * @return a valid {@link javax.xml.transform.Templates} using either the given styleName or the default xsl style file

      */

     protected Templates getStyle(String styleName) {

         Templates style = null;

         try {

             style = styleService.getStyleAsTranslet(styleName);

         } catch (TransformerConfigurationException tce) {

             String message = "Error obtaining style '" + styleName + "', using default";

             LOG.error(message, tce);

             // throw new WorkflowRuntimeException("Error obtaining style '" + styleName + "'", tce);

         }

         if (style == null) {

             LOG.warn("Could not find specified style, " + styleName + ", using default");

             try {

                 style = TransformerFactory.newInstance().newTemplates(new StreamSource(new DefaultResourceLoader().getResource("classpath:org/kuali/rice/kew/mail/" + DEFAULT_EMAIL_STYLESHEET_RESOURCE_LOC).getInputStream()));

             } catch (Exception tce) {

                 String message = "Error obtaining default style from resource: " + DEFAULT_EMAIL_STYLESHEET_RESOURCE_LOC;

                 LOG.error(message, tce);

                 throw new WorkflowRuntimeException("Error obtaining style '" + styleName + "'", tce);

             }

         }

         return style;

     }

     protected EmailContent generateEmailContent(String styleName, Document doc) {

         Templates style = getStyle(styleName);

         return styleHelper.generateEmailContent(style, doc);

     }

     protected EmailContent generateReminderForActionItems(Person user, Collection<ActionItem> actionItems, String name, String style) {

         DocumentBuilder db = getDocumentBuilder(false);

         Document doc = db.newDocument();

         Element element = doc.createElement(name);

         Map<String,DocumentRouteHeaderValue> routeHeaders = getRouteHeaders(actionItems);

         setStandardAttributes(element);

         doc.appendChild(element);

         try {

             addObjectXML(doc, user, element, "user");

             for (ActionItem actionItem: actionItems) {

                 try {

                     addSummarizedActionItem(doc, actionItem, user, element, routeHeaders.get(actionItem.getDocumentId()));

                 } catch (Exception e) {

                     String message = "Error generating XML for action item: " + actionItem;

                     LOG.error(message, e);

                     throw new WorkflowRuntimeException(e);

                 }

             }

         } catch (Exception e) {

             String message = "Error generating XML for action items: " + actionItems;

             LOG.error(message, e);

             throw new WorkflowRuntimeException(e);

         }

         return generateEmailContent(style, doc);

     }

     protected void setStandardAttributes(Element e) {

         e.setAttribute("env", getDeploymentEnvironment());

         e.setAttribute("applicationEmailAddress", getApplicationEmailAddress());

         e.setAttribute("actionListUrl", getActionListUrl());

         e.setAttribute("preferencesUrl", getPreferencesUrl());

     }

     /**

      * This method generates an {@link EmailContent} object using the given parameters.  Part of this operation includes

      * serializing the given {@link ActionItem} to XML. The following objects and methods are included in the serialization:

      *

      * <ul>

      * <li>{@link Person}</li>

      * <li>{@link Person#getPrincipalName()}</li>

      * <li>{@link DocumentRouteHeaderValue}</li>

      * <li>{@link DocumentRouteHeaderValue#getInitiatorUser()}</li>

      * <li>{@link DocumentRouteHeaderValue#getDocumentType()}</li>

      * <li>{@link Person}</li>

      * </ul>

      *

      * @param user - the current user

      * @param actionItem - the action item being added

      * @param documentType - the document type that the custom email style sheet will come from

      * @param node - the node object to add the actionItem XML to (defaults to the doc variable if null is passed in)

      * @throws Exception

      */

     @Override

         public EmailContent generateImmediateReminder(Person user, ActionItem actionItem, DocumentType documentType) {

             LOG.info("Starting generation of immediate email reminder...");

             LOG.info("Action Id: " + actionItem.getActionItemId() + 

                              ";  ActionRequestId: " + actionItem.getActionRequestId() + 

                              ";  Action Item Principal Name: " + actionItem.getPerson().getPrincipalName());

             LOG.info("User Principal Name: " + user.getPrincipalName());

         // change style name based on documentType when configurable email style on document is implemented...

         String styleSheet = documentType.getCustomEmailStylesheet();

         LOG.debug(documentType.getName() + " style: " + styleSheet);

         if (styleSheet == null) {

             styleSheet = globalEmailStyleSheet;

         }

         LOG.info("generateImmediateReminder using style sheet: "+ styleSheet + " for Document Type " + documentType.getName());

 //        return generateReminderForActionItems(user, actionItems, "immediateReminder", styleSheet);

         DocumentBuilder db = getDocumentBuilder(false);

         Document doc = db.newDocument();

         Element element = doc.createElement("immediateReminder");

         setStandardAttributes(element);

         doc.appendChild(element);

         try {

             addObjectXML(doc, user, element, "user");

 //            addActionItem(doc, actionItem, user, node);

             Node node = element;

             if (node == null) {

                 node = doc;

             }

             Element root = doc.createElement("actionItem");

             // append the custom body and subject if they exist

             try {

                 CustomEmailAttribute customEmailAttribute = getCustomEmailAttribute(user, actionItem);

                 if (customEmailAttribute != null) {

                     String customBody = customEmailAttribute.getCustomEmailBody();

                     if (!org.apache.commons.lang.StringUtils.isEmpty(customBody)) {

                         Element bodyElement = doc.createElement("customBody");

                         bodyElement.appendChild(doc.createTextNode(customBody));

                         root.appendChild(bodyElement);

                     }

                     String customEmailSubject = customEmailAttribute.getCustomEmailSubject();

                     if (!org.apache.commons.lang.StringUtils.isEmpty(customEmailSubject)) {

                         Element subjectElement = doc.createElement("customSubject");

                         subjectElement.appendChild(doc.createTextNode(customEmailSubject));

                         root.appendChild(subjectElement);

                     }

                 }

             } catch (Exception e) {

                 LOG.error("Error when checking for custom email body and subject.", e);

             }

             Person person = actionItem.getPerson();

             DocumentRouteHeaderValue header = getRouteHeader(actionItem);

             // keep adding stuff until we have all the xml we need to formulate the message :/

             addObjectXML(doc, actionItem, root, "actionItem");

             addObjectXML(doc, person, root, "actionItemPerson");

             addTextElement(doc, root, "actionItemPrincipalId", person.getPrincipalId());

             addTextElement(doc, root, "actionItemPrincipalName", person.getPrincipalName());

             addDocumentHeaderXML(doc, header, root, "doc");

             addObjectXML(doc, header.getInitiatorPrincipal(), root, "docInitiator");

             addTextElement(doc, root, "docInitiatorDisplayName", header.getInitiatorDisplayName());

             addObjectXML(doc, header.getDocumentType(), root, "documentType");

             node.appendChild(root);

         } catch (Exception e) {

             String message = "Error generating immediate reminder XML for action item: " + actionItem;

             LOG.error(message, e);

             throw new WorkflowRuntimeException(e);

         }

         LOG.info("Leaving generation of immeidate email reminder...");

             /**

              * End IU customization

              */

         return generateEmailContent(styleSheet, doc);

     }

     /**

      * This method handles converting the DocumentRouteHeaderValue into an XML representation.  The reason we can't just use

      * propertiesToXml like we have elsewhere is because the doc header has a String attached to it that has the XML document

      * content in it.  The default serialization of this will serialize this as a String so we will end up with escaped XML

      * in our output which we won't be able to process with the email stylesheet.  So we need to read the xml content from

      * the document and parse it into a DOM object so it can be appended to our output.

      */

     protected void addDocumentHeaderXML(Document document, DocumentRouteHeaderValue documentHeader, Node node, String elementName) throws Exception {

             Element element = XmlHelper.propertiesToXml(document, documentHeader, elementName);

             // now we need to "fix" the xml document content because it's going to be in there as escaped XML

             Element docContentElement = (Element)element.getElementsByTagName("docContent").item(0);

             String documentContent = docContentElement.getTextContent();

             if (!StringUtils.isBlank(documentContent) && documentContent.startsWith("<")) {

                     Document documentContentXML = XmlHelper.readXml(documentContent);

                     Element documentContentElement = documentContentXML.getDocumentElement();

                     documentContentElement = (Element)document.importNode(documentContentElement, true);

                     // remove the old, bad text content

                     docContentElement.removeChild(docContentElement.getFirstChild());

                     // replace with actual XML

                     docContentElement.appendChild(documentContentElement);

             } else {

                     // in this case it means that the XML is encrypted, unfortunately, we have no way to decrypt it since

                     // the key is stored in the client application.  We will just include the doc content since none of our

                     // current IU clients will be using this feature right away

                     // remove the old, bad text content

                     docContentElement.removeChild(docContentElement.getFirstChild());

             }

             if (LOG.isDebugEnabled()) {

             LOG.debug(XmlJotter.jotNode(element));

         }

         node.appendChild(element);

     }

     @Override

         public EmailContent generateWeeklyReminder(Person user, Collection<ActionItem> actionItems) {

         return generateReminderForActionItems(user, actionItems, "weeklyReminder", globalEmailStyleSheet);

     }

     @Override

         public EmailContent generateDailyReminder(Person user, Collection<ActionItem> actionItems) {

         return generateReminderForActionItems(user, actionItems, "dailyReminder", globalEmailStyleSheet);

     }

     @Override

         public EmailContent generateFeedback(FeedbackForm form) {

         DocumentBuilder db = getDocumentBuilder(true);

         Document doc = db.newDocument();

         String styleSheet = globalEmailStyleSheet;

         // if the doc type is specified, see if that doc has a custom email stylesheet and use it

         // NOTE: do we need to do this for feedback? presumably feedback will be going back to admins

         /*String docTypeName = form.getDocumentType();

         if (!StringUtils.isBlank(docTypeName)) {

             DocumentType docType = KEWServiceLocator.getDocumentTypeService().findByName(docTypeName);

             if (docType == null) {

                 LOG.error("User specified document type '" + docTypeName + "' in feedback form, but the document type was not found in the system");

             } else {

                 if (docType.getCustomEmailStylesheet() != null) {

                     styleSheet = docType.getCustomEmailStylesheet();

                 }

             }

         }*/

         LOG.info("form: " + form.getDocumentId());

         try {

             addObjectXML(doc, form, null, "feedback");

         } catch (Exception e) {

             String message = "Error generating XML for feedback form: " + form;

             LOG.error(message, e);

             throw new WorkflowRuntimeException(message, e);

         }

         setStandardAttributes(doc.getDocumentElement());

         return generateEmailContent(styleSheet, doc);

     }

 }