/*
    * Copyright 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.ken.web.spring;
  
  import java.util.Date;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import org.apache.commons.lang.StringUtils;
  import org.apache.log4j.Logger;
  import org.kuali.rice.ken.bo.Notification;
  import org.kuali.rice.ken.bo.NotificationChannelReviewer;
  import org.kuali.rice.ken.document.kew.NotificationWorkflowDocument;
  import org.kuali.rice.ken.service.NotificationMessageContentService;
  import org.kuali.rice.ken.service.NotificationRecipientService;
  import org.kuali.rice.ken.service.NotificationWorkflowDocumentService;
  import org.kuali.rice.ken.util.NotificationConstants;
  import org.kuali.rice.ken.util.Util;
  import org.kuali.rice.kew.dto.NetworkIdDTO;
  import org.kuali.rice.kew.dto.WorkflowIdDTO;
  import org.kuali.rice.kew.service.WorkflowDocument;
  import org.kuali.rice.kim.bo.Person;
  import org.kuali.rice.kim.service.KIMServiceLocator;
  import org.kuali.rice.kim.util.KimConstants.KimGroupMemberTypes;
  import org.springframework.validation.BindException;
  import org.springframework.validation.ValidationUtils;
  import org.springframework.web.bind.ServletRequestBindingException;
  import org.springframework.web.servlet.ModelAndView;
  import org.springframework.web.servlet.mvc.multiaction.MultiActionController;
  
  
  /**
   * Implements reviewer Approve/Disapprove and initiator Acknowledge of a Notification requests
   * sent to channels configured with reviewers
   * @author Kuali Rice Team (rice.collab@kuali.org)
   */
  public class AdministerNotificationRequestController extends MultiActionController {
      private static final Logger LOG = Logger.getLogger(AdministerNotificationRequestController.class);
  
      /**
       * Command object for this controller
       */
      public static class AdministerNotificationRequestCommand {
          // incoming
          private Long docId;
  
          // outgoing
          private NotificationWorkflowDocument document;
          private Notification notification;
          private String renderedContent;
          private boolean valid = true;
          private String message;
  
          public Long getDocId() {
              return docId;
          }
          public void setDocId(Long docId) {
              this.docId = docId;
          }
          public NotificationWorkflowDocument getDocument() {
              return document;
          }
          public void setDocument(NotificationWorkflowDocument document) {
              this.document = document;
          }
          public Notification getNotification() {
              return notification;
          }
          public void setNotification(Notification notification) {
              this.notification = notification;
          }
          public String getRenderedContent() {
              return renderedContent;
          }
          public void setRenderedContent(String renderedContent) {
              this.renderedContent = renderedContent;
          }
          public boolean isValid() {
              return valid;
          }
          public void setValid(boolean valid) {
             this.valid = valid;
         }
         public String getMessage() {
             return message;
         }
         public void setMessage(String message) {
             this.message = message;
         }
     }
 
     protected NotificationMessageContentService messageContentService;
     protected NotificationWorkflowDocumentService workflowDocumentService;
     protected NotificationRecipientService recipientService;
 
     /**
      * Sets the messageContentService attribute value.
      * @param messageContentService the NotificationMessageContentService impl
      */
     public void setMessageContentService(
             NotificationMessageContentService notificationMessageContentService) {
         this.messageContentService = notificationMessageContentService;
     }
 
     /**
      * Sets the workflowDocumentService attribute value.
      * @param workflowDocumentService the NotificationWorkflowDocumentService impl
      */
     public void setWorkflowDocumentService(
             NotificationWorkflowDocumentService notificationWorkflowDocumentService) {
         this.workflowDocumentService = notificationWorkflowDocumentService;
     }
 
     /**
      * Sets the recipientService attribute value.
      * @param recipientService the NotificationRecipientService impl
      */
     public void setRecipientService(
             NotificationRecipientService notificationRecipientService) {
         this.recipientService = notificationRecipientService;
     }
 
     /**
      * Parses the serialized Notification xml from the workflow document application content into a reconstituted
      * Notification BO
      * @param document the WorkflowDocument
      * @return a Notification BO reconstituted from the serialized XML form in the workflow document
      * @throws Exception if parsing fails
      */
     private Notification retrieveNotificationForWorkflowDocument(WorkflowDocument document) throws Exception {
         String notificationAsXml = document.getApplicationContent();
 
         //parse out the application content into a Notification BO
         Notification notification = messageContentService.parseSerializedNotificationXml(notificationAsXml.getBytes());
 
         return notification;
     }
 
     /**
      * View action that displays an approve/disapprove/acknowledge view
      * @param request the HttpServletRequest
      * @param response the HttpServletResponse
      * @param command the command object bound for this MultiActionController
      * @return a view ModelAndView
      */
     public ModelAndView view(HttpServletRequest request, HttpServletResponse response, AdministerNotificationRequestCommand command) {
         // obtain a workflow user object first
         WorkflowIdDTO initiator = new WorkflowIdDTO(request.getRemoteUser());
 
         // now construct the workflow document, which will interact with workflow
         if (command.getDocId() == null) {
             throw new RuntimeException("An invalid document ID was recieved from KEW's action list.");
         }
 
         //check to see which view is being passed to us from the notification list - pop up or inline
         String view = request.getParameter(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.COMMAND);
         String standaloneWindow = "true";
         if(view != null && view.equals(NotificationConstants.NOTIFICATION_DETAIL_VIEWS.INLINE)) {
             standaloneWindow = "false";
         }
 
         NotificationWorkflowDocument document;
         Map<String, Object> model = new HashMap<String, Object>();
         // set into model whether we are dealing with a pop up or an inline window
         model.put(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.STANDALONE_WINDOW, standaloneWindow);
         try {
             document = new NotificationWorkflowDocument(initiator, new Long(command.getDocId()));
 
             Notification notification = retrieveNotificationForWorkflowDocument(document);
 
             // set up model
             command.setDocument(document);
             command.setNotification(notification);
             // render the event content according to registered XSLT stylesheet
             command.setRenderedContent(Util.transformContent(notification));
 
             LOG.info("notification auto remove date time: " + notification.getAutoRemoveDateTime());
             if (document.stateIsApproved()) {
                 command.setValid(false);
                 command.setMessage("This notification request has been approved.");
             } else if (document.stateIsDisapproved()) {
                 command.setMessage("This notification request has been disapproved.");
             } else if (notification.getAutoRemoveDateTime() != null && notification.getAutoRemoveDateTime().before(new Date(System.currentTimeMillis()))) {
                 /*if (!document.stateIsCanceled()) {
                 workflowDocumentService.terminateWorkflowDocument(new WorkflowDocument(new NetworkIdVO("notsys"), new Long(command.getDocId())));
                 }*/
                 // the autoremove date time has already passed...this notification request is null and void at this time
                 boolean disapproved = document.stateIsDisapproved();
                 if (!document.stateIsDisapproved()) {
                     List<NotificationChannelReviewer> reviewers = notification.getChannel().getReviewers();
                     String user = null;
                     for (NotificationChannelReviewer reviewer: reviewers) {
                         if (KimGroupMemberTypes.PRINCIPAL_MEMBER_TYPE.equals(reviewer.getReviewerType())) {
                             if (reviewer.getReviewerId().equals(request.getRemoteUser())) {
                                 user = request.getRemoteUser();
                             }
                         } else if (KimGroupMemberTypes.GROUP_MEMBER_TYPE.equals(reviewer.getReviewerType())) {
                             // if it's a group
                             String[] members = recipientService.getGroupMembers(reviewer.getReviewerId());
                             for (String member: members) {
                                 if (StringUtils.equals(member, request.getRemoteUser())) {
                                     user = request.getRemoteUser();
                                     break;
                                 }
                             }
                         }
                     }
                     // if the current user is a reviewer, then disapprove as that user
                     if (user != null) {
                         new WorkflowDocument(new NetworkIdDTO(user), new Long(command.getDocId())).disapprove("Disapproving notification request.  Auto-remove datetime has already passed.");
                         disapproved = true;
                     }
                 }
                 command.setValid(false);
                 if (disapproved) {
                     command.setMessage("This notification request is no longer valid because the Auto-Remove date has already passed.  It has been disapproved.  Please refresh your action list.");
                 } else {
                     command.setMessage("This notification request is no longer valid because the Auto-Remove date has already passed.");
                 }
             }
 
             model.put(getCommandName(command), command);
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
 
         return new ModelAndView("ViewNotificationRequestDetails", model);
     }
 
     /**
      * Approve action that approves a notification request
      * @param request the HttpServletRequest
      * @param response the HttpServletResponse
      * @param command the command object bound for this MultiActionController
      * @return a view ModelAndView
      * @throws ServletException if an error occurs during approval
      */
     public ModelAndView approve(HttpServletRequest request, HttpServletResponse response, AdministerNotificationRequestCommand command) throws ServletException {
         administerEventNotificationMessage(request, response, command, "approve");
         Map<String, Object> model = new HashMap<String, Object>();
         model.put("workflowActionTaken", "Approved");
         model.put(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.STANDALONE_WINDOW, request.getParameter(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.STANDALONE_WINDOW));
         return new ModelAndView("SendNotificationRequestActionTakenWindow", model);
     }
 
     /**
      * Disapprove action that disapproves a notification request
      * @param request the HttpServletRequest
      * @param response the HttpServletResponse
      * @param command the command object bound for this MultiActionController
      * @return a view ModelAndView
      * @throws ServletException if an error occurs during disapproval
      */
     public ModelAndView disapprove(HttpServletRequest request, HttpServletResponse response, AdministerNotificationRequestCommand command) throws ServletException {
         administerEventNotificationMessage(request, response, command, "disapprove");
         Map<String, Object> model = new HashMap<String, Object>();
         model.put("workflowActionTaken", "Disapproved");
         model.put(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.STANDALONE_WINDOW, request.getParameter(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.STANDALONE_WINDOW));
         return new ModelAndView("SendNotificationRequestActionTakenWindow", model);
     }
 
     /**
      * Acknowledge action that acknowledges a notification request disapproval
      * @param request the HttpServletRequest
      * @param response the HttpServletResponse
      * @param command the command object bound for this MultiActionController
      * @return a view ModelAndView
      * @throws ServletException if an error occurs during acknowledgement
      */
     public ModelAndView acknowledge(HttpServletRequest request, HttpServletResponse response, AdministerNotificationRequestCommand command) throws ServletException {
         administerEventNotificationMessage(request, response, command, "acknowledge");
         Map<String, Object> model = new HashMap<String, Object>();
         model.put(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.STANDALONE_WINDOW, request.getParameter(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.STANDALONE_WINDOW));
         model.put("workflowActionTaken", "Acknowledged");
         return new ModelAndView("SendNotificationRequestActionTakenWindow", model);
     }
 
     /**
      * This method handles approval/disapproval/acknowledgement of the notification request
      * @param request the HttpServletRequest
      * @param response the HttpServletResponse
      * @param command the command object bound for this MultiActionController
      * @throws ServletException
      */
     private void administerEventNotificationMessage(HttpServletRequest request, HttpServletResponse response, AdministerNotificationRequestCommand command, String action) throws ServletException {
         LOG.debug("remoteUser: " + request.getRemoteUser());
 
         BindException bindException = new BindException(command, "command");
         ValidationUtils.rejectIfEmpty(bindException, "docId", "Document id must be specified");
         if (bindException.hasErrors()) {
             throw new ServletRequestBindingException("Document id must be specified", bindException);
         }
 
         // obtain a workflow user object first
         WorkflowIdDTO user = new WorkflowIdDTO(request.getRemoteUser());
 
         try {
             // now construct the workflow document, which will interact with workflow
             NotificationWorkflowDocument document = new NotificationWorkflowDocument(user, command.getDocId());
 
             Notification notification = retrieveNotificationForWorkflowDocument(document);
 
             String initiatorPrincipalId = document.getRouteHeader().getInitiatorPrincipalId();
             Person initiator = KIMServiceLocator.getPersonService().getPerson(initiatorPrincipalId);
             String notificationBlurb =  notification.getContentType().getName() + " notification submitted by " + initiator.getName() + " for channel " + notification.getChannel().getName();
             if ("disapprove".equals(action)) {
                 document.disapprove("User " + user.getWorkflowId() + " disapproving " + notificationBlurb);
             } else if ("approve".equals(action)) {
                 document.approve("User " + user.getWorkflowId() + " approving " + notificationBlurb);
             } else if ("acknowledge".equals(action)) {
                 document.acknowledge("User " + user.getWorkflowId() + " acknowledging " + notificationBlurb);
             }
         } catch (Exception e) {
             LOG.error("Exception occurred taking action on notification request", e);
             throw new ServletException("Exception occurred taking action on notification request", e);
         }
     }
 }