package org.cateproject.view.flow;
   
   import java.beans.PropertyEditorSupport;
   
   import org.springframework.beans.BeanWrapperImpl;
   import org.springframework.beans.BeansException;
   import org.springframework.beans.NotReadablePropertyException;
   import org.springframework.beans.NotWritablePropertyException;
   import org.springframework.beans.TypeMismatchException;
  import org.springframework.binding.convert.ConversionException;
  import org.springframework.binding.convert.ConversionExecutor;
  import org.springframework.binding.convert.service.GenericConversionService;
  import org.springframework.binding.expression.EvaluationException;
  import org.springframework.binding.expression.Expression;
  import org.springframework.binding.expression.PropertyNotFoundException;
  import org.springframework.binding.expression.ValueCoercionException;
  import org.springframework.core.convert.ConversionService;
  
  public class BeanWrapperExpression implements Expression {
  
  	private String expression;
  
  	private GenericConversionService conversionService;
  
  	/**
  	 * Creates a new bean wrapper expression.
  	 * @param expression the property expression string
  	 * @param conversionService the conversion service containing converters to use as PropertyEditors for type
  	 * conversion
  	 */
  	public BeanWrapperExpression(String expression, GenericConversionService conversionService) {
  		this.expression = expression;
  		this.conversionService = conversionService;
  	}
  
  	public boolean equals(Object o) {
  		if (!(o instanceof BeanWrapperExpression)) {
  			return false;
  		}
  		BeanWrapperExpression other = (BeanWrapperExpression) o;
  		return expression.equals(other.expression);
  	}
  
  	public int hashCode() {
  		return expression.hashCode();
  	}
  
  	public Object getValue(Object context) throws EvaluationException {
  		try {
  			BeanWrapperImpl beanWrapper = new BeanWrapperImpl(context);
  			beanWrapper.setConversionService(conversionService.getDelegateConversionService());
  			return beanWrapper.getPropertyValue(expression);
  		} catch (NotReadablePropertyException e) {
  			throw new PropertyNotFoundException(context.getClass(), expression, e);
  		} catch (BeansException e) {
  			throw new EvaluationException(context.getClass(), getExpressionString(),
  					"A BeansException occurred getting the value for expression '" + getExpressionString()
  							+ "' on context [" + context.getClass() + "]", e);
  		}
  	}
  
  	public void setValue(Object context, Object value) {
  		try {
  			BeanWrapperImpl beanWrapper = new BeanWrapperImpl(context);
  			beanWrapper.setConversionService(conversionService.getDelegateConversionService());
  			
  			beanWrapper.setPropertyValue(expression, value);
  		} catch (NotWritablePropertyException e) {
  			throw new PropertyNotFoundException(context.getClass(), expression, e);
  		} catch (TypeMismatchException e) {
  			throw new ValueCoercionException(context.getClass(), expression, value, e.getRequiredType(), e);
  		} catch (BeansException e) {
  			throw new EvaluationException(context.getClass(), getExpressionString(),
  					"A BeansException occurred setting the value of expression '" + getExpressionString()
  							+ "' on context [" + context.getClass() + "] to [" + value + "]", e);
  		}
  	}
  
  	public Class getValueType(Object context) {
  		try {
  			BeanWrapperImpl beanWrapper = new BeanWrapperImpl(context);
  			return beanWrapper.getPropertyType(expression);
  		} catch (NotReadablePropertyException e) {
  			throw new PropertyNotFoundException(context.getClass(), expression, e);
  		} catch (BeansException e) {
  			throw new EvaluationException(context.getClass(), getExpressionString(),
  					"An BeansException occurred getting the value type for expression '" + getExpressionString()
  							+ "' on context [" + context.getClass() + "]", e);
  		}
  	}
  
  	public String getExpressionString() {
  		return expression;
  	}
  
  	public String toString() {
  		return expression;
  	}
  
 	/**
 	 * Adapts the String->Object converters to PropertyEditors for use during a setValue attempt. Excludes any
 	 * String->Enum converter, since BeanWrapper has built in support for Enum conversion.
 	 * @param registry the registry to register converter-to-editor adapters with
 	 */
 //	protected void registerConvertersAsPropertyEditors(PropertyEditorRegistry registry) {
 //		registry.registerCustomEditor(String.class,new StringTrimmerEditor(true));
 //
 //		Set converters = conversionService.getConversionExecutors(String.class);
 //		for (Iterator it = converters.iterator(); it.hasNext();) {
 //			ConversionExecutor converter = (ConversionExecutor) it.next();
 //			if (!converter.getTargetClass().getName().equals("java.lang.Enum")) {
 //				registry.registerCustomEditor(converter.getTargetClass(), new PropertyEditorConverter(converter));
 //			}
 //		}
 //	}
 
 	private static class PropertyEditorConverter extends PropertyEditorSupport {
 
 		private ConversionExecutor converter;
 
 		public PropertyEditorConverter(ConversionExecutor converter) {
 			this.converter = converter;
 		}
 
 		public void setAsText(String text) throws IllegalArgumentException {
 			try {
 				Object convertedValue = converter.execute(text);
 				setValue(convertedValue);
 			} catch (ConversionException e) {
 				IllegalArgumentException iae = new IllegalArgumentException("Unable to convert text '" + text + "'");
 				iae.initCause(e);
 				throw iae;
 			}
 		}
 	}
 
 }