/**
    * Copyright 2005-2016 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.krad.data.jpa;
  
  import java.lang.reflect.InvocationTargetException;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  import java.util.concurrent.Callable;
  
  import javax.persistence.EntityManager;
  import javax.persistence.NonUniqueResultException;
  import javax.persistence.PersistenceException;
  import javax.persistence.metamodel.ManagedType;
  
  import org.apache.commons.beanutils.PropertyUtils;
  import org.apache.commons.lang.ArrayUtils;
  import org.eclipse.persistence.jpa.JpaEntityManager;
  import org.eclipse.persistence.sessions.CopyGroup;
  import org.kuali.rice.core.api.CoreConstants;
  import org.kuali.rice.core.api.config.property.ConfigContext;
  import org.kuali.rice.core.api.criteria.QueryByCriteria;
  import org.kuali.rice.core.api.criteria.QueryResults;
  import org.kuali.rice.core.api.exception.RiceRuntimeException;
  import org.kuali.rice.core.api.mo.common.GloballyUnique;
  import org.kuali.rice.core.api.mo.common.Versioned;
  import org.kuali.rice.krad.data.CompoundKey;
  import org.kuali.rice.krad.data.CopyOption;
  import org.kuali.rice.krad.data.DataObjectService;
  import org.kuali.rice.krad.data.DataObjectWrapper;
  import org.kuali.rice.krad.data.KradDataServiceLocator;
  import org.kuali.rice.krad.data.PersistenceOption;
  import org.kuali.rice.krad.data.metadata.DataObjectCollection;
  import org.kuali.rice.krad.data.metadata.DataObjectMetadata;
  import org.kuali.rice.krad.data.metadata.DataObjectRelationship;
  import org.kuali.rice.krad.data.provider.PersistenceProvider;
  import org.springframework.beans.BeansException;
  import org.springframework.beans.factory.BeanFactory;
  import org.springframework.beans.factory.BeanFactoryAware;
  import org.springframework.beans.factory.BeanFactoryUtils;
  import org.springframework.beans.factory.ListableBeanFactory;
  import org.springframework.dao.DataAccessException;
  import org.springframework.dao.support.ChainedPersistenceExceptionTranslator;
  import org.springframework.dao.support.DataAccessUtils;
  import org.springframework.dao.support.PersistenceExceptionTranslator;
  import org.springframework.orm.jpa.EntityManagerFactoryUtils;
  import org.springframework.transaction.annotation.Transactional;
  
  import com.google.common.collect.Sets;
  
  /**
   * Java Persistence API (JPA) implementation of {@link PersistenceProvider}.
   *
   * <p>
   * When creating a new instance of this provider, a reference to a "shared" entity manager (like that created by
   * Spring's {@link org.springframework.orm.jpa.support.SharedEntityManagerBean} must be injected. Additionally, a
   * reference to the {@link DataObjectService} must be injected as well.
   * </p>
   *
   * <p>
   * This class will perform persistence exception translation (converting JPA exceptions to
   * {@link org.springframework.dao.DataAccessException}s. It will scan the
   * {@link org.springframework.beans.factory.BeanFactory} in which it was created to find beans which implement
   * {@link org.springframework.dao.support.PersistenceExceptionTranslator} and use those translators for translation.
   * </p>
   *
   * @see org.springframework.orm.jpa.support.SharedEntityManagerBean
   * @see org.springframework.dao.support.PersistenceExceptionTranslator
   *
   * @author Kuali Rice Team (rice.collab@kuali.org)
   */
  public class JpaPersistenceProvider implements PersistenceProvider, BeanFactoryAware {
  
  	private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(JpaPersistenceProvider.class);
  
      /**
       * Indicates if a JPA {@code EntityManager} flush should be automatically executed when calling
       * {@link org.kuali.rice.krad.data.DataObjectService#save(Object, org.kuali.rice.krad.data.PersistenceOption...)}
       * using a JPA provider.
       *
       * <p>This is recommended for testing only since the change is global and would affect all persistence units.</p>
       */
      public static final String AUTO_FLUSH = "rice.krad.data.jpa.autoFlush";
  
      private EntityManager sharedEntityManager;
     private DataObjectService dataObjectService;
 
     private PersistenceExceptionTranslator persistenceExceptionTranslator;
 
     private Set<Class<?>> managedTypesCache;
 
     /**
      * Initialization-on-demand holder idiom for thread-safe lazy loading of configuration.
      */
     private static final class LazyConfigHolder {
         private static final boolean autoFlush = ConfigContext.getCurrentContextConfig().getBooleanProperty(AUTO_FLUSH, false);
     }
 
     /**
      * Gets the shared {@link EntityManager}.
      *
      * @return The shared {@link EntityManager}.
      */
     public EntityManager getSharedEntityManager() {
         return sharedEntityManager;
     }
 
     /**
      * Setter for the shared {@link EntityManager}.
      *
      * @param sharedEntityManager The shared {@link EntityManager} to set.
      */
     public void setSharedEntityManager(EntityManager sharedEntityManager) {
         this.sharedEntityManager = sharedEntityManager;
     }
 
     /**
      * Setter for the {@link DataObjectService}.
      *
      * @param dataObjectService The {@link DataObjectService} to set.
      */
     public void setDataObjectService(DataObjectService dataObjectService) {
         this.dataObjectService = dataObjectService;
     }
 
     /**
      * Returns the {@link DataObjectService}.
      *
      * @return a {@link DataObjectService}
      */
     public DataObjectService getDataObjectService() {
         return this.dataObjectService;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
         if (!(beanFactory instanceof ListableBeanFactory)) {
             throw new IllegalArgumentException(
                     "Cannot use PersistenceExceptionTranslator autodetection without ListableBeanFactory");
         }
         this.persistenceExceptionTranslator = detectPersistenceExceptionTranslators((ListableBeanFactory)beanFactory);
     }
 
     /**
      * Gets any {@link PersistenceExceptionTranslator}s from the {@link BeanFactory}.
      *
      * @param beanFactory The {@link BeanFactory} to use.
      *
      * @return A {@link PersistenceExceptionTranslator} from the {@link BeanFactory}.
      */
     protected PersistenceExceptionTranslator detectPersistenceExceptionTranslators(ListableBeanFactory beanFactory) {
         // Find all translators, being careful not to activate FactoryBeans.
         Map<String, PersistenceExceptionTranslator> pets = BeanFactoryUtils.beansOfTypeIncludingAncestors(beanFactory,
                 PersistenceExceptionTranslator.class, false, false);
         ChainedPersistenceExceptionTranslator cpet = new ChainedPersistenceExceptionTranslator();
         for (PersistenceExceptionTranslator pet : pets.values()) {
             cpet.addDelegate(pet);
         }
         // always add one last persistence exception translator as a catch all
         cpet.addDelegate(new DefaultPersistenceExceptionTranslator());
         return cpet;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @Transactional
     public <T> T save(final T dataObject, final PersistenceOption... options) {
         return doWithExceptionTranslation(new Callable<T>() {
             @Override
 			public T call() {
                 verifyDataObjectWritable(dataObject);
 
         		Set<PersistenceOption> optionSet = Sets.newHashSet(options);
 
 		        T mergedDataObject = sharedEntityManager.merge(dataObject);
 
                 // We must flush if they pass us a flush option, have auto flush turned on, or are synching keys
                 // after save. We are required to flush before synching because we may need to use generated values to
                 // perform synchronization and those won't be there until after a flush
                 //
                 // note that the actual synchronization of keys is handled automatically by the framework after the
                 // save has been completed
                 if(optionSet.contains(PersistenceOption.FLUSH) || optionSet.contains(PersistenceOption.LINK_KEYS) ||
                         LazyConfigHolder.autoFlush){
 					sharedEntityManager.flush();
                 }
 
 				if (sharedEntityManager.getEntityManagerFactory().getCache() != null) {
 					try {
 						Object dataObjectKey = sharedEntityManager.getEntityManagerFactory().getPersistenceUnitUtil()
 								.getIdentifier(mergedDataObject);
 						if (dataObjectKey != null) {
 							sharedEntityManager.getEntityManagerFactory().getCache()
 									.evict(dataObject.getClass(), dataObjectKey);
 						}
 					} catch (PersistenceException ex) {
 						// JPA fails if it can't create the key field classes - we just need to catch and ignore here
 					}
 				}
 
                 return mergedDataObject;
             }
         });
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @Transactional(readOnly = true)
     public <T> T find(final Class<T> type, final Object id) {
         return doWithExceptionTranslation(new Callable<T>() {
             @Override
 			public T call() {
                 if (id instanceof CompoundKey) {
 			        QueryResults<T> results = findMatching(type,
 				        	QueryByCriteria.Builder.andAttributes(((CompoundKey) id).getKeys()).build());
 			        if (results.getResults().size() > 1) {
 				        throw new NonUniqueResultException("Error Compound Key: " + id + " on class " + type.getName()
 					        	+ " returned more than one row.");
 			        }
                     if (!results.getResults().isEmpty()) {
 				        return results.getResults().get(0);
                     }
 			        return null;
                 } else {
                     return sharedEntityManager.find(type, id);
                 }
             }
         });
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @Transactional(readOnly = true)
     public <T> QueryResults<T> findMatching(final Class<T> type, final QueryByCriteria queryByCriteria) {
         return doWithExceptionTranslation(new Callable<QueryResults<T>>() {
             @Override
 			public QueryResults<T> call() {
                 return new JpaCriteriaQuery(sharedEntityManager).lookup(type, queryByCriteria);
             }
         });
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @Transactional(readOnly = true)
     public <T> QueryResults<T> findAll(final Class<T> type) {
         return doWithExceptionTranslation(new Callable<QueryResults<T>>() {
             @Override
             public QueryResults<T> call() {
                 return new JpaCriteriaQuery(getSharedEntityManager()).lookup(type, QueryByCriteria.Builder.create().build());
             }
         });
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @Transactional
     public void delete(final Object dataObject) {
         doWithExceptionTranslation(new Callable<Object>() {
             @Override
 			public Object call() {
                 verifyDataObjectWritable(dataObject);
 				// If the L2 cache is enabled, the item will still be served from the cache
 				// So, we need to flush that as well for the given type and key
 				if (sharedEntityManager.getEntityManagerFactory().getCache() != null) {
 					try {
 						Object dataObjectKey = sharedEntityManager.getEntityManagerFactory().getPersistenceUnitUtil()
 								.getIdentifier(dataObject);
 						if (dataObjectKey != null) {
 							sharedEntityManager.getEntityManagerFactory().getCache()
 									.evict(dataObject.getClass(), dataObjectKey);
 						}
 					} catch (PersistenceException ex) {
 						// JPA fails if it can't create the key field classes - we just need to catch and ignore here
 					}
 				}
 				Object mergedDataObject = sharedEntityManager.merge(dataObject);
 				sharedEntityManager.remove(mergedDataObject);
                 return null;
             }
         });
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @Transactional
     public <T> void deleteMatching(final Class<T> type, final QueryByCriteria queryByCriteria) {
         doWithExceptionTranslation(new Callable<Object>() {
             @Override
             public Object call() {
                 new JpaCriteriaQuery(getSharedEntityManager()).deleteMatching(type, queryByCriteria);
 				// If the L2 cache is enabled, items will still be served from the cache
 				// So, we need to flush that as well for the given type
 				if (sharedEntityManager.getEntityManagerFactory().getCache() != null) {
 					sharedEntityManager.getEntityManagerFactory().getCache().evict(type);
 				}
                 return null;
             }
         });
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @Transactional
     public <T> void deleteAll(final Class<T> type) {
         doWithExceptionTranslation(new Callable<Object>() {
             @Override
             public Object call() {
                 new JpaCriteriaQuery(getSharedEntityManager()).deleteAll(type);
 				// If the L2 cache is enabled, items will still be served from the cache
 				// So, we need to flush that as well for the given type
 				if (sharedEntityManager.getEntityManagerFactory().getCache() != null) {
 					sharedEntityManager.getEntityManagerFactory().getCache().evict(type);
 				}
                 return null;
             }
         });
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @Transactional
 	public <T> T copyInstance(final T dataObject, CopyOption... options) {
 		final CopyGroup copyGroup = new CopyGroup();
 		if (ArrayUtils.contains(options, CopyOption.RESET_PK_FIELDS)) {
 			copyGroup.setShouldResetPrimaryKey(true);
 		}
 		final boolean shouldResetVersionNumber = ArrayUtils.contains(options, CopyOption.RESET_VERSION_NUMBER);
 		if (shouldResetVersionNumber) {
 			copyGroup.setShouldResetVersion(true);
 		}
 		final boolean shouldResetObjectId = ArrayUtils.contains(options, CopyOption.RESET_OBJECT_ID);
         return doWithExceptionTranslation(new Callable<T>() {
 			@SuppressWarnings("unchecked")
 			@Override
             public T call() {
 				T copiedObject = (T) sharedEntityManager.unwrap(JpaEntityManager.class).getDatabaseSession()
 						.copy(dataObject, copyGroup);
 				if (shouldResetObjectId) {
 					clearObjectIdOnUpdatableObjects(copiedObject, new HashSet<Object>());
 				}
 				if (shouldResetVersionNumber) {
 				    clearVersionNumberOnUpdatableObjects(copiedObject, new HashSet<Object>());
 				}
 				return copiedObject;
             }
         });
     }
 
 	/**
 	 * For the given data object, recurse through all updatable references and clear the object ID on the basis that
 	 * this is a unique column in each object's table.
 	 * 
 	 * @param dataObject
 	 *            The data object on which to clear the object ID from itself and all updatable child objects.
 	 * @param visitedObjects
 	 *            A set of objects built by the recursion process which will be checked to ensure that the code does not
 	 *            get into an infinite loop.
 	 */
 	protected void clearObjectIdOnUpdatableObjects(Object dataObject, Set<Object> visitedObjects) {
 		if (dataObject == null) {
 			return;
 		}
 		// avoid infinite loops
 		if (visitedObjects.contains(dataObject)) {
 			return;
 		}
 		visitedObjects.add(dataObject);
 		if (dataObject instanceof GloballyUnique) {
 			try {
 				PropertyUtils.setSimpleProperty(dataObject, CoreConstants.CommonElements.OBJECT_ID, null);
 			} catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException ex) {
 				// there may not be a setter or some other issue. In any case, we don't want to blow the method.
 				LOG.warn("Unable to clear the objectId from copyInstance on an object: " + dataObject, ex);
 			}
 		}
 		DataObjectWrapper<Object> wrapper = KradDataServiceLocator.getDataObjectService().wrap(dataObject);
 		if (wrapper.getMetadata() != null) {
 			for (DataObjectRelationship rel : wrapper.getMetadata().getRelationships()) {
 				if (rel.isSavedWithParent()) {
 					// recurse in
 					clearObjectIdOnUpdatableObjects(wrapper.getPropertyValue(rel.getName()), visitedObjects);
 				}
 			}
 			for (DataObjectCollection rel : wrapper.getMetadata().getCollections()) {
 				if (rel.isSavedWithParent()) {
 					Collection<?> collection = (Collection<?>) wrapper.getPropertyValue(rel.getName());
 					if (collection != null) {
 						for (Object element : collection) {
 							clearObjectIdOnUpdatableObjects(element, visitedObjects);
 						}
 					}
 				}
 			}
 
 		}
 	}
 
 	/**
 	 * For the given data object, recurse through all updatable references and clear the object ID on the basis that
 	 * this is a unique column in each object's table.
 	 * 
 	 * @param dataObject
 	 *            The data object on which to clear the object ID from itself and all updatable child objects.
 	 * @param visitedObjects
 	 *            A set of objects built by the recursion process which will be checked to ensure that the code does not
 	 *            get into an infinite loop.
 	 */
 	protected void clearVersionNumberOnUpdatableObjects(Object dataObject, Set<Object> visitedObjects) {
 		if (dataObject == null) {
 			return;
 		}
 		// avoid infinite loops
 		if (visitedObjects.contains(dataObject)) {
 			return;
 		}
 		visitedObjects.add(dataObject);
 		if (dataObject instanceof Versioned) {
 			try {
 				PropertyUtils.setSimpleProperty(dataObject, CoreConstants.CommonElements.VERSION_NUMBER, null);
 			} catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException ex) {
 				// there may not be a setter or some other issue. In any case, we don't want to blow the method.
 				LOG.warn("Unable to clear the objectId from copyInstance on an object: " + dataObject, ex);
 			}
 		}
 		DataObjectWrapper<Object> wrapper = KradDataServiceLocator.getDataObjectService().wrap(dataObject);
 		if (wrapper.getMetadata() != null) {
 			for (DataObjectRelationship rel : wrapper.getMetadata().getRelationships()) {
 				if (rel.isSavedWithParent()) {
 					// recurse in
 					clearVersionNumberOnUpdatableObjects(wrapper.getPropertyValue(rel.getName()), visitedObjects);
 				}
 			}
 			for (DataObjectCollection rel : wrapper.getMetadata().getCollections()) {
 				if (rel.isSavedWithParent()) {
 					Collection<?> collection = (Collection<?>) wrapper.getPropertyValue(rel.getName());
 					if (collection != null) {
 						for (Object element : collection) {
 							clearVersionNumberOnUpdatableObjects(element, visitedObjects);
 						}
 					}
 				}
 			}
 
 		}
 	}
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean handles(final Class<?> type) {
         if (managedTypesCache == null) {
             managedTypesCache = new HashSet<Class<?>>();
 
             Set<ManagedType<?>> managedTypes = sharedEntityManager.getMetamodel().getManagedTypes();
             for (ManagedType managedType : managedTypes) {
                 managedTypesCache.add(managedType.getJavaType());
             }
         }
 
         if (managedTypesCache.contains(type)) {
             return true;
         } else {
             return false;
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @Transactional(readOnly = true)
     public void flush(final Class<?> type) {
         doWithExceptionTranslation(new Callable<Object>() {
             @Override
 			public Object call() {
                 sharedEntityManager.flush();
 				// If the L2 cache is enabled, items will still be served from the cache
 				// So, we need to flush that as well for the given type
 				// if (sharedEntityManager.getEntityManagerFactory().getCache() != null) {
 				// if (type != null) {
 				// sharedEntityManager.getEntityManagerFactory().getCache().evict(type);
 				// } else {
 				// sharedEntityManager.getEntityManagerFactory().getCache().evictAll();
 				// }
 				// }
                 return null;
             }
         });
     }
 
     /**
      * Verifies that the data object can be written to.
      *
      * @param dataObject The data object to check.
      */
     protected void verifyDataObjectWritable(Object dataObject) {
         DataObjectMetadata metaData = dataObjectService.getMetadataRepository().getMetadata(dataObject.getClass());
         if (metaData == null) {
             throw new IllegalArgumentException("Given data object class is not loaded into the MetadataRepository: " + dataObject.getClass());
         }
         if (metaData.isReadOnly()) {
             throw new UnsupportedOperationException(dataObject.getClass() + " is read-only");
         }
     }
 
     /**
      * Surrounds the transaction with a try/catch block that can use the {@link PersistenceExceptionTranslator} to
      * translate the exception if necessary.
      *
      * @param callable The data operation to invoke.
      * @param <T> The type of the data operation.
      *
      * @return The result from the data operation, if successful.
      */
     protected <T> T doWithExceptionTranslation(Callable<T> callable) {
         try {
             return callable.call();
         }
         catch (RuntimeException ex) {
             throw DataAccessUtils.translateIfNecessary(ex, this.persistenceExceptionTranslator);
         } catch (Exception ex) {
             // this should really never happen based on the internal usage in this class
             throw new RiceRuntimeException("Unexpected checked exception during data access.", ex);
         }
     }
 
     /**
      * Defines a default {@link PersistenceExceptionTranslator} if no others exist.
      */
     private static final class DefaultPersistenceExceptionTranslator implements PersistenceExceptionTranslator {
 
         /**
          * {@inheritDoc}
          */
         @Override
         public DataAccessException translateExceptionIfPossible(RuntimeException ex) {
             return EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(ex);
         }
 
     }
 
 }