/*

  * ============================================================================

  *                   GNU Lesser General Public License

  * ============================================================================

  *

  * Taylor - The Java Enterprise Application Framework.

  * Copyright (C) 2005 John Gilbert jgilbert01@users.sourceforge.net

  *

  * This library is free software; you can redistribute it and/or

  * modify it under the terms of the GNU Lesser General Public

  * License as published by the Free Software Foundation; either

  * version 2.1 of the License, or (at your option) any later version.

  *

  * This library is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  * Lesser General Public License for more details.

  *

  * You should have received a copy of the GNU Lesser General Public

  * License along with this library; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.

  *

  * John Gilbert

  * Email: jgilbert01@users.sourceforge.net

  */

 package net.taylor.audit;

 import java.io.Serializable;

 import java.lang.reflect.Method;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Date;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import javax.jms.JMSException;

 import javax.jms.Message;

 import javax.jms.ObjectMessage;

 import javax.jms.Session;

 import javax.persistence.Embeddable;

 import javax.persistence.Entity;

 import net.taylor.audit.entity.Action;

 import net.taylor.audit.entity.AuditEntry;

 import net.taylor.audit.entity.AuditField;

 import net.taylor.jms.JmsSender;

 import net.taylor.jms.MessageCallback;

 import net.taylor.jpa.JpaUtil;

 import net.taylor.lang.ReflectionUtil;

 import net.taylor.security.JAASUtil;

 import org.apache.commons.collections.CollectionUtils;

 import org.apache.commons.lang.StringUtils;

 import org.apache.commons.lang.builder.ToStringBuilder;

 import org.apache.commons.lang.builder.ToStringStyle;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import org.hibernate.collection.PersistentCollection;

 import org.hibernate.engine.CollectionEntry;

 import org.hibernate.event.AbstractCollectionEvent;

 import org.hibernate.event.PostCollectionRecreateEvent;

 import org.hibernate.event.PostCollectionRecreateEventListener;

 import org.hibernate.event.PostDeleteEvent;

 import org.hibernate.event.PostDeleteEventListener;

 import org.hibernate.event.PostInsertEvent;

 import org.hibernate.event.PostInsertEventListener;

 import org.hibernate.event.PostUpdateEvent;

 import org.hibernate.event.PostUpdateEventListener;

 import org.hibernate.event.PreCollectionRemoveEvent;

 import org.hibernate.event.PreCollectionRemoveEventListener;

 import org.hibernate.event.PreCollectionUpdateEvent;

 import org.hibernate.event.PreCollectionUpdateEventListener;

 public class AuditListener implements PostDeleteEventListener,

                 PostInsertEventListener, PostUpdateEventListener, PreCollectionUpdateEventListener, PreCollectionRemoveEventListener,

         PostCollectionRecreateEventListener {

         protected static final long serialVersionUID = 1L;

         protected static final Log logger = LogFactory.getLog(AuditListener.class);

         public void onPostInsert(PostInsertEvent event) {

                 if (event.getId() == null) {

                         return;

                 }

                 if (bypass(event.getEntity().getClass())) {

                         return;

                 }

                 queue(Action.INSERT, event.getEntity().getClass().getName(), (Long) event

                                 .getId(), event.getPersister().getPropertyNames(), null, event

                                 .getState());

         }

         public void onPostUpdate(PostUpdateEvent event) {

                 if (bypass(event.getEntity().getClass())) {

                         return;

                 }

                 queue(Action.UPDATE, event.getEntity().getClass().getName(), (Long) event

                                 .getId(), event.getPersister().getPropertyNames(), event

                                 .getOldState(), event.getState());

         }

         public void onPostDelete(PostDeleteEvent event) {

                 if (bypass(event.getEntity().getClass())) {

                         return;

                 }

                 queue(Action.DELETE, event.getEntity().getClass().getName(), (Long) event

                                 .getId(), null, null, null);

         }

         @SuppressWarnings("unchecked")

         protected boolean bypass(Class entityClass) {

                 if (entityClass.isAnnotationPresent(BypassAudit.class)) {

                         return true;

                 }

                 return false;

         }

         protected void queue(final Action action, final String entityName,

                         final Long id, final String[] names, final Object[] oldValues,

                         final Object[] newValues) {

                 final AuditEntry ae = createAuditEntry(entityName, id, action);

                 if (names != null) {

                         addAuditFields(ae, names, oldValues, newValues);

                 }

                 publish(ae);

         }

         public static final String ACTION = "action";

         public static final String ENTITY_NAME = "entityName";

         public static final String ENTITY_ID = "entityId";

         public static final String INSERT = "INSERT";

         public static final String UPDATE = "UPDATE";

         public static final String DELETE = "DELETE";

         protected void publish(final AuditEntry ae) {

                 JmsSender.unmanagedSend("topic/net.taylor.AuditTopic", new MessageCallback() {

                         public Message createMessage(Session session) throws JMSException {

                                 ObjectMessage msg = session.createObjectMessage();

                                 msg.setStringProperty(ACTION, ae.getAction().name());

                                 msg.setStringProperty(ENTITY_NAME, ae.getEntityName());

                                 msg.setLongProperty(ENTITY_ID, ae.getEntityId());

                                 msg.setObject(ae);

                                 return msg;

                         }

                 });                        

         }

         protected AuditEntry createAuditEntry(String entityName, Long entityId,

                         Action action) {

                 AuditEntry ae = new AuditEntry();

                 if (JAASUtil.getPrincipal() == null) {

                         ae.setUser("system");

                 } else {

                         ae.setUser(JAASUtil.getPrincipal().getName());

                 }

                 ae.setTimestamp(new Date());

                 ae.setEntityName(entityName);

                 ae.setEntityId(entityId);

                 ae.setAction(action);

                 if (logger.isDebugEnabled()) {

                         logger.debug(ToStringBuilder.reflectionToString(ae,

                                         ToStringStyle.MULTI_LINE_STYLE));

                 }

                 return ae;

         }

         protected AuditField createAuditField(String name, Object oldValue,

                         Object newValue) {

                 AuditField af = new AuditField();

                 af.setName(name);

                 af.setNewValue(getValue(newValue));

                 af.setOldValue(getValue(oldValue));

                 if (logger.isDebugEnabled()) {

                         logger.debug(ToStringBuilder.reflectionToString(af,

                                         ToStringStyle.MULTI_LINE_STYLE));

                 }

                 return af;

         }

         protected String getValue(Object v) {

                 if (v == null) {

                         return null;

                 }

                 if (v.getClass().isAnnotationPresent(Entity.class)) {

                         // handle display of m2o associations

                         String[] names = { "getName", "getCode", "getTitle", "getDescription" };

                         for (String name : names) {

                                 String value = get(v, name);

                                 if (value != null) {

                                         return value;

                                 }

                         }

                         return JpaUtil.getNaturalId(v).toString();

                 }

                 return v.toString();

         }

         private String get(Object o, String name) {

                 try {

                         Method m = o.getClass().getMethod(name, new Class[] {});

                         if (m == null) {

                                 return null;

                         }

                         return (String) m.invoke(o, new Object[0]);

                 } catch (Exception ex) {

                         return null;

                 }

         }

         protected void addAuditFields(AuditEntry ae, String[] names,

                         Object[] oldValues, Object[] newValues) {

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

                         Object ov = oldValues == null ? null : oldValues[i];

                         Object nv = newValues == null ? null : newValues[i];

                         if (isCollection(ov, nv)) {

                                 continue;

                         } else if (isEmbedded(ov, nv)) {

                                 handleEmbedded(ae, names[i], ov, nv);

                         } else if (hasChanged(ov, nv)) {

                                 ae.addField(createAuditField(names[i], ov, nv));

                         }

                 }

         }

         protected boolean isCollection(Object oldValue, Object newValue) {

                 Object value = oldValue;

                 if (value == null) {

                         value = newValue;

                 }

                 if (value == null) {

                         return false;

                 }

                 return value instanceof Collection;

         }

         protected boolean isEmbedded(Object oldValue, Object newValue) {

                 Object value = oldValue;

                 if (value == null) {

                         value = newValue;

                 }

                 if (value == null) {

                         return false;

                 }

                 return value.getClass().isAnnotationPresent(Embeddable.class);

         }

         protected void handleEmbedded(AuditEntry ae, String name, Object oldValue,

                         Object newValue) {

                 try {

                         Map<String, Object> oldValues = describe(oldValue);

                         Map<String, Object> newValues = describe(newValue);

                         Set<String> names = newValues.keySet();

                         for (String key : names) {

                                 if ("class".equals(key)) {

                                         continue;

                                 }

                                 Object ov = oldValues.get(key);

                                 Object nv = newValues.get(key);

                                 if (isEmbedded(ov, nv)) {

                                         handleEmbedded(ae, name + "." + key, ov, nv);

                                 } else if (hasChanged(ov, nv)) {

                                         ae.addField(createAuditField(name + "." + key, ov, nv));

                                 }

                         }

                 } catch (Exception e) {

                         throw new RuntimeException(e);

                 }

         }

         protected boolean hasChanged(Object oldValue, Object newValue) {

                 return (oldValue != null && newValue != null && !oldValue

                                 .equals(newValue))

                                 || (oldValue != null && newValue == null)

                                 || (oldValue == null && newValue != null);

         }

         protected Map<String, Object> describe(Object object) {

                 Map<String, Object> properties = new HashMap<String, Object>();

                 if (object != null) {

                         List<Method> list = new ArrayList<Method>();

                         Method[] methods = object.getClass().getMethods();

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

                                 Method method = methods[i];

                                 if (method.getName().startsWith("get")) {

                                         list.add(method);

                                 }

                         }

                         for (Method method : list) {

                                 String name = method.getName();

                                 name = name.substring(3);

                                 name = StringUtils.uncapitalize(name);

                                 properties.put(name, ReflectionUtil.invoke(method, object,

                                                 new Object[] {}));

                         }

                 }

                 return properties;

         }

         //---------------------------------------------------------------

         // collections

         //---------------------------------------------------------------

     public void onPreUpdateCollection(PreCollectionUpdateEvent event) {

                 if (bypass(event.getAffectedOwnerOrNull().getClass())) {

                         return;

                 }

         CollectionEntry collectionEntry = getCollectionEntry(event);        

 //        if (!collectionEntry.getLoadedPersister().isInverse()) {

             onCollectionAction(event, event.getCollection(), collectionEntry.getSnapshot(), collectionEntry);

 //        }

     }

     public void onPreRemoveCollection(PreCollectionRemoveEvent event) {

                 if (bypass(event.getAffectedOwnerOrNull().getClass())) {

                         return;

                 }

         CollectionEntry collectionEntry = getCollectionEntry(event);

 //        if (!collectionEntry.getLoadedPersister().isInverse()) {

             onCollectionAction(event, null, collectionEntry.getSnapshot(), collectionEntry);

 //        }

     }

     public void onPostRecreateCollection(PostCollectionRecreateEvent event) {

                 if (bypass(event.getAffectedOwnerOrNull().getClass())) {

                         return;

                 }

         CollectionEntry collectionEntry = getCollectionEntry(event);

 //        if (!collectionEntry.getLoadedPersister().isInverse()) {

             onCollectionAction(event, event.getCollection(), null, collectionEntry);

 //        }

     }

     protected CollectionEntry getCollectionEntry(AbstractCollectionEvent event) {

         return event.getSession().getPersistenceContext().getCollectionEntry(event.getCollection());

     }

     protected void onCollectionAction(AbstractCollectionEvent event, PersistentCollection newColl, Serializable oldColl,

             CollectionEntry collectionEntry) {

                 final AuditEntry ae = createAuditEntry(event

                                 .getAffectedOwnerEntityName(), (Long) event

                                 .getAffectedOwnerIdOrNull(), Action.UPDATE);

                 Collection<?> added = (newColl instanceof Collection ? (Collection<?>) newColl : null);

                 Collection<?> removed = (oldColl instanceof Collection ? (Collection<?>) oldColl : null);

                 if (added != null && removed != null) {

                         Collection<?> intersection = CollectionUtils.intersection(added, removed);

                         added.removeAll(intersection);

                         removed.removeAll(intersection);

                 }

                 if (added != null) {

                         String role = event.getCollection().getRole();

                         if (role != null) {

                                 role = role.substring(role.lastIndexOf(".") + 1);

                         }

                         for (Object object : added) {

                                 AuditField af = new AuditField();

                                 af.setName(role);

                                 String value = JpaUtil.getNaturalId(object).toString();

                                 value = value.replace("{", "").replace("}", "");

                                 af.setNewValue(getValue(value));

                                 ae.addField(af);

                         }

                 }

                 if (removed != null) {

                         String role = event.getCollection().getRole();

                         if (role != null) {

                                 role = role.substring(role.lastIndexOf(".") + 1);

                         }

                         for (Object object : removed) {

                                 AuditField af = new AuditField();

                                 af.setName(role);

                                 String value = JpaUtil.getNaturalId(object).toString();

                                 value = value.replace("{", "").replace("}", "");

                                 af.setOldValue(getValue(value));

                                 ae.addField(af);

                         }

                 }

                 if (!ae.getFields().isEmpty()) {

                         publish(ae);

                 }

         }        

 }