package com.trendmicro.grid.acl.metadata;
   
   import net.sf.tinyjee.collections.Filter;
   import net.sf.tinyjee.collections.FilteredCollection;
   import net.sf.tinyjee.collections.FilteredSet;
   
   import java.util.Collection;
   import java.util.LinkedHashMap;
   import java.util.Map;
  import java.util.Set;
  
  /**
   * Implements a Map that transparently validates Meta elements.
   * <p/>
   * <ul>Known Issues:
   * <li>The collections, keySet(), values() and entrySet() do not properly protect the
   * Meta elements from getting changed.
   * <li>The Meta elements are not immutable and their value may get changed after adding
   * them to this map without being checked.
   * </ul>
   * In order to resolve some of these issues call {@link #assertValuesAreValidForWrite()}
   * before attempting to write the elements contained in this map.
   *
   * @author juergen_kellerer, 2010-11-30
   * @version 1.0
   */
  public class ValidatedMetaMap extends LinkedHashMap<String, Meta> implements Cloneable {
  
  	private static final long serialVersionUID = 3532083475416802063L;
  
  	private static final ValidatorResolver NULL_RESOLVER = new ValidatorResolver() {
  		@Override
  		public Validator getValidator() {
  			return null;
  		}
  	};
  
  	transient ValidatorResolver validatorResolver;
  
  	/**
  	 * Constructs a new validated map with default values for all entries.
  	 */
  	public ValidatedMetaMap() {
  		setValidatorResolver(ValidationContext.getInstance());
  	}
  
  	/**
  	 * Constructs a new validated map with the given options.
  	 *
  	 * @param initialCapacity   the initial capacity of the map.
  	 * @param validatorResolver the resolver to use.
  	 */
  	public ValidatedMetaMap(int initialCapacity, ValidatorResolver validatorResolver) {
  		super(initialCapacity);
  		setValidatorResolver(validatorResolver);
  	}
  
  	public ValidatorResolver getValidatorResolver() {
  		return validatorResolver;
  	}
  
  	public void setValidatorResolver(ValidatorResolver resolver) {
  		this.validatorResolver = resolver == null ? NULL_RESOLVER : resolver;
  	}
  
  	/**
  	 * Returns the used validator for the current context.
  	 *
  	 * @return the used validator for the current context.
  	 */
  	public Validator getValidator() {
  		return validatorResolver.getValidator();
  	}
  
  	/**
  	 * Validates that all contained values are valid and writable in the current context.
  	 */
  	public void assertValuesAreValidForWrite() {
  		final Validator validator = validatorResolver.getValidator();
  		if (validator != null) {
  			for (Meta meta : super.values())
  				assertIsValidAndWritable(validator, meta.getName(), meta);
  		}
  	}
  
  	private void assertIsValidAndWritable(final Validator validator, final String key, final Meta value) {
  		if (!validator.isWritable(key)) {
  			throw new IllegalStateException("Cannot write the meta element named as '" + key +
  					"'. It is not allowed to set or change the value in the current context.");
  		}
  
  		if (!validator.isValid(value)) {
  			throw new IllegalArgumentException("Cannot write the meta element '" + value + "'. " +
  					"The format of the element is invalid with regards to the active meta data profile " +
  					"within the current context.");
  		}
  	}
  
  	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public Meta get(Object key) {
 		final Validator validator = validatorResolver.getValidator();
 		if (validator == null || validator.isReadable((String) key))
 			return super.get(key);
 		return null;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public Meta put(String key, Meta value) {
 		final Validator validator = validatorResolver.getValidator();
 		// Note: We may validate only when this value existed already.
 		//       Metadata cannot be built due to timing issues when validating entries that do not yet exist.
 		if (validator != null && containsKey(key))
 			assertIsValidAndWritable(validator, key, value);
 		return super.put(key, value);
 	}
 
 	/**
 	 * Puts the given meta entry without validating it.
 	 *
 	 * @param value the meta entry to put.
 	 */
 	void putWithoutValidation(Meta value) {
 		super.put(value.getName(), value);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public void putAll(Map<? extends String, ? extends Meta> m) {
 		final Validator validator = validatorResolver.getValidator();
 		if (validator != null) {
 			// Note: We may validate only when this value existed already.
 			//       Metadata cannot be built due to timing issues when validating entries that do not yet exist.
 			for (Map.Entry<? extends String, ? extends Meta> entry : m.entrySet())
 				if (containsKey(entry.getKey()))
 					assertIsValidAndWritable(validator, entry.getKey(), entry.getValue());
 		}
 		super.putAll(m);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public Meta remove(Object key) {
 		final Validator validator = validatorResolver.getValidator();
 		if (validator != null && !validator.isWritable((String) key)) {
 			throw new IllegalStateException("Cannot remove the meta element named as '" + key +
 					"'. It is not allowed to change the value in the current context.");
 		}
 
 		return super.remove(key);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public Set<String> keySet() {
 		final Validator validator = validatorResolver.getValidator();
 		if (validator == null)
 			return super.keySet();
 		else {
 			return new FilteredSet<String>(super.keySet(), new Filter<String>() {
 				@Override
 				public boolean accept(String value) {
 					return validator.isReadable(value);
 				}
 			});
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public Collection<Meta> values() {
 		final Validator validator = validatorResolver.getValidator();
 		if (validator == null)
 			return super.values();
 		else {
 			return new FilteredCollection<Meta>(super.values(), new Filter<Meta>() {
 				@Override
 				public boolean accept(Meta value) {
 					return value == null || validator.isReadable(value.getName());
 				}
 			});
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public Set<Map.Entry<String, Meta>> entrySet() {
 		final Validator validator = validatorResolver.getValidator();
 		if (validator == null)
 			return super.entrySet();
 		else {
 			return new FilteredSet<Map.Entry<String, Meta>>(super.entrySet(), new Filter<Map.Entry<String, Meta>>() {
 				@Override
 				public boolean accept(Map.Entry<String, Meta> value) {
 					return validator.isReadable(value.getKey());
 				}
 			});
 		}
 	}
 
 	/**
 	 * Returns all values without validating anything.
 	 *
 	 * @return all values without validating anything.
 	 */
 	Collection<Meta> valuesWithoutValidation() {
 		return super.values();
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public ValidatedMetaMap clone() {
 		return (ValidatedMetaMap) super.clone();
 	}
 }