/**

  * 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;

         }

 }