package com.trendmicro.grid.acl.metadata;
   
   import com.trendmicro.grid.acl.commons.XmlSerializer;
   import com.trendmicro.grid.acl.commons.collections.AbstractMapValueCollection;
   
   import javax.xml.bind.annotation.*;
   import java.io.*;
   import java.util.Collection;
   import java.util.List;
  import java.util.Map;
  
  /**
   * Defines the metadata root element used to store a single metadata package.
   *
   * @author Juergen_Kellerer, 2010-04-19
   * @version 1.0
   */
  @XmlAccessorType(XmlAccessType.PROPERTY)
  @XmlType(name = "metadata", namespace = Metadata.NS)
  @XmlRootElement(name = "metadata", namespace = Metadata.NS)
  public class Metadata implements Cloneable, Externalizable {
  
  	private static class MetaCollectionMapAdapter extends AbstractMapValueCollection<String, Meta> {
  		private MetaCollectionMapAdapter(Map<String, Meta> wrappedMap) {
  			super(wrappedMap);
  		}
  
  		protected String createKeyForValue(Meta value) {
  			return value.getName();
  		}
  	}
  
  	private static final long serialVersionUID = 8942843714209700817L;
  	private static final byte serialVersion = 1;
  
  	public static final String NS = "http://grid.trendmicro.com/metadata/1.0";
  	public static final String DEFAULT_SCHEMA_BASENAME = "metadata-schema";
  
  	private static XmlSerializer<Metadata> xmlSerializer =
  			new XmlSerializer<Metadata>(Metadata.class, NS, DEFAULT_SCHEMA_BASENAME);
  
  	public static XmlSerializer<Metadata> getXmlSerializer() {
  		return xmlSerializer;
  	}
  
  	public static List<File> generateSchema(final File outputDirectory, final String basename) throws Exception {
  		return xmlSerializer.generateSchema(outputDirectory, basename);
  	}
  
  	public static Metadata load(File file) throws Exception {
  		return xmlSerializer.load(file);
  	}
  
  	public static Metadata load(InputStream in) throws Exception {
  		return xmlSerializer.load(in);
  	}
  
  	public void save(File file) throws Exception {
  		xmlSerializer.save(this, file);
  	}
  
  	public void save(OutputStream out) throws Exception {
  		xmlSerializer.save(this, out);
  	}
  
  	ValidatedMetaMap metaElements;
  	final transient Collection<Meta> valueCollection;
  
  	/**
  	 * Constructs a new, empty Metadata instance.
  	 */
  	public Metadata() {
  		metaElements = new ValidatedMetaMap();
  		valueCollection = new MetaCollectionMapAdapter(metaElements);
  	}
  
  	/**
  	 * Constructs a copied Metadata instance.
  	 *
  	 * @param other The Metadata instance to copy.
  	 */
  	@SuppressWarnings("unchecked")
  	public Metadata(Metadata other) {
  		metaElements = other.metaElements.clone();
  		for (Map.Entry<String, Meta> entry : metaElements.entrySet())
  			entry.setValue(entry.getValue().clone());
  		valueCollection = new MetaCollectionMapAdapter(metaElements);
  	}
  
  	/**
  	 * Constructs a new, Metadata instance that is filled with the given elements.
  	 *
  	 * @param metaElements the elements to place inside this instance.
  	 */
  	public Metadata(Collection<Meta> metaElements) {
  		this();
  		setMetaElements(metaElements);
  	}
  
 	/**
 	 * Returns all elements.
 	 *
 	 * @return all elements.
 	 */
 	@XmlElement(name = "meta", namespace = NS)
 	public Collection<Meta> getMetaElements() {
 		return valueCollection;
 	}
 
 	public void setMetaElements(Collection<Meta> metaElements) {
 		if (metaElements != valueCollection) {
 			this.metaElements.clear();
 
 			if (metaElements != null)
 				for (Meta meta : metaElements)
 					this.metaElements.put(meta.getName(), meta);
 		}
 	}
 
 	/**
 	 * Validates that all contained values are valid and writable in the current context.
 	 */
 	public void assertValuesAreValidForWrite() {
 		metaElements.assertValuesAreValidForWrite();
 	}
 
 	/**
 	 * Returns a map of all Meta elements.
 	 *
 	 * @return a map of all Meta elements.
 	 */
 	public Map<String, Meta> getAll() {
 		return metaElements;
 	}
 
 	/**
 	 * Adds or overwrites a new Meta element.
 	 *
 	 * @param name the name of the Meta element to add or overwrite.
 	 * @return The newly added Meta element.
 	 */
 	public Meta add(String name) {
 		Meta p = new Meta(name);
 		metaElements.put(name, p);
 		return p;
 	}
 
 	/**
 	 * Returns the named meta element or 'null' if not existing.
 	 *
 	 * @param name the name of the Meta element to return.
 	 * @return the named meta element or 'null' if not existing.
 	 */
 	public Meta get(final String name) {
 		return get(name, null);
 	}
 
 	/**
 	 * Returns the named meta element or 'defaultValue' if not existing.
 	 *
 	 * @param name		 the name of the Meta element to return.
 	 * @param defaultValue the Meta element to return if the named element does not exist.
 	 * @return the named meta element or 'defaultValue' if not existing.
 	 */
 	public Meta get(final String name, final Meta defaultValue) {
 		Meta meta = metaElements.get(name);
 		return meta != null ? meta : defaultValue;
 	}
 
 	/**
 	 * Adds a new Meta element if not existing or returns the existing element.
 	 *
 	 * @param name the name of the Meta element to return or create.
 	 * @return a new Meta element if not existing or returns the existing element.
 	 */
 	public Meta addOrGet(final String name) {
 		Meta meta = get(name);
 		return meta != null ? meta : add(name);
 	}
 
 	/**
 	 * Removes the named Meta element and returns it.
 	 *
 	 * @param name the name of the Meta element to return or create.
 	 * @return the removed Meta element or 'null' if it didn't exist.
 	 */
 	public Meta remove(final String name) {
 		return metaElements.remove(name);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public String toString() {
 		return "Metadata{" +
 				"metaElements=" + valueCollection +
 				'}';
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public Metadata clone() {
 		return new Metadata(this);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public boolean equals(Object o) {
 		if (this == o) return true;
 		if (!(o instanceof Metadata)) return false;
 		Metadata metadata = (Metadata) o;
 		if (valueCollection.size() == metadata.valueCollection.size()) {
 			// Start comparisons with value collection as this is faster, fallback to map compare.
 			return valueCollection.equals(metadata.valueCollection) ||
 					metaElements.equals(metadata.metaElements);
 		} else
 			return false;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public int hashCode() {
 		return metaElements.hashCode();
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public void writeExternal(ObjectOutput out) throws IOException {
 		out.writeByte(serialVersion);
 
 		final Collection<Meta> metaCollection = metaElements.valuesWithoutValidation();
 		out.writeInt(metaCollection.size());
 		for (Meta meta : metaCollection)
 			meta.writeExternal(out);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
 		switch (in.readByte()) {
 			case 1:
 				if (!metaElements.isEmpty())
 					metaElements.clear();
 
 				for (int i = in.readInt(); i > 0; i--) {
 					Meta meta = new Meta();
 					meta.readExternal(in);
 					metaElements.putWithoutValidation(meta);
 				}
 				break;
 			default:
 				throw new IOException("Stream is corrupted or was written with a newer unsupported version.");
 		}
 	}
 }