package com.trendmicro.grid.acl.ds.jpa.util;
   
   import com.trendmicro.grid.acl.commons.SoftReferenceThreadLocal;
   import com.trendmicro.grid.acl.l0.datatypes.AbstractListPage;
   import com.trendmicro.grid.acl.l0.datatypes.MetadataOwner;
   import com.trendmicro.grid.acl.l0.datatypes.NameListPage;
   import com.trendmicro.grid.acl.l0.datatypes.Tagged;
   import com.trendmicro.grid.acl.metadata.Metadata;
   import com.trendmicro.grid.acl.metadata.ValidationContext;
  
  import javax.persistence.NonUniqueResultException;
  import javax.persistence.Query;
  import javax.persistence.TypedQuery;
  import javax.xml.bind.JAXBException;
  import javax.xml.bind.Marshaller;
  import javax.xml.bind.PropertyException;
  import javax.xml.bind.Unmarshaller;
  import javax.xml.transform.Source;
  import javax.xml.transform.stax.StAXSource;
  import javax.xml.transform.stream.StreamSource;
  import java.io.StringReader;
  import java.io.StringWriter;
  import java.nio.ByteBuffer;
  import java.util.*;
  import java.util.concurrent.Callable;
  
  import static com.trendmicro.grid.acl.Limits.SERIALIZED_METADATA_LENGTH;
  import static com.trendmicro.grid.acl.Limits.TAG_STRING_LENGTH;
  import static net.sf.tinyjee.util.Assert.assertEquals;
  
  /**
   * A small set of common helper methods used to simplify working with JPA.
   *
   * @author juergen_kellerer, 2010-06-07
   * @version 1.0
   */
  public class JpaUtils {
  
  	//Don't remove the line below!
  	// START SNIPPET: StorageOptions
  
  	/**
  	 * Toggles whether EMPTY metadata and 'NULL' are treated equal. (defaults to 'true')
  	 * <p/>
  	 * When 'true' the ACL normalizes empty metadata to 'null' to reduce the storage
  	 * overhead inside the database.
  	 */
  	public static final boolean EMPTY_METADATA_EQUALS_NULL = Boolean.parseBoolean(
  			System.getProperty("gacl.empty.metadata.equals.null", Boolean.TRUE.toString()));
  
  	//END SNIPPET: StorageOptions
  	//Don't remove the line above!
  
  	private static final TagsSerializedCache TAGS_SERIALIZED_CACHE = new TagsSerializedCache();
  
  	/**
  	 * Creation of Unmarshallers has shown to be expensive, caching them in a TL.
  	 */
  	private static final SoftReferenceThreadLocal<Unmarshaller> META_UNMARSHALLERS =
  			new SoftReferenceThreadLocal<Unmarshaller>() {
  				@Override
  				protected Unmarshaller createInitialValue() throws Exception {
  					return Metadata.getXmlSerializer().getJaxbContext().createUnmarshaller();
  				}
  			};
  
  	/**
  	 * Creation of Marshallers has shown to be expensive, caching them in a TL.
  	 */
  	private static final SoftReferenceThreadLocal<Marshaller> META_MARSHALLERS = new SoftReferenceThreadLocal<Marshaller>() {
  		@Override
  		protected Marshaller createInitialValue() throws Exception {
  			Marshaller marshaller = Metadata.getXmlSerializer().getJaxbContext().createMarshaller();
  			try {
  				marshaller.setProperty("com.sun.xml.bind.xmlDeclaration", Boolean.FALSE);
  			} catch (PropertyException ignored) {
  				marshaller.setProperty("com.sun.xml.internal.bind.xmlDeclaration", Boolean.FALSE);
  			}
  			return marshaller;
  		}
  	};
  
  	/**
  	 * Defines a callback to use for converting types.
  	 *
  	 * @param <E> The input type.
  	 * @param <V> The converted output type.
  	 */
  	public interface Callback<E, V> {
  		V call(E element);
  	}
  
  	/**
  	 * Straight converter callback that simply passed single or array input to a single output.
  	 */
  	public static final Callback SINGLE_ELEMENT_CALLBACK = new Callback<Object, Object>() {
  		@Override
  		public Object call(Object element) {
  			if (element instanceof Object[]) {
 				Object[] array = (Object[]) element;
 				return array[array.length - 1];
 			}
 			return element;
 		}
 	};
 
 	/**
 	 * Encodes a UUID to its byte representation.
 	 *
 	 * @param guid the UUID to convert.
 	 * @return the encoded UUID bytes.
 	 */
 	public static byte[] toBytes(UUID guid) {
 		if (guid == null)
 			return null;
 		return ByteBuffer.allocate(16).putLong(guid.getMostSignificantBits()).putLong(guid.getLeastSignificantBits()).array();
 	}
 
 	/**
 	 * Decodes a UUID from its byte representation.
 	 *
 	 * @param publicGUID the UUID to convert.
 	 * @return the decoded UUID.
 	 */
 	public static UUID fromBytes(byte[] publicGUID) {
 		if (publicGUID == null)
 			return null;
 
 		assertEquals("publicGUID#length", 16, publicGUID.length);
 
 		ByteBuffer buffer = ByteBuffer.wrap(publicGUID);
 		return new UUID(buffer.getLong(), buffer.getLong());
 	}
 
 	/**
 	 * Serializes the given tag array to text.
 	 *
 	 * @param tags the tags to encode.
 	 * @return the text encoded tags.
 	 */
 	public static String serializeTags(String[] tags) {
 		if (tags == null || tags.length == 0) return null;
 
 		// Lots of elements are tagged with the same tags.
 		// Caching the serialization results speeds-up the storage.
 		String result = TAGS_SERIALIZED_CACHE.get(tags);
 
 		if (result == null) {
 			// Clone the tags to avoid modifying external values.
 			tags = tags.clone();
 
 			final Locale locale = Locale.getDefault();
 			int len = 1;
 			for (int i = 0; i < tags.length; i++) {
 				final String tag = tags[i];
 				len += tag.length() + 1;
 				tags[i] = tag.replace(' ', '_').toLowerCase(locale);
 			}
 
 			result = TAGS_SERIALIZED_CACHE.get(tags);
 
 			if (result == null) {
 
 				Arrays.sort(tags);
 
 				final StringBuilder builder = new StringBuilder(len).append(' ');
 				for (String tag : tags)
 					builder.append(tag).append(' ');
 
 				result = builder.toString();
 				if (result.length() > TAG_STRING_LENGTH) {
 					throw new IllegalArgumentException("The tag list '" + result + "' exceeds the maximum length of '" +
 							TAG_STRING_LENGTH + "' characters.");
 				}
 
 				TAGS_SERIALIZED_CACHE.put(tags, result);
 			}
 		}
 
 		return result;
 	}
 
 	/**
 	 * Deserizalizes the given serialized tags.
 	 *
 	 * @param tags the text encoded tags.
 	 * @return the deserialized tag array.
 	 */
 	public static String[] deserializeTags(String tags) {
 		if (tags == null || tags.isEmpty()) return null;
 
 		String[] result = TAGS_SERIALIZED_CACHE.getReverse(tags);
 
 		if (result == null) {
 			List<String> tagList = new ArrayList<String>(5 + (tags.length() / 8)); // assuming avg tag size is 8 chars.
 
 			final Locale locale = Locale.getDefault();
 			final StringTokenizer tok = new StringTokenizer(tags, " ");
 			while (tok.hasMoreTokens()) {
 				tagList.add(tok.nextToken().toLowerCase(locale));
 			}
 
 			result = tagList.toArray(new String[tagList.size()]);
 
 			// For security reasons tags are sorted again when read.
 			// (to avoid that external DB modifications break the ACL internal logic when dealing with tags)
 			Arrays.sort(result);
 
 			TAGS_SERIALIZED_CACHE.put(tags, result);
 		}
 
 		// Clone the result before returning to avoid that external implementation can modify the cached values.
 		return result.clone();
 	}
 
 	/**
 	 * Serializes the given metadata to XML.
 	 *
 	 * @param metadata the metadata to encode.
 	 * @return the XML encoded metadata.
 	 */
 	public static String serializeMetadata(Metadata metadata) {
 		if (metadata == null || (EMPTY_METADATA_EQUALS_NULL && metadata.getMetaElements().isEmpty())) return null;
 
 		// Make sure all meta values are valid before allowing to write them.
 		metadata.assertValuesAreValidForWrite();
 
 		final StringWriter w = new StringWriter(2048);
 		try {
 			META_MARSHALLERS.getValue().marshal(metadata, new LimitedWriter(w, SERIALIZED_METADATA_LENGTH));
 			return w.toString();
 		} catch (JAXBException e) {
 			if (e.getCause() instanceof LimitedWriter.OutOfBounds) {
 				throw new IllegalArgumentException("The metadata element exceeds the maximum length of '" +
 						SERIALIZED_METADATA_LENGTH + "' characters.\n\n" + w.toString(), e);
 			} else
 				throw new RuntimeException(e);
 		}
 	}
 
 	/**
 	 * Deserizalizes the given XML serialized metadata.
 	 *
 	 * @param rawData the XML encoded metadata.
 	 * @return the deserialized metadata.
 	 */
 	public static Metadata deserializeMetadata(final String rawData) {
 		if (rawData == null || rawData.isEmpty()) return null;
 
 		return deserializeMetadata(new StreamSource(new StringReader(rawData)));
 	}
 
 	/**
 	 * Deserizalizes the given XML serialized metadata.
 	 *
 	 * @param rawData the XML encoded metadata.
 	 * @return the deserialized metadata.
 	 */
 	public static Metadata deserializeMetadata(final Source rawData) {
 		if (rawData == null) return null;
 
 		try {
 			return ValidationContext.getInstance().doUnvalidated(new Callable<Metadata>() {
 				@Override
 				public Metadata call() throws Exception {
 					final Unmarshaller um = META_UNMARSHALLERS.getValue();
 					final Metadata metadata;
 					if (rawData instanceof StAXSource) {
 						final StAXSource source = (StAXSource) rawData;
 						metadata = source.getXMLEventReader() == null ?
 								(Metadata) um.unmarshal(source.getXMLStreamReader()) :
 								(Metadata) um.unmarshal(source.getXMLEventReader());
 					} else
 						metadata = (Metadata) um.unmarshal(rawData);
 
 					if (EMPTY_METADATA_EQUALS_NULL && metadata.getMetaElements().isEmpty())
 						return null;
 
 					return metadata;
 				}
 			});
 		} catch (Exception e) {
 			throw new RuntimeException(e);
 		}
 	}
 
 	/**
 	 * Returns true if the 2 metadata owning instances differ.
 	 *
 	 * @param a the first instance to check.
 	 * @param b the second instance to check.
 	 * @return true if the 2 metadata owning instances differ.
 	 */
 	public static boolean metadataDiffers(MetadataOwner a, MetadataOwner b) {
 		final Metadata ma = a.getMetadata(), mb = b.getMetadata();
 		if (ma == null)
 			return mb != null;
 		else
 			return mb == null || !mb.equals(ma);
 	}
 
 	/**
 	 * Returns true if the 2 tagged instances differ.
 	 *
 	 * @param a the first instance to check.
 	 * @param b the second instance to check.
 	 * @return true if the 2 tagged instances differ.
 	 */
 	public static boolean tagsDiffer(Tagged a, Tagged b) {
 		Collection<String> ta = a.getTags(), tb = b.getTags();
 
 		if (ta.size() != tb.size()) return true;
 
 		ta = new HashSet<String>(ta);
 		for (String s : tb) {
 			if (!ta.contains(s)) return true;
 		}
 
 		return false;
 	}
 
 	/**
 	 * Returns true if the element is tagged with the given tags.
 	 *
 	 * @param element the element to check.
 	 * @param tags    the tags to verify.
 	 * @return true if the element contains all the tags, false if not, 'null' if the element was 'null'.
 	 */
 	public static Boolean isTaggedWith(Tagged element, String[] tags) {
 		if (element == null)
 			return null;
 		else {
 			for (String tag : tags) {
 				boolean invert = tag.startsWith("-");
 				boolean containsTag = element.containsTag(invert ? tag.substring(1) : tag);
 				if (invert ? containsTag : !containsTag) return false;
 			}
 			return true;
 		}
 	}
 
 	/**
 	 * Extracts a name part of a hierarchic package, family or vendor name.
 	 *
 	 * @param name           the name to work on.
 	 * @param delimiterCount the count of delimiters to include (e.g. 1 => vendorName, 2 => familyName, ...).
 	 * @return A name with all trailing name parts stripped.
 	 */
 	public static String extractName(String name, int delimiterCount) {
 		int endIdx = -1;
 		for (int i = 0; i < delimiterCount; i++)
 			endIdx = name.indexOf(':', endIdx + 1);
 
 		return endIdx == -1 ? name : name.substring(0, endIdx);
 	}
 
 	/**
 	 * Appends exactly one element to the given result list (using 'null' if the query produces no results).
 	 *
 	 * @param result the result list to add the element of the given query or 'null'
 	 *               if the query produced no results.
 	 * @param query  the query that fetches the element to add to the result.
 	 * @throws NonUniqueResultException In case of the query produced more than one result.
 	 */
 	public static <T> void appendSingleElementToList(final Collection<T> result, final TypedQuery<? extends T> query) {
 		final List<? extends T> ts = query.getResultList();
 
 		if (ts.isEmpty())
 			result.add(null);
 		else if (ts.size() > 1)
 			throw new NonUniqueResultException("More than one result returned for query " + query);
 		else
 			result.add(ts.get(0));
 	}
 
 	/**
 	 * Applies page number and size to the query.
 	 *
 	 * @param query      the query to apply the limits on.
 	 * @param pageNumber the number of the page to query.
 	 * @param pageSize   the size of a single page.
 	 * @return a positioned and limited query.
 	 */
 	public static <Q extends Query> Q applyPage(Q query, int pageNumber, int pageSize) {
 		query.setFirstResult(pageNumber * pageSize);
 		query.setMaxResults(pageSize + 1);
 		return query;
 	}
 
 	/**
 	 * Converts the given query to a list page.
 	 *
 	 * @param query         the query to convert.
 	 * @param emptyListPage the list page template instance to use.
 	 * @return the given list page, after filling the query results.
 	 */
 	@SuppressWarnings("unchecked")
 	public static <E, T extends AbstractListPage<E>> T toListPage(TypedQuery<E> query, T emptyListPage) {
 		return toListPage(query, (Callback<E, E>) SINGLE_ELEMENT_CALLBACK, emptyListPage);
 	}
 
 	/**
 	 * Converts the given query to a list page using converterCallback to convert results.
 	 *
 	 * @param query             the query to convert.
 	 * @param converterCallback a converter used to convert the query results to the type needed
 	 *                          within the list page.
 	 * @param emptyListPage     the list page template instance to use.
 	 * @return the given list page, after filling the query results.
 	 */
 	public static <E, V, T extends AbstractListPage<E>> T toListPage(
 			TypedQuery<V> query, Callback<V, E> converterCallback, T emptyListPage) {
 		return toListPage((Query) query, converterCallback, emptyListPage);
 	}
 
 	/**
 	 * Converts the given query to a list page using converterCallback to convert results.
 	 *
 	 * @param query             the query to convert.
 	 * @param converterCallback a converter used to convert the query results to the type needed
 	 *                          within the list page.
 	 * @param emptyListPage     the list page template instance to use.
 	 * @return the given list page, after filling the query results.
 	 */
 	@SuppressWarnings("unchecked")
 	public static <E, V, T extends AbstractListPage<E>> T toListPage(Query query, Callback<V, E> converterCallback, T emptyListPage) {
 
 		final int pageSize = query.getMaxResults() - 1, pageNumber = query.getFirstResult() / pageSize;
 
 		final List<V> results = (List<V>) query.getResultList();
 		final List<E> pageElements = new ArrayList<E>(results.size());
 
 		int count = 0;
 		for (V result : results) {
 			if (++count > pageSize) break;
 
 			pageElements.add(converterCallback.call(result));
 		}
 
 		if (pageElements.isEmpty()) return null;
 
 		emptyListPage.setPageNumber(pageNumber);
 		emptyListPage.setLastPage(count <= pageSize);
 		emptyListPage.setElements(pageElements);
 		return emptyListPage;
 	}
 
 	/**
 	 * Converts the given query to a name list page.
 	 *
 	 * @param query      the query to convert.
 	 * @param pageNumber the number of the page to extract.
 	 * @param pageSize   the size of the page to return.
 	 * @return the list page.
 	 */
 	@SuppressWarnings("unchecked")
 	public static NameListPage toNameListPage(Query query, int pageNumber, int pageSize) {
 		applyPage(query, pageNumber, pageSize);
 		return toListPage(query, (Callback<String, String>) SINGLE_ELEMENT_CALLBACK, new NameListPage());
 	}
 
 	/**
 	 * Converts the given query to a name list page.
 	 *
 	 * @param query      the query to convert.
 	 * @param pageNumber the number of the page to extract.
 	 * @param pageSize   the size of the page to return.
 	 * @return the list page.
 	 */
 	public static NameListPage toNameListPage(TypedQuery<String> query, int pageNumber, int pageSize) {
 		return toNameListPage((Query) query, pageNumber, pageSize);
 	}
 
 	private JpaUtils() {
 	}
 }