package com.trendmicro.grid.acl.ds.jpa;
   
   import com.trendmicro.grid.acl.WellKnownTags;
   import com.trendmicro.grid.acl.ds.jpa.entities.*;
   import com.trendmicro.grid.acl.l0.datatypes.*;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   
   import javax.persistence.Query;
  import java.util.*;
  
  import static com.trendmicro.grid.acl.ds.jpa.ReceivedPreparedPackagesHandler.PreparedPackage;
  import static com.trendmicro.grid.acl.ds.jpa.StorageOptions.PATH_DELIMITERS;
  import static com.trendmicro.grid.acl.ds.jpa.entities.JpaNamedFileIdentifierHistory.HistoryType.removed;
  import static com.trendmicro.grid.acl.ds.jpa.entities.JpaNamedFileIdentifierHistory.HistoryType.renamed;
  
  /**
   * Is the primary handler that operates on the complete dataSets.
   *
   * @author juergen_kellerer, 2010-11-22
   * @version 1.0
   */
  public class ReceivedDataSetsHandler extends AbstractReceivedFileContentsHandler<Void> {
  
  	private static final Logger log = LoggerFactory.getLogger(ReceivedDataSetsHandler.class);
  
  	private final JpaPackageRepository packageRepository;
  	private final JpaSourceRepository sourceRepository;
  
  	private final ReceivedPreparedPackagesHandler packagesHandler;
  	private final ReceivedSourcesHandler sourcesHandler;
  
  	/**
  	 * Creates a new thread safe instance.
  	 *
  	 * @param fileRepository    the repository to use for file contents.
  	 * @param packageRepository the repository to use for packages.
  	 * @param packagesHandler   the PreparedPackage handler to use.
  	 * @param sourcesHandler    the SourcesHandler to use.
  	 */
  	public ReceivedDataSetsHandler(JpaFileRepository fileRepository,
  	                               JpaPackageRepository packageRepository,
  	                               ReceivedPreparedPackagesHandler packagesHandler,
  	                               ReceivedSourcesHandler sourcesHandler) {
  		super(fileRepository);
  
  		this.packageRepository = packageRepository;
  		this.packagesHandler = packagesHandler;
  		this.sourcesHandler = sourcesHandler;
  		sourceRepository = sourcesHandler.getSourceRepository();
  	}
  
  	/**
  	 * {@inheritDoc}
  	 */
  	@Override
  	protected Void handle(StorageContext context) {
  		final Collection<PreparedPackage> preparedPackages = packagesHandler.handle(context);
  		final Iterator<ProcessPackageDataSet> dataSets = context.receivedDataSets.iterator();
  		final Iterator<List<JpaSource>> sourceReferences = sourcesHandler.handle(context).iterator();
  
  		for (PreparedPackage preparedPackage : preparedPackages) {
  			final List<JpaSource> sources = sourceReferences.next();
  			final ProcessPackageDataSet dataSet = dataSets.next();
  			if (preparedPackage != null)
  				handlePreparedPackage(context, preparedPackage, sources, dataSet);
  		}
  
  		return null;
  	}
  
  	/**
  	 * Handles all linkages between package and other contents and triggers the final update on the prepared package.
  	 *
  	 * @param context          the context for the current transaction.
  	 * @param preparedPackage  the prepare package to handle.
  	 * @param sourceReferences the list of sources to link the file content entries against.
  	 * @param dataSet          the relevant dataset.
  	 */
  	void handlePreparedPackage(final StorageContext context,
  	                           final PreparedPackage preparedPackage,
  	                           final List<JpaSource> sourceReferences,
  	                           final ProcessPackageDataSet dataSet) {
  
  		// Handle the package members.
  		final Collection<JpaFileDetails> fileRefs = createOrUpdateFileReferences(context, dataSet.getPackageMember());
  		final boolean revisionNeedsIncrement = synchronizeMembers(context, preparedPackage, fileRefs, dataSet);
  
  		// Handle the source linkage
  		fileRefs.add(preparedPackage.getFileReference());
  		sourceRepository.referenceFilesFromSources(fileRefs, sourceReferences);
  
  		// Handle the linkage against the root package
  		linkWithRootPackage(context, preparedPackage);
  
  		preparedPackage.applyFinalPackageUpdates(revisionNeedsIncrement);
  
  		// Flushing the changes now 
  		// (to avoid duplicate key issues with repeated content in the same transaction)
 		context.em.flush();
 	}
 
 	/**
 	 * Manages updates to FILE_CONTENTS for package members and deals with the PACKAGE_FILES & HISTORY table.
 	 *
 	 * @param context
 	 * @param preparedPackage the reference package (including the primary key).
 	 * @param fileRefs        the list of updated file references (including pk).
 	 * @param dataSet         the complete dataset containing the package members.
 	 * @return returns true if history entries were created on the PACKAGE_FILES_HISTORY table.
 	 */
 	boolean synchronizeMembers(final StorageContext context,
 	                           final PreparedPackage preparedPackage,
 	                           final Collection<JpaFileDetails> fileRefs,
 	                           final ProcessPackageDataSet dataSet) {
 
 		// Updating changes to the file details.
 		final Iterator<JpaFileDetails> fileRefsIterator = fileRefs.iterator();
 
 		// Updating file assignments now.
 		final JpaPackageDetails packageRef = preparedPackage.getReference();
 		boolean historyEntriesCreated = false;
 		final int revision = packageRef.getRevision();
 
 		final Map<NamedFileIdentifier, JpaNamedFileIdentifier> namedFileIdentifierMap =
 				packageRepository.getFilesContainedInPackage(packageRef);
 		final Map<FileIdentifier, Map<NamedFileIdentifier, JpaNamedFileIdentifier>> fileIdentifierMap =
 				buildIdentifierOnlyMap(namedFileIdentifierMap);
 
 		final int memberCount = dataSet.getPackageMember().size();
 		final Set<JpaNamedFileIdentifier> persistedOrChangedRefs = new HashSet<JpaNamedFileIdentifier>(memberCount);
 		final IdentityHashMap<Object, Object> ignoredRefs = new IdentityHashMap<Object, Object>(memberCount);
 
 		// Handle additions and renames
 		Query fnUpdateQuery = null;
 		for (PackageMember member : dataSet.getPackageMember()) {
 			final JpaFileDetails fileRef = fileRefsIterator.next();
 			final NamedFileIdentifier namedIdentifier = member.getIdentifier();
 			final String fileName = namedIdentifier.getFileName();
 
 			JpaNamedFileIdentifier ref = namedFileIdentifierMap.get(namedIdentifier);
 			if (ref == null) {
 				final FileIdentifier key = new FileIdentifier(namedIdentifier.getSHA1Hash());
 				ref = findRenamedReference(namedIdentifier, fileIdentifierMap.get(key));
 
 				if (ref == null) {
 					// new file
 					ref = new JpaNamedFileIdentifier(fileRef, packageRef, fileName);
 
 					if (persistedOrChangedRefs.contains(ref)) {
 						log.warn("Ignoring a duplicate file reference for file '{}', " +
 								"this is very likely invalid data in the received data-set.", fileName);
 						continue;
 					}
 
 					if (log.isTraceEnabled())
 						log.trace("Creating new package file reference for file '{}'", fileName);
 
 					context.em.persist(ref);
 					mapIdentifier(namedIdentifier, ref, fileIdentifierMap);
 					persistedOrChangedRefs.add(ref);
 
 				} else {
 					// renamed file
 					if (persistedOrChangedRefs.contains(ref)) {
 						log.warn("Ignoring a duplicate request to rename file '{}' => '{}', " +
 								"this is very likely invalid data in the received data-set.",
 								ref.getReference().getFileName(), fileName);
 						continue;
 					}
 					persistedOrChangedRefs.add(ref);
 
 					ignoredRefs.put(ref, ref);
 					JpaNamedFileIdentifierHistory history = new JpaNamedFileIdentifierHistory(
 							fileRef, packageRef, ref.getReference().getFileName(), renamed, revision);
 
 					//If disabled, recording of data in the database are ignored. Default is enabled
 					if (context.enableHistoryRecording) {
 						if (log.isTraceEnabled()) {
 							log.trace("Storing history entry for renamed file '{}' => '{}'",
 									ref.getReference().getFileName(), fileName);
 						}
 						context.em.persist(history);
 					} else {
 						if (log.isTraceEnabled())
 							log.trace("enableHistoryRecording is set to {}. Disregarding package-file history entry: {}", context.enableHistoryRecording, history);
 					}
 
 					historyEntriesCreated = true;
 
 					// .. and finally updating the name inside the DB
 					if (fnUpdateQuery == null)
 						fnUpdateQuery = context.em.createNamedQuery("NamedFileIdentifier.UpdateFileNameById");
 					int updateCount = fnUpdateQuery.setParameter("fileName", fileName).
 							setParameter("id", ref.getReference()).executeUpdate();
 					if (updateCount != 1) {
 						// A failed rename is fatal as it will prevent history updates in the future!
 						throw new IllegalStateException("Failed to rename file '" +
 								ref.getReference().getFileName() + "' to '" + fileName + "' for package '" +
 								packageRef.getPackageInformation().getName() + "'");
 					}
 				}
 			} else
 				ignoredRefs.put(ref, ref);
 		}
 
 		// Handle removed files (only if package is not tagged "oversized")
 		PackageInformation info = dataSet.getProcessedPackage().getPackageInformation();
 		boolean packageIsOversized = info.containsTag(WellKnownTags.oversized.name());
 		if (!packageIsOversized) {
 			for (JpaNamedFileIdentifier ref : namedFileIdentifierMap.values()) {
 				if (ignoredRefs.containsKey(ref))
 					continue;
 
 				JpaNamedFileIdentifierHistory history = new JpaNamedFileIdentifierHistory(
 						ref.getReference().getFileDetails(), packageRef, ref.getReference().getFileName(),
 						removed, revision);
 				if (log.isTraceEnabled())
 
 
 					//If disabled, recording of data in the database are ignored. Default is enabled
 					if (context.enableHistoryRecording) {
 						if (log.isTraceEnabled())
 							log.trace("Storing history entry for the removed file '{}'", ref.getReference().getFileName());
 						context.em.persist(history);
 					} else {
 						if (log.isTraceEnabled())
 							log.trace("enableHistoryRecording is set to {}. Disregarding package-file history entry: {}", context.enableHistoryRecording, history);
 					}
 
 				context.em.remove(ref);
 				historyEntriesCreated = true;
 			}
 		}
 
 		return historyEntriesCreated;
 	}
 
 	/**
 	 * Finds the reference that was renamed inside the map of existing identifiers.
 	 *
 	 * @param newIdentifier The new identifier to test for a renamed file.
 	 * @param map           The existing identifiers map (should be pre-filtered using
 	 *                      {@code buildIdentifierOnlyMap(..)}).
 	 * @return The renamed existing named reference or 'null' if either no identifier
 	 *         matched or the identifier was not renamed.
 	 */
 	private JpaNamedFileIdentifier findRenamedReference(NamedFileIdentifier newIdentifier, Map<NamedFileIdentifier, JpaNamedFileIdentifier> map) {
 
 		if (map == null || map.isEmpty()) return null;
 
 		final String newFileName = newIdentifier.getFileName();
 		for (Map.Entry<NamedFileIdentifier, JpaNamedFileIdentifier> entry : map.entrySet()) {
 			final NamedFileIdentifier identifier = entry.getKey();
 
 			if (!identifier.identifierEquals(newIdentifier)) continue;
 
 			boolean pathIsSameButCaseChange = !newFileName.equals(identifier.getFileName()) && newFileName.equalsIgnoreCase(identifier.getFileName());
 			if (checkOnlyNameDiffers(newFileName, identifier.getFileName()) || pathIsSameButCaseChange)
 				return entry.getValue();
 		}
 
 		return null;
 	}
 
 	/**
 	 * Compares path A and B and returns true if everything is equal but the last element differs.
 	 *
 	 * @param pathA The first path to check.
 	 * @param pathB The second path to check.
 	 * @return true if everything is equal but the last element differs.
 	 */
 	boolean checkOnlyNameDiffers(String pathA, String pathB) {
 		//Todo: Create unit test someday
 		final StringTokenizer ta = new StringTokenizer(pathA == null ? "" : pathA, PATH_DELIMITERS),
 				tb = new StringTokenizer(pathB == null ? "" : pathB, PATH_DELIMITERS);
 
 		while (ta.hasMoreTokens() && tb.hasMoreTokens()) {
 			if (!ta.nextToken().equals(tb.nextToken()))
 				return !ta.hasMoreTokens() && !tb.hasMoreTokens();
 		}
 
 		return false; // if we end here, pathA and B is the same.
 	}
 
 	/**
 	 * Creates an additional map that doesn't treat file-names in order to detect renamed files.
 	 *
 	 * @param namedFileIdentifierMap the source map to convert.
 	 * @return a map that maps only the sha1 hashes, not the filenames.
 	 */
 	private Map<FileIdentifier, Map<NamedFileIdentifier, JpaNamedFileIdentifier>> buildIdentifierOnlyMap(
 			Map<NamedFileIdentifier, JpaNamedFileIdentifier> namedFileIdentifierMap) {
 
 		Map<FileIdentifier, Map<NamedFileIdentifier, JpaNamedFileIdentifier>> map =
 				new HashMap<FileIdentifier, Map<NamedFileIdentifier, JpaNamedFileIdentifier>>(
 						namedFileIdentifierMap.size());
 
 		for (Map.Entry<NamedFileIdentifier, JpaNamedFileIdentifier> entry : namedFileIdentifierMap.entrySet())
 			mapIdentifier(entry.getKey(), entry.getValue(), map);
 
 		return map;
 	}
 
 	private void mapIdentifier(NamedFileIdentifier namedIdentifier, JpaNamedFileIdentifier reference,
 	                           Map<FileIdentifier, Map<NamedFileIdentifier, JpaNamedFileIdentifier>> map) {
 		final FileIdentifier key = new FileIdentifier(namedIdentifier.getSHA1Hash());
 
 		Map<NamedFileIdentifier, JpaNamedFileIdentifier> identifierMap = map.get(key);
 		if (identifierMap == null) {
 			// Using a singleton map when we have only one entry as
 			// this greatly reduced memory footprint (and performance)
 			map.put(key, Collections.singletonMap(namedIdentifier, reference));
 			return;
 		} else if (identifierMap.size() == 1)
 			map.put(key, identifierMap = new LinkedHashMap<NamedFileIdentifier, JpaNamedFileIdentifier>(identifierMap));
 
 		identifierMap.put(namedIdentifier, reference);
 	}
 
 	/**
 	 * Handles the linkage of a package against the root package.
 	 *
 	 * @param context         the context for the current transaction.
 	 * @param preparedPackage the prepare package to link.
 	 */
 	void linkWithRootPackage(final StorageContext context, final PreparedPackage preparedPackage) {
 		final JpaPackageDetails rootPackageRef = context.getRootPackageReference(packageRepository);
 		final String remoteFileName = preparedPackage.getRemoteFileName();
 
 		if (rootPackageRef != null) {
 			final JpaFileDetails fileReference = preparedPackage.getFileReference();
 
 			final List r = context.em.createNamedQuery("NamedFileIdentifier.SelectEntryExists").
 					setParameter("package", rootPackageRef).
 					setParameter("file", fileReference).
 					setParameter("fileName", remoteFileName).setMaxResults(1).getResultList();
 
 			if (r.isEmpty()) {
 				JpaNamedFileIdentifier nfi = new JpaNamedFileIdentifier(fileReference, rootPackageRef, remoteFileName);
 				context.em.persist(nfi);
 			}
 		} else {
 			if (log.isTraceEnabled())
 				log.trace("Not inserting linkage to ROOT package with filename '{}', " +
 						"no ROOT package exists inside the PACKAGES table.", remoteFileName);
 		}
 	}
 }