/*

  * Copyright 2006-2011 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.service.impl;

 import org.kuali.rice.core.framework.persistence.dao.GenericDao;

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

 import org.kuali.rice.ken.bo.Notification;

 import org.kuali.rice.ken.bo.NotificationMessageDelivery;

 import org.kuali.rice.ken.bo.NotificationRecipient;

 import org.kuali.rice.ken.bo.NotificationResponse;

 import org.kuali.rice.ken.dao.NotificationDao;

 import org.kuali.rice.ken.deliverer.impl.KEWActionListMessageDeliverer;

 import org.kuali.rice.ken.service.NotificationAuthorizationService;

 import org.kuali.rice.ken.service.NotificationMessageContentService;

 import org.kuali.rice.ken.service.NotificationMessageDeliveryService;

 import org.kuali.rice.ken.service.NotificationRecipientService;

 import org.kuali.rice.ken.service.NotificationService;

 import org.kuali.rice.ken.service.NotificationWorkflowDocumentService;

 import org.kuali.rice.ken.util.NotificationConstants;

 import java.io.IOException;

 import java.sql.Timestamp;

 import java.util.Collection;

 import java.util.HashMap;

 //import org.kuali.rice.core.jpa.criteria.Criteria;

 /**

  * NotificationService implementation - this is the default out-of-the-box implementation of the service.

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

  */

 public class NotificationServiceImpl implements NotificationService {

         private static org.apache.log4j.Logger LOG = org.apache.log4j.Logger

         .getLogger(NotificationServiceImpl.class);

         private GenericDao businessObjectDao;

         private NotificationDao notDao;

         private NotificationMessageContentService messageContentService;

         private NotificationAuthorizationService notificationAuthorizationService;

         private NotificationRecipientService notificationRecipientService;

         private NotificationWorkflowDocumentService notificationWorkflowDocumentService;

         private NotificationMessageDeliveryService notificationMessageDeliveryService;

         /**

          * Constructs a NotificationServiceImpl class instance.

          * @param businessObjectDao

          * @param messageContentService

          * @param notificationAuthorizationService

          * @param notificationRecipientService

          * @param notificationWorkflowDocumentService

          * @param notificationMessageDeliveryService

          */

         public NotificationServiceImpl(GenericDao businessObjectDao, NotificationMessageContentService messageContentService,

                         NotificationAuthorizationService notificationAuthorizationService, NotificationRecipientService notificationRecipientService, 

                         NotificationWorkflowDocumentService notificationWorkflowDocumentService, 

                         NotificationMessageDeliveryService notificationMessageDeliveryService,

                         NotificationDao notDao) {

                 this.businessObjectDao = businessObjectDao;

                 this.messageContentService = messageContentService;

                 this.notificationAuthorizationService = notificationAuthorizationService;

                 this.notificationRecipientService = notificationRecipientService;

                 this.notificationWorkflowDocumentService = notificationWorkflowDocumentService;

                 this.notificationMessageDeliveryService = notificationMessageDeliveryService;

                 this.notDao = notDao;

         }

         /**

          * This is the default implementation that uses the businessObjectDao.

          * @see org.kuali.rice.ken.service.NotificationService#getNotification(java.lang.Long)

          */

         public Notification getNotification(Long id) {

                 HashMap<String, Long> primaryKeys = new HashMap<String, Long>();

                 primaryKeys.put(NotificationConstants.BO_PROPERTY_NAMES.ID, id);

                 return (Notification) businessObjectDao.findByPrimaryKey(Notification.class, primaryKeys);

         }

         /**

          * This method is responsible for parsing out the notification message which is sent in as a String 

          * of XML.  It calls the appropriate services to validate the message content, converts it to a BO, 

          * and then passes it to another service where its content and meta-data is validated and if successful, it 

          * is saved.

          * @see org.kuali.rice.ken.service.NotificationService#sendNotification(java.lang.String)

          */

         public NotificationResponse sendNotification(String notificationMessageAsXml) throws IOException, XmlException {

                 // try to parse out the XML with the message content service

                 Notification notification = messageContentService.parseNotificationRequestMessage(notificationMessageAsXml);

                 // now call out to the meat of the notification sending - this will validate users, groups, producers, and save

                 return sendNotification(notification);

         }

         /**

          * @see org.kuali.rice.ken.service.NotificationService#sendNotification(org.kuali.rice.ken.bo.Notification)

          */

         public NotificationResponse sendNotification(Notification notification) {

                 NotificationResponse response = new NotificationResponse();

                 // make sure that the producer is able to send notifications on behalf of the channel

                 boolean producerAuthorizedForChannel = notificationAuthorizationService.isProducerAuthorizedToSendNotificationForChannel(notification.getProducer(), notification.getChannel());

                 if(!producerAuthorizedForChannel) {

                         LOG.error("Producer " + notification.getProducer() + " is not authorized to send messages to channel " + notification.getChannel());

                         response.setStatus(NotificationConstants.RESPONSE_STATUSES.FAILURE);

                         response.setMessage(NotificationConstants.RESPONSE_MESSAGES.PRODUCER_NOT_AUTHORIZED_FOR_CHANNEL);

                         return response;

                 }

                 // make sure that the recipients are valid

                 for(int i = 0; i < notification.getRecipients().size(); i++) {

                         NotificationRecipient recipient = notification.getRecipient(i);

                         boolean validRecipient = notificationRecipientService.isRecipientValid(recipient.getRecipientId(), recipient.getRecipientType());

                         if(!validRecipient) {

                                 response.setStatus(NotificationConstants.RESPONSE_STATUSES.FAILURE);

                                 response.setMessage(NotificationConstants.RESPONSE_MESSAGES.INVALID_RECIPIENT + " - recipientId=" + 

                                                 recipient.getRecipientId() + ", recipientType=" + recipient.getRecipientType());

                                 return response;

                         }

                 }

                 // set the creationDateTime attribute to the current timestamp if it's currently null

                 if (notification.getCreationDateTime() == null) {

                         notification.setCreationDateTime(new Timestamp(System.currentTimeMillis()));

                 }

                 // set the sendDateTime attribute to the current timestamp if it's currently null

                 if(notification.getSendDateTime() == null) {

                         notification.setSendDateTime(new Timestamp(System.currentTimeMillis()));

                 }

                 // if the autoremove time is before the send date time, reject the notification

                 if (notification.getAutoRemoveDateTime() != null) {

                         if (notification.getAutoRemoveDateTime().before(notification.getSendDateTime()))  {

                                 response.setStatus(NotificationConstants.RESPONSE_STATUSES.FAILURE);

                                 response.setMessage(NotificationConstants.RESPONSE_MESSAGES.INVALID_REMOVE_DATE);

                                 return response;

                         }

                 }

                 // make sure the delivery types are valid

                 if(!notification.getDeliveryType().equalsIgnoreCase(NotificationConstants.DELIVERY_TYPES.ACK) && 

                                 !notification.getDeliveryType().equalsIgnoreCase(NotificationConstants.DELIVERY_TYPES.FYI)) {

                         response.setStatus(NotificationConstants.RESPONSE_STATUSES.FAILURE);

                         response.setMessage(NotificationConstants.RESPONSE_MESSAGES.INVALID_DELIVERY_TYPE + " - deliveryType=" + 

                                         notification.getDeliveryType());

                         return response;

                 }

                 // now try to persist the object

                 try {

                         businessObjectDao.save(notification);

                 } catch(Exception e) {

                         response.setStatus(NotificationConstants.RESPONSE_STATUSES.FAILURE);

                         response.setMessage(NotificationConstants.RESPONSE_MESSAGES.ERROR_SAVING_NOTIFICATION);

                         return response;

                 }

                 // everything looks good!

                 response.setMessage(NotificationConstants.RESPONSE_MESSAGES.SUCCESSFULLY_RECEIVED);

                 response.setNotificationId(notification.getId());

                 return response;

         }

         /**

          * This is the default implementation that uses the businessObjectDao and its findMatching method.

          * @see org.kuali.rice.ken.service.NotificationService#getNotificationsForRecipientByType(java.lang.String, java.lang.String)

          */

         public Collection getNotificationsForRecipientByType(String contentTypeName, String recipientId) {

                 HashMap<String, String> queryCriteria = new HashMap<String, String>();

                 queryCriteria.put(NotificationConstants.BO_PROPERTY_NAMES.CONTENT_TYPE_NAME, contentTypeName);

                 queryCriteria.put(NotificationConstants.BO_PROPERTY_NAMES.RECIPIENTS_RECIPIENT_ID, recipientId);

                 return businessObjectDao.findMatching(Notification.class, queryCriteria);

         }

         /**

          * @see org.kuali.rice.ken.service.NotificationService#dismissNotificationMessageDelivery(java.lang.Long, java.lang.String)

          */

         public void dismissNotificationMessageDelivery(Long id, String user, String cause) {

                 // TODO: implement pessimistic locking on the message delivery

                 NotificationMessageDelivery nmd = notificationMessageDeliveryService.getNotificationMessageDelivery(id);

                 dismissNotificationMessageDelivery(nmd, user, cause);

         }

         /**

          * @see org.kuali.rice.ken.service.NotificationService#dismissNotificationMessageDelivery(org.kuali.rice.ken.bo.NotificationMessageDelivery, java.lang.String, java.lang.String)

          */   

         public void dismissNotificationMessageDelivery(NotificationMessageDelivery nmd, String user, String cause) {

                 // get the notification that generated this particular message delivery

                 Notification notification = nmd.getNotification();

                 // get all of the other deliveries of this notification for the user

                 Collection<NotificationMessageDelivery> userDeliveries = notificationMessageDeliveryService.getNotificationMessageDeliveries(notification, nmd.getUserRecipientId());

                 final String targetStatus;

                 // if the cause was our internal "autoremove" cause, then we need to indicate

                 // the message was autoremoved instead of normally dismissed

                 if (NotificationConstants.AUTO_REMOVE_CAUSE.equals(cause)) {

                         targetStatus = NotificationConstants.MESSAGE_DELIVERY_STATUS.AUTO_REMOVED;

                 } else {

                         targetStatus = NotificationConstants.MESSAGE_DELIVERY_STATUS.REMOVED;

                 }

                 KEWActionListMessageDeliverer deliverer = new KEWActionListMessageDeliverer();

                 // TODO: implement pessimistic locking on all these message deliveries

                 // now, do dispatch in reverse...dismiss each message delivery via the appropriate deliverer

                 for (NotificationMessageDelivery messageDelivery: userDeliveries) {

                         // don't attempt to dismiss undelivered message deliveries

                         if (!NotificationConstants.MESSAGE_DELIVERY_STATUS.DELIVERED.equals(messageDelivery.getMessageDeliveryStatus())) {

                                 LOG.info("Skipping dismissal of non-delivered message delivery #" + messageDelivery.getId());

                         } else if (targetStatus.equals(messageDelivery.getMessageDeliveryStatus())) {

                                 LOG.info("Skipping dismissal of already removed message delivery #" + messageDelivery.getId());

                         } else {

                                 LOG.debug("Dismissing message delivery #" + messageDelivery.getId() + " " + messageDelivery.getVersionNumber());//.getLockVerNbr());

                                 // we have our message deliverer, so tell it to dismiss the message

                                 //try {

                                 deliverer.dismissMessageDelivery(messageDelivery, user, cause);

                                 //} catch (NotificationMessageDismissalException nmde) {

                                 //LOG.error("Error dismissing message " + messageDelivery, nmde);

                                 //throw new RuntimeException(nmde);

                                 //}

                         }

                         // by definition we have succeeded at this point if no exception was thrown by the messageDeliverer

                         // so update the status of the delivery message instance to indicate its dismissal

                         // if the message delivery was not actually delivered in the first place, we still need to mark it as

                         // removed here so delivery is not attempted again

                         messageDelivery.setMessageDeliveryStatus(targetStatus);

                         // TODO: locking

                         // mark as unlocked

                         //messageDelivery.setLockedDate(null);

                         LOG.debug("Saving message delivery #" + messageDelivery.getId() + " " + messageDelivery.getVersionNumber());

                         businessObjectDao.save(messageDelivery);

                         LOG.debug("Message delivery '" + messageDelivery.getId() + "' for notification '" + messageDelivery.getNotification().getId() + "' was successfully dismissed.");

                 }

         }

         /**

          * This method is responsible for atomically finding all untaken, unresolved notifications that are ready to be sent,

          * marking them as taken and returning them to the caller for processing.

          * NOTE: it is important that this method execute in a SEPARATE dedicated transaction; either the caller should

          * NOT be wrapped by Spring declarative transaction and this service should be wrapped (which is the case), or

          * the caller should arrange to invoke this from within a newly created transaction).

          * @return a list of available notifications that have been marked as taken by the caller

          */

         //switch to JPA criteria

         public Collection<Notification> takeNotificationsForResolution() {

                 // get all unprocessed notifications with sendDateTime <= current

 //                Criteria criteria = new Criteria();

 //                criteria.addEqualTo(NotificationConstants.BO_PROPERTY_NAMES.PROCESSING_FLAG, NotificationConstants.PROCESSING_FLAGS.UNRESOLVED);

 //                criteria.addLessOrEqualThan(NotificationConstants.BO_PROPERTY_NAMES.SEND_DATE_TIME, new Timestamp(System.currentTimeMillis()));

 //                criteria.addIsNull(NotificationConstants.BO_PROPERTY_NAMES.LOCKED_DATE);

                 //criteria = Util.makeSelectForUpdate(criteria);

                 //                Criteria criteria = new Criteria(Notification.class.getName());

                 //                criteria.eq(NotificationConstants.BO_PROPERTY_NAMES.PROCESSING_FLAG, NotificationConstants.PROCESSING_FLAGS.UNRESOLVED);

                 //                criteria.lte(NotificationConstants.BO_PROPERTY_NAMES.SEND_DATE_TIME, new Timestamp(System.currentTimeMillis()));

                 //                criteria.isNull(NotificationConstants.BO_PROPERTY_NAMES.LOCKED_DATE);

                 //Collection<Notification> available_notifications = businessObjectDao.findMatching(Notification.class, criteria, true, RiceConstants.NO_WAIT);

                 Collection<Notification> available_notifications = notDao.findMatchedNotificationsForResolution(new Timestamp(System.currentTimeMillis()), businessObjectDao);

                 //LOG.debug("Available notifications: " + available_notifications.size());

                 // mark as "taken"

                 if (available_notifications != null) {

                         for (Notification notification: available_notifications) {

                                 LOG.info("notification: " + notification);

                                 notification.setLockedDate(new Timestamp(System.currentTimeMillis()));

                                 businessObjectDao.save(notification);

                         }

                 }

                 return available_notifications;

         }

         /**

          * Unlocks specified notification

          * @param notification the notification object to unlock

          */

         //switch to JPA criteria

         public void unlockNotification(Notification notification) {

 //                Map<String, Long> criteria = new HashMap<String, Long>();

 //                criteria.put(NotificationConstants.BO_PROPERTY_NAMES.ID, notification.getId());

 //                Criteria criteria = new Criteria();

 //                criteria.addEqualTo(NotificationConstants.BO_PROPERTY_NAMES.ID, notification.getId());

                 //criteria = Util.makeSelectForUpdate(criteria);

                 //                Criteria criteria = new Criteria(Notification.class.getName());

                 //                criteria.eq(NotificationConstants.BO_PROPERTY_NAMES.ID, notification.getId());

                 //Collection<Notification> notifications = businessObjectDao.findMatching(Notification.class, criteria, true, RiceConstants.NO_WAIT);

                 Collection<Notification> notifications = notDao.findMatchedNotificationsForUnlock(notification, businessObjectDao);

                 if (notifications == null || notifications.size() == 0) {

                         throw new RuntimeException("Notification #" + notification.getId() + " not found to unlock");

                 }

                 Notification n = notifications.iterator().next();

                 n.setLockedDate(null);

                 businessObjectDao.save(n);

         }

 }