package com.buckosoft.PicMan.service.support;
   
   import java.io.IOException;
   import java.lang.reflect.InvocationTargetException;
   import java.util.HashSet;
   import java.util.Map;
   
   import com.fasterxml.jackson.core.JsonParser;
   import com.fasterxml.jackson.core.JsonProcessingException;
  import com.fasterxml.jackson.core.JsonToken;
  import com.fasterxml.jackson.databind.AnnotationIntrospector;
  import com.fasterxml.jackson.databind.BeanProperty;
  import com.fasterxml.jackson.databind.DeserializationContext;
  import com.fasterxml.jackson.databind.JavaType;
  import com.fasterxml.jackson.databind.JsonDeserializer;
  import com.fasterxml.jackson.databind.JsonMappingException;
  import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
  import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
  import com.fasterxml.jackson.databind.deser.ContextualKeyDeserializer;
  import com.fasterxml.jackson.databind.deser.ResolvableDeserializer;
  import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
  import com.fasterxml.jackson.databind.deser.ValueInstantiator;
  import com.fasterxml.jackson.databind.deser.impl.PropertyBasedCreator;
  import com.fasterxml.jackson.databind.deser.impl.PropertyValueBuffer;
  import com.fasterxml.jackson.databind.deser.std.ContainerDeserializerBase;
  import com.fasterxml.jackson.databind.deser.std.UntypedObjectDeserializer;
  import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
  import com.fasterxml.jackson.databind.util.ArrayBuilders;
  
  /**
   * Basic serializer that can take Json "Object" structure and construct a
   * {@link java.util.Map} instance, with typed contents.
   * <p>
   * Note: for untyped content (one indicated by passing Object.class as the
   * type), {@link UntypedObjectDeserializer} is used instead. It can also
   * construct {@link java.util.Map}s, but not with specific POJO types, only
   * other containers and primitives/wrappers.
   */
  @JacksonStdImpl
  public class KeyValueMapDeserializer extends
  		ContainerDeserializerBase<Map<Object, Object>> implements
  		ContextualDeserializer, ResolvableDeserializer, MapLabels {
  	// // Configuration: typing, deserializers
  
  	private static final long serialVersionUID = 6589120424431005028L;
  
  	protected final JavaType _mapType;
  
  	/**
  	 * Key deserializer to use; either passed via constructor (when indicated by
  	 * annotations), or resolved when {@link #resolve} is called;
  	 */
  	protected final JsonDeserializer<Object> _keyDeserializer;
  
  	/**
  	 * Flag set to indicate that the key type is {@link java.lang.String} (or
  	 * {@link java.lang.Object}, for which String is acceptable), <b>and</b>
  	 * that the default Jackson key deserializer would be used. If both are
  	 * true, can optimize handling.
  	 */
  	protected boolean _standardStringKey;
  
  	/**
  	 * Value deserializer.
  	 */
  	protected final JsonDeserializer<Object> _valueDeserializer;
  
  	/**
  	 * If value instances have polymorphic type information, this is the type
  	 * deserializer that can handle it
  	 */
  	protected final TypeDeserializer _valueTypeDeserializer;
  
  	// // Instance construction settings:
  
  	protected final ValueInstantiator _valueInstantiator;
  
  	protected final boolean _hasDefaultCreator;
  
  	/**
  	 * Deserializer that is used iff delegate-based creator is to be used for
  	 * deserializing from JSON Object.
  	 */
  	protected JsonDeserializer<Object> _delegateDeserializer;
  
  	/**
  	 * If the Map is to be instantiated using non-default constructor or factory
  	 * method that takes one or more named properties as argument(s), this
  	 * creator is used for instantiation.
  	 */
  	protected PropertyBasedCreator _propertyBasedCreator;
  
  	// // Any properties to ignore if seen?
  
  	protected HashSet<String> _ignorableProperties;
  
  	/*
  	 * /********************************************************** /* Life-cycle
  	 * /**********************************************************
 	 */
 
 	@SuppressWarnings("deprecation")
 	public KeyValueMapDeserializer(JavaType mapType,
 			ValueInstantiator valueInstantiator,
 			JsonDeserializer<Object> keyDeser,
 			JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser) {
 		super(Map.class);
 		_mapType = mapType;
 		_keyDeserializer = keyDeser;
 		_valueDeserializer = valueDeser;
 		_valueTypeDeserializer = valueTypeDeser;
 		_valueInstantiator = valueInstantiator;
 		_hasDefaultCreator = false;//valueInstantiator.canCreateUsingDefault();
 		_delegateDeserializer = null;
 		_propertyBasedCreator = null;
 		_standardStringKey = _isStdKeyDeser(mapType, keyDeser);
 	}
 
 	/**
 	 * Copy-constructor that can be used by sub-classes to allow copy-on-write
 	 * styling copying of settings of an existing instance.
 	 */
 	@SuppressWarnings("deprecation")
 	protected KeyValueMapDeserializer(KeyValueMapDeserializer src) {
 		super(src._valueClass);
 		_mapType = src._mapType;
 		_keyDeserializer = src._keyDeserializer;
 		_valueDeserializer = src._valueDeserializer;
 		_valueTypeDeserializer = src._valueTypeDeserializer;
 		_valueInstantiator = src._valueInstantiator;
 		_propertyBasedCreator = src._propertyBasedCreator;
 		_delegateDeserializer = src._delegateDeserializer;
 		_hasDefaultCreator = src._hasDefaultCreator;
 		// should we make a copy here?
 		_ignorableProperties = src._ignorableProperties;
 
 		_standardStringKey = src._standardStringKey;
 	}
 
 	@SuppressWarnings("deprecation")
 	protected KeyValueMapDeserializer(KeyValueMapDeserializer src,
 			ValueInstantiator valueInstantiator,
 			JsonDeserializer<Object> keyDeser,
 			JsonDeserializer<Object> valueDeser,
 			TypeDeserializer valueTypeDeser, HashSet<String> ignorable) {
 		super(src._valueClass);
 		_mapType = src._mapType;
 		_keyDeserializer = keyDeser;
 		_valueDeserializer = valueDeser;
 		_valueTypeDeserializer = valueTypeDeser;
 		_valueInstantiator = valueInstantiator;
 		_propertyBasedCreator = src._propertyBasedCreator;
 		_delegateDeserializer = src._delegateDeserializer;
 		_hasDefaultCreator = src._hasDefaultCreator;
 		_ignorableProperties = ignorable;
 
 		_standardStringKey = _isStdKeyDeser(_mapType, keyDeser);
 	}
 
 	/**
 	 * Fluent factory method used to create a copy with slightly different
 	 * settings. When sub-classing, MUST be overridden.
 	 */
 	@SuppressWarnings("unchecked")
 	protected KeyValueMapDeserializer withResolved(
 			JsonDeserializer<?> keyDeser, TypeDeserializer valueTypeDeser,
 			JsonDeserializer<?> valueDeser, ValueInstantiator vi, HashSet<String> ignorable) {
 
 		if ((_keyDeserializer == keyDeser)
 				&& (_valueDeserializer == valueDeser)
 				&& (_valueTypeDeserializer == valueTypeDeser)
 				&& (_ignorableProperties == ignorable)
 				&& (_valueInstantiator == vi)) {
 			return this;
 		}
 		return new KeyValueMapDeserializer(this,
 				vi,
 				(JsonDeserializer<Object>) keyDeser,
 				(JsonDeserializer<Object>) valueDeser, valueTypeDeser,
 				ignorable);
 	}
 
 	/**
 	 * Helper method used to check whether we can just use the default key
 	 * deserialization, where JSON String becomes Java String.
 	 */
 	protected final boolean _isStdKeyDeser(JavaType mapType,
 			JsonDeserializer<Object> keyDeser) {
 		if (keyDeser == null) {
 			return true;
 		}
 		JavaType keyType = mapType.getKeyType();
 		if (keyType == null) { // assumed to be Object
 			return true;
 		}
 		Class<?> rawKeyType = keyType.getRawClass();
 		return ((rawKeyType == String.class || rawKeyType == Object.class) && _isDefaultKeyDeserializer(keyDeser));
 	}
 
 	protected boolean _isDefaultKeyDeserializer(
 			JsonDeserializer<Object> keyDeser) {
 		return (keyDeser != null && keyDeser.getClass().getAnnotation(
 				JacksonStdImpl.class) != null);
 	}
 
 	public void setIgnorableProperties(String[] ignorable) {
 		_ignorableProperties = (ignorable == null || ignorable.length == 0) ? null
 				: ArrayBuilders.arrayToSet(ignorable);
 	}
 
 	/*
 	 * /********************************************************** /*
 	 * Validation, post-processing (ResolvableDeserializer)
 	 * /**********************************************************
 	 */
 
 	// @Override
 	public void resolve(DeserializationContext ctxt)
 			throws JsonMappingException {
 		// May need to resolve types for delegate- and/or property-based
 		// creators:
 		final ValueInstantiator valueInstantiator = ctxt.getFactory().findValueInstantiator(ctxt, ctxt.getConfig().introspectForCreation(_mapType));
 		
 		if (valueInstantiator.canCreateUsingDelegate()) {
 			JavaType delegateType = valueInstantiator.getDelegateType(ctxt
 					.getConfig());
 			if (delegateType == null) {
 				throw new IllegalArgumentException(
 						"Invalid delegate-creator definition for "
 								+ _mapType
 								+ ": value instantiator ("
 								+ valueInstantiator.getClass().getName()
 								+ ") returned true for 'canCreateUsingDelegate()', but null for 'getDelegateType()'");
 			}
 			/*
 			 * Theoretically should be able to get CreatorProperty for delegate
 			 * parameter to pass; but things get tricky because DelegateCreator
 			 * may contain injectable values. So, for now, let's pass nothing.
 			 */
 			_delegateDeserializer = findDeserializer(ctxt, delegateType, null);
 		}
 		if (valueInstantiator.canCreateFromObjectWith()) {
 			SettableBeanProperty[] creatorProps = valueInstantiator
 					.getFromObjectArguments(ctxt.getConfig());
 			_propertyBasedCreator = PropertyBasedCreator.construct(ctxt,
 					valueInstantiator, creatorProps);
 		}
 		_standardStringKey = _isStdKeyDeser(_mapType, _keyDeserializer);
 	}
 
 	/**
 	 * Method called to finalize setup of this deserializer, when it is known
 	 * for which property deserializer is needed for.
 	 */
 	// @Override
 	public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
 			BeanProperty property) throws JsonMappingException {
 		JsonDeserializer<?> kd = _keyDeserializer;
 		if (kd == null) {
 			kd = ctxt.findContextualValueDeserializer(_mapType.getKeyType(),
 					property);
 		} else {
 			if (kd instanceof ContextualKeyDeserializer) {
 				kd = ((ContextualDeserializer) kd).createContextual(ctxt,
 						property);
 			}
 		}
 		JsonDeserializer<?> vd = _valueDeserializer;
 		if (vd == null) {
 			vd = ctxt.findContextualValueDeserializer(
 					_mapType.getContentType(), property);
 		} else { // if directly assigned, probably not yet contextual, so:
 			if (vd instanceof ContextualDeserializer) {
 				vd = ((ContextualDeserializer) vd).createContextual(ctxt,
 						property);
 			}
 		}
 		TypeDeserializer vtd = _valueTypeDeserializer;
 		if (vtd != null) {
 			vtd = vtd.forProperty(property);
 		}
 		HashSet<String> ignored = _ignorableProperties;
 		AnnotationIntrospector intr = ctxt.getAnnotationIntrospector();
 		if (intr != null && property != null) {
 			String[] moreToIgnore = intr.findPropertiesToIgnore(property
 					.getMember());
 			if (moreToIgnore != null) {
 				ignored = (ignored == null) ? new HashSet<String>()
 						: new HashSet<String>(ignored);
 				for (String str : moreToIgnore) {
 					ignored.add(str);
 				}
 			}
 		}
 		
 		ValueInstantiator vi = _valueInstantiator;
 		if (vi == null) {
 			vi = ctxt.getFactory().findValueInstantiator(ctxt, ctxt.getConfig().introspectForCreation(_mapType));
 		}
 		return withResolved(kd, vtd, vd, vi, ignored);
 	}
 
 	/*
 	 * /********************************************************** /*
 	 * ContainerDeserializerBase API
 	 * /**********************************************************
 	 */
 
 	@Override
 	public JavaType getContentType() {
 		return _mapType.getContentType();
 	}
 
 	@Override
 	public JsonDeserializer<Object> getContentDeserializer() {
 		return _valueDeserializer;
 	}
 
 	/*
 	 * /********************************************************** /*
 	 * JsonDeserializer API
 	 * /**********************************************************
 	 */
 
 	@Override
 	@SuppressWarnings("unchecked")
 	public Map<Object, Object> deserialize(JsonParser jp,
 			DeserializationContext ctxt) throws IOException,
 			JsonProcessingException {
 		
 		if (_propertyBasedCreator != null) {
 			return _deserializeUsingCreator(jp, ctxt);
 		}
 		if (_delegateDeserializer != null) {
 			return (Map<Object, Object>) _valueInstantiator
 					.createUsingDelegate(ctxt,
 							_delegateDeserializer.deserialize(jp, ctxt));
 		}
 		if (!_hasDefaultCreator && !_valueInstantiator.canCreateUsingDefault()) {
 			throw ctxt.instantiationException(getMapClass(),
 					"No default constructor found");
 		}
 		// Ok: must point to START_ARRAY, START_OBJECT or END_ARRAY
 		JsonToken t = jp.getCurrentToken();
 		if (t != JsonToken.START_ARRAY && t != JsonToken.START_OBJECT
 				&& t != JsonToken.END_ARRAY) {
 			// [JACKSON-620] (empty) String may be ok however:
 			if (t == JsonToken.VALUE_STRING) {
 				return (Map<Object, Object>) _valueInstantiator
 						.createFromString(ctxt, jp.getText());
 			}
 			throw ctxt.mappingException(getMapClass());
 		}
 		final Map<Object, Object> result = (Map<Object, Object>) _valueInstantiator
 				.createUsingDefault(ctxt);
 		if (_standardStringKey) {
 			_readAndBindStringMap(jp, ctxt, result);
 			return result;
 		}
 		_readAndBind(jp, ctxt, result);
 		return result;
 	}
 
 	@Override
 	public Map<Object, Object> deserialize(JsonParser jp,
 			DeserializationContext ctxt, Map<Object, Object> result)
 			throws IOException, JsonProcessingException {
 		// Ok: must point to START_ARRAY or START_OBJECT
 		JsonToken t = jp.getCurrentToken();
 		if (t != JsonToken.START_ARRAY && t != JsonToken.START_OBJECT) {
 			throw ctxt.mappingException(getMapClass());
 		}
 		if (_standardStringKey) {
 			_readAndBindStringMap(jp, ctxt, result);
 			return result;
 		}
 		_readAndBind(jp, ctxt, result);
 		return result;
 	}
 
 	@Override
 	public Object deserializeWithType(JsonParser jp,
 			DeserializationContext ctxt, TypeDeserializer typeDeserializer)
 			throws IOException, JsonProcessingException {
 		// In future could check current token... for now this should be enough:
 		return typeDeserializer.deserializeTypedFromObject(jp, ctxt);
 	}
 
 	/*
 	 * /********************************************************** /* Other
 	 * public accessors
 	 * /**********************************************************
 	 */
 
 	@SuppressWarnings("unchecked")
 	public final Class<?> getMapClass() {
 		return (Class<Map<Object, Object>>) _mapType.getRawClass();
 	}
 
 	@Override
 	public JavaType getValueType() {
 		return _mapType;
 	}
 
 	/*
 	 * /********************************************************** /* Internal
 	 * methods /**********************************************************
 	 */
 
 	protected final void _readAndBind(JsonParser jp,
 			DeserializationContext ctxt, Map<Object, Object> result)
 			throws IOException, JsonProcessingException {
 		JsonToken t = jp.getCurrentToken();
 		if (t == JsonToken.START_ARRAY) {
 			t = jp.nextToken();
 		}
 		final JsonDeserializer<Object> keyDes = _keyDeserializer;
 		final JsonDeserializer<Object> valueDes = _valueDeserializer;
 		final TypeDeserializer typeDeser = _valueTypeDeserializer;
 		for (; t == JsonToken.START_OBJECT; t = jp.nextToken()) {
 			Object key = null, value = null;
 			
 			for (t = jp.nextToken(); t == JsonToken.FIELD_NAME; t = jp.nextToken()) {
 				// Must point to field name
 				String fieldName = jp.getCurrentName();
 				t = jp.nextToken();
 				if (_ignorableProperties != null
 						&& _ignorableProperties.contains(fieldName)) {
 					jp.skipChildren();
 					continue;
 				}
 
 				if (MAP_KEY_NAME.equals(fieldName)) {
 					if (t == JsonToken.VALUE_NULL) {
 						// handle null keys
 						key = null;
 					} else {
 						key = keyDes.deserialize(jp, ctxt);
 					}
 				} else if (MAP_VALUE_NAME.equals(fieldName)) {
 					// Note: must handle null explicitly here; value
 					// deserializers won't
 					if (t == JsonToken.VALUE_NULL) {
 						value = null;
 					} else if (typeDeser == null) {
 						value = valueDes.deserialize(jp, ctxt);
 					} else {
 						value = valueDes.deserializeWithType(jp, ctxt,
 								typeDeser);
 					}
 				}
 				/*
 				 * !!! 23-Dec-2008, tatu: should there be an option to verify
 				 * that there are no duplicate field names? (and/or what to do,
 				 * keep-first or keep-last)
 				 */
 				if (key != null) {
 					result.put(key, value);
 				}
 			}
 		}
 	}
 
 	/**
 	 * Optimized method used when keys can be deserialized as plain old
 	 * {@link java.lang.String}s, and there is no custom deserialized specified.
 	 */
 	protected final void _readAndBindStringMap(JsonParser jp,
 			DeserializationContext ctxt, Map<Object, Object> result)
 			throws IOException, JsonProcessingException {
 		JsonToken t = jp.getCurrentToken();
 		if (t == JsonToken.START_OBJECT) {
 			t = jp.nextToken();
 		}
 		final JsonDeserializer<Object> valueDes = _valueDeserializer;
 		final TypeDeserializer typeDeser = _valueTypeDeserializer;
 		for (; t == JsonToken.FIELD_NAME; t = jp.nextToken()) {
 			// Must point to field name
 			String fieldName = jp.getCurrentName();
 			// And then the value...
 			t = jp.nextToken();
 			if (_ignorableProperties != null
 					&& _ignorableProperties.contains(fieldName)) {
 				jp.skipChildren();
 				continue;
 			}
 			// Note: must handle null explicitly here; value deserializers won't
 			Object value;
 			if (t == JsonToken.VALUE_NULL) {
 				value = null;
 			} else if (typeDeser == null) {
 				value = valueDes.deserialize(jp, ctxt);
 			} else {
 				value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
 			}
 			result.put(fieldName, value);
 		}
 	}
 
 	@SuppressWarnings("unchecked")
 	public Map<Object, Object> _deserializeUsingCreator(JsonParser jp,
 			DeserializationContext ctxt) throws IOException,
 			JsonProcessingException {
 		final PropertyBasedCreator creator = _propertyBasedCreator;
 		// null -> no ObjectIdReader for Maps (yet?)
 		PropertyValueBuffer buffer = creator.startBuilding(jp, ctxt, null);
 
 		JsonToken t = jp.getCurrentToken();
 		if (t == JsonToken.START_OBJECT) {
 			t = jp.nextToken();
 		}
 		final JsonDeserializer<Object> valueDes = _valueDeserializer;
 		final TypeDeserializer typeDeser = _valueTypeDeserializer;
 		for (; t == JsonToken.FIELD_NAME; t = jp.nextToken()) {
 			String propName = jp.getCurrentName();
 			t = jp.nextToken(); // to get to value
 			if (_ignorableProperties != null
 					&& _ignorableProperties.contains(propName)) {
 				jp.skipChildren(); // and skip it (in case of array/object)
 				continue;
 			}
 			// creator property?
 			SettableBeanProperty prop = creator.findCreatorProperty(propName);
 			if (prop != null) {
 				// Last property to set?
 				Object value = prop.deserialize(jp, ctxt);
 				if (buffer.assignParameter(prop.getCreatorIndex(), value)) {
 					jp.nextToken();
 					Map<Object, Object> result;
 					try {
 						result = (Map<Object, Object>) creator.build(ctxt,
 								buffer);
 					} catch (Exception e) {
 						wrapAndThrow(e, _mapType.getRawClass());
 						return null;
 					}
 					_readAndBind(jp, ctxt, result);
 					return result;
 				}
 				continue;
 			}
 			Object key = _keyDeserializer.deserialize(jp, ctxt);
 			Object value;
 			if (t == JsonToken.VALUE_NULL) {
 				value = null;
 			} else if (typeDeser == null) {
 				value = valueDes.deserialize(jp, ctxt);
 			} else {
 				value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
 			}
 			buffer.bufferMapProperty(key, value);
 		}
 		// end of JSON object?
 		// if so, can just construct and leave...
 		try {
 			return (Map<Object, Object>) creator.build(ctxt, buffer);
 		} catch (Exception e) {
 			wrapAndThrow(e, _mapType.getRawClass());
 			return null;
 		}
 	}
 
 	// note: copied form BeanDeserializer; should try to share somehow...
 	protected void wrapAndThrow(Throwable t, Object ref) throws IOException {
 		// to handle StackOverflow:
 		while (t instanceof InvocationTargetException && t.getCause() != null) {
 			t = t.getCause();
 		}
 		// Errors and "plain" IOExceptions to be passed as is
 		if (t instanceof Error) {
 			throw (Error) t;
 		}
 		// ... except for mapping exceptions
 		if (t instanceof IOException && !(t instanceof JsonMappingException)) {
 			throw (IOException) t;
 		}
 		throw JsonMappingException.wrapWithPath(t, ref, null);
 	}
 }