/***
    * Copyright (C) 2006 Philipp Mpalampanis
    *
    * License: MPL 1.1/GPL 2.0/LGPL 2.1
    *
    * The contents of this file are subject to the Mozilla Public License Version
    * 1.1 (the "License"); you may not use this file except in compliance with
    * the License. You may obtain a copy of the License at
    * http://www.mozilla.org/MPL/
   *
   * Software distributed under the License is distributed on an "AS IS" basis,
   * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
   * for the specific language governing rights and limitations under the
   * License.
   *
   * Alternatively, the contents of this file may be used under the terms of
   * either the GNU General Public License Version 2 or later (the "GPL"), or
   * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
   * in which case the provisions of the GPL or the LGPL are applicable instead
   * of those above. If you wish to allow use of your version of this file only
   * under the terms of either the GPL or the LGPL, and not to allow others to
   * use your version of this file under the terms of the MPL, indicate your
   * decision by deleting the provisions above and replace them with the notice
   * and other provisions required by the GPL or the LGPL. If you do not delete
   * the provisions above, a recipient may use your version of this file under
   * the terms of any one of the MPL, the GPL or the LGPL.
   */
  
  package net.sf.echobinding.binding;
  
  import java.util.StringTokenizer;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import net.sf.echobinding.validation.BeanValidator;
  import net.sf.echobinding.validation.ValidationReport;
  import ognl.*;
  
  import org.apache.log4j.Logger;
  import org.hibernate.Hibernate;
  
  /***
   * This is an implemenation of the <code>PropertyAdaper</code> interface using OGNL
   * expressions for accessing domain model properties.
   * 
   */
  public class OgnlPropertyAdapter extends AbstractPropertyAdapter {
  
  	@SuppressWarnings("unused")
  	private final Logger _logger = Logger.getLogger(OgnlPropertyAdapter.class);
  	
  	private String _expression;
  	
  	private Object _parsedExpression;
  	
  	/***
  	 * Creates a new PropertyAdapter using OGNL expressions for accessing model properties.
  	 * 
  	 * @param expression The OGNL expression
  	 */
  	public OgnlPropertyAdapter(String expression) {
  		setExpression(expression);
  	}
  	
  
  	/* (non-Javadoc)
  	 * @see echobinding.Binding#setValue(java.lang.Object, java.lang.Object)
  	 */
  	public void setValue(Object bean, Object value) {
  		setValue(null, bean, value);
  	}
  
  	/* (non-Javadoc)
  	 * @see echobinding.Binding#getValue(java.lang.Object)
  	 */
  	public Object getValue(Object bean) throws BindingException {
  		return getValue(null, bean);
  	}
  
  
  	/***
  	 * Sets the value. 
  	 * 
  	 * @param context
  	 * @param bean
  	 * @param value
  	 * @throws BindingException
  	 */
  	public void setValue(OgnlContext context, Object bean, Object value) throws BindingException {
  		
  		Object newValue = parse(value);	
  		try {
  			if(context != null)
  				Ognl.setValue(_parsedExpression, context, bean, newValue);
  			else
  				Ognl.setValue(_parsedExpression, bean, newValue);
          }
          catch (OgnlException e) {
          	// e.printStackTrace();
         	throw new BindingException(e.getMessage(), e);
         }
 	}
 	
 	
 	/***
 	 * 
 	 * @param context
 	 * @param bean
 	 * @return
 	 */
 	public Object getValue(OgnlContext context, Object bean) {
 		if (context == null && bean == null)
 			throw new BindingException("Bean and context must not be null!");
 		
 		// _logger.debug( "Looking up property '" + getExpression() + "' bean class = " + bean.getClass() + " OgnlContext =  "+context);
 		
 		Object value = null;
         try {
         	if(context != null)
         		value = Ognl.getValue( _parsedExpression, context, bean );
         	else
         		value = Ognl.getValue( _parsedExpression, bean );
         }
         catch (OgnlException e) {
         	_logger.debug( "Property '" + getExpression() + "' not found. Exception = " + e.getMessage() );
         	String hint ="An error has occured.";
         	if(e instanceof ognl.NoSuchPropertyException) {
 	        	if(bean != null) {
 	        		hint="Property not found in class "+bean.getClass().getName()+". ";
 	        	}
         	}
             throw new BindingException("Could not get value for property adapter '"+getId()+"' (expression='"+getExpression()+"')! "+hint+"", e);
         }
        //  _logger.debug( "Property '" + getExpression() + "' was found. Value = " + value );
         return value == null ? null : format(value);
 	}
 
 	
 	/***
 	 * Validates a bean property by examing its annotated contraints. 
 	 * 
 	 * @param bean 
 	 * @param value 
 	 * @return 
 	 * 
 	 * @see Hibernate Validation Framework 
 	 * 
 	 * @throws OgnlException 
 	 */
 	public ValidationReport validateBean(Object bean, Object value) {
 		
 		Node node = (Node) _parsedExpression;
 
 		String ognlContextName = getOgnlContextName();
 		if(ognlContextName!=null) {
 			String expression = getExpression().replaceFirst( "#"+ognlContextName+"//.", "" );
 			node = (Node) parseExpression( expression );
 		}
 		
 		String propertyName;
 		Node child;
 		
 		ValidationReport validationReport = null;
 		for( int i = 0; i < node.jjtGetNumChildren(); i++ ) {
 			
 			child = node.jjtGetChild(i);
 			propertyName = child.toString().replaceAll("\"", "");
 	
 			validationReport = BeanValidator.validate(bean, propertyName, value);
 			
 			OgnlContext context = (OgnlContext) Ognl.createDefaultContext(bean);
 			try {
 				bean = child.getValue( context, bean);
 			} catch (OgnlException e) {
 				e.printStackTrace();
 			}
 		}
 		
 		return validationReport;
 	}
 	
 	
 	
 	/* (non-Javadoc)
 	 * @see echobinding.binding.AbstractPropertyAdapter#validate(java.lang.Object, java.lang.Object)
 	 */
 	@Override
 	public ValidationReport validate(Object bean, Object value) {
 		ValidationReport report = super.validate( bean, value );
 		
 		// validate bean
 		if(report.isValid())
 			report = validateBean(bean, parse( value ));
 		
 		return report;
 	}
 
 
 	public PropertyAdapter newInstance() {
 		
 		OgnlPropertyAdapter binding = new OgnlPropertyAdapter(getExpression());
 		binding.setDecorator(getDecorator());
 		binding.setFormat(getFormat());
 		binding.setLabel(getLabel());
 		binding.setSubContext(getSubContext());
 		binding.setValidators(getValidators());
 		binding.setValidationHandler(getValidationHandler());
 
 		return binding;
 	}
 
 
 	@Override
 	public String toString() {
 		return "OgnlPropertyAdapter#"+getExpression()+"#"+hashCode();
 	}
 
 
 	/***
 	 * @return Returns the parsedExpression.
 	 */
 	protected Object getParsedExpression() {
 		return _parsedExpression;
 	}
 
 	/*** 
 	 * Returns the OGNL expression.
 	 * 
 	 * @return The OGNL expression
 	 */
 	public String getExpression() {
 		return _expression;
 	}
 
 	/***
 	 * Sets the OGNL expression.
 	 * 
 	 * @param the OGNL expression
 	 * @return the property adapter
 	 */
 	public void setExpression(String expression) {
 		_expression = expression;
 		_parsedExpression = parseExpression( expression );
 	}
 
 
 	/***
 	 * @param expression
 	 * @return
 	 */
 	private Object parseExpression(String expression) {
 		Object parsedExpression = null;
 		try {
 			parsedExpression = Ognl.parseExpression(expression);
 		} catch (OgnlException e) {
 			// e.printStackTrace();
 			throw new BindingException(e.getMessage(), e);
 		}
 		return parsedExpression;
 	}
 	
 	
 	@Override
 	public String getLabel() {
 		if(super.getLabel() == null)
 			return createLabel();
 		return super.getLabel();
 	}
 	/***
 	 * 
 	 * @return
 	 */
 	private String createLabel() {
 		
 		String label ="";
 		StringTokenizer tokenizer = new StringTokenizer(_expression, ".");
 		while(tokenizer.hasMoreTokens()) {
 			String token = tokenizer.nextToken();
 			label += token.substring(0,1).toUpperCase() + token.substring(1, token.length()).toLowerCase();
 		}
 		
 		return label;
 	}
 
 
 	/***
 	 * @return
 	 */
 	public String getOgnlContextName() {
 
 		Pattern pattern = Pattern.compile( "#(.*?)//..*" );
 		Matcher matcher = pattern.matcher( getExpression() );
 		if(matcher.matches())
 			return matcher.group( 1 );
 		return null;
 	}
 	
 }