package com.trendmicro.grid.acl.ds.jpa;
   
   import com.trendmicro.grid.acl.ds.jpa.entities.JpaPackageDetails;
   import com.trendmicro.grid.acl.l0.datatypes.ProcessPackageDataSet;
   import com.trendmicro.grid.acl.metadata.Metadata;
   import net.sf.tinyjee.config.PropertySection;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   
  import javax.persistence.EntityManager;
  import javax.persistence.FlushModeType;
  import java.util.Collection;
  import java.util.Date;
  
  import static com.trendmicro.grid.acl.ds.jpa.entities.JpaPackageInformation.ROOT_PACKAGE_NAME;
  import static net.sf.tinyjee.util.Assert.assertNotEmpty;
  import static net.sf.tinyjee.util.Assert.assertNotNull;
  
  /**
   * Is the abstract base to implementations that handle aspects of the storage of processing results.
   *
   * @author juergen_kellerer, 2010-11-22
   * @version 1.0
   */
  public abstract class AbstractReceivedResultsHandler<T> {
  
  	private static final Logger log = LoggerFactory.getLogger(AbstractReceivedResultsHandler.class);
  
  	/**
  	 * Defines a storage context for handlers that summarizes the information needed to
  	 * process a single transaction.
  	 */
  	protected static class StorageContext {
  
  		protected final EntityManager em;
  		protected final Collection<ProcessPackageDataSet> receivedDataSets;
  		protected final boolean ignoreAllUpdates, ignoreNullMetadataUpdates, enableHistoryRecording;
  
  		private JpaPackageDetails rootPackageReference;
  
  		/**
  		 * Constructs a new instance bound to the given EntityManager.
  		 *
  		 * @param em						the shared entity manager to use to storing the content.
  		 * @param receivedDataSets		  the received datasets that need to be stored.
  		 * @param ignoreAllUpdates		  whether handlers should not handle any updates at all.
  		 * @param ignoreNullMetadataUpdates whether handlers should ignore metadata updates when to null
  		 *                                  (do not remove existing metadata).
  		 * @param enableHistoryRecording disable or enable the recording of history data in the history tables
  		 *                                    (FILE_CONTENT_HISTORY, PACKAGE_HISTORY, PACKAGE_FILES_HISTORY)
  		 *                                     Default is enabled
  		 */
  		public StorageContext(EntityManager em, Collection<ProcessPackageDataSet> receivedDataSets,
  		                      boolean ignoreAllUpdates, boolean ignoreNullMetadataUpdates, boolean enableHistoryRecording) {
  			assertNotNull("EntityManager", em);
  			assertNotEmpty("Collection<ProcessPackageDataSet>", receivedDataSets);
  
  			this.em = em;
  			this.receivedDataSets = receivedDataSets;
  			this.ignoreAllUpdates = ignoreAllUpdates;
  			this.ignoreNullMetadataUpdates = ignoreAllUpdates || ignoreNullMetadataUpdates;
  			this.enableHistoryRecording = enableHistoryRecording;
  
  			// Changing flush-mode to COMMIT (dramatically improves performance,
  			// compared to AUTO when storing large object trees).
  			if (em.getFlushMode() != FlushModeType.COMMIT)
  				em.setFlushMode(FlushModeType.COMMIT);
  		}
  
  		/**
  		 * Returns a reference to the root package if available or 'null'.
  		 *
  		 * @param repository the repository to use for retrieving the reference.
  		 * @return a reference to the root package if available or 'null'.
  		 */
  		protected JpaPackageDetails getRootPackageReference(JpaPackageRepository repository) {
  			if (rootPackageReference == null) {
  				final Integer rootPk = repository.getPackagePrimaryKeyByName(ROOT_PACKAGE_NAME);
  				if (rootPk != null)
  					rootPackageReference = em.getReference(JpaPackageDetails.class, rootPk);
  			}
  			return rootPackageReference;
  		}
  	}
  
  	/**
  	 * Checks whether the given metadata element can be considered to be null.
  	 *
  	 * @param metadata the metadata element to check.
  	 * @return true if the element equals to 'null'.
  	 */
  	protected static boolean isNull(Metadata metadata) {
  		return metadata == null || metadata.getMetaElements().isEmpty();
  	}
  
  	/**
  	 * If a null safe compare method for 2 dataes.
  	 *
  	 * @param reference   the reference data to verify whether dataToCheck is after it.
 	 * @param dateToCheck the date the check against reference date.
 	 * @return true if dateToCheck is after the reference date or when reference == null && dateToCheck != null.
 	 */
 	protected static boolean isAfter(Date reference, Date dateToCheck) {
 		return dateToCheck != null && (reference == null || dateToCheck.after(reference));
 	}
 
 	/**
 	 * Shortcut to retrieve a boolean value form the given property section.
 	 *
 	 * @param section  the section to read from.
 	 * @param property the key of the value to extract.
 	 * @return true if the value was set and true.
 	 */
 	protected static boolean getValue(PropertySection section, String property) {
 		try {
 			return section.getProperty(property).getValue().getBoolean();
 		} catch (Exception e) {
 			log.warn("TMACL-01050:Failed getting property {}, using 'false'", property);
 			return false;
 		}
 	}
 
 	/**
 	 * Handles the job in relation to the given storage context.
 	 *
 	 * @param context the data set to handle.
 	 * @return an arbitrary value that may be used by downstream handlers, or 'null' if not relevant.
 	 */
 	protected abstract T handle(StorageContext context);
 }