// Copyright 2006 Daniel Gredler

 //

 // Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0

 //

 // Unless required by applicable law or agreed to in writing, software

 // distributed under the License is distributed on an "AS IS" BASIS,

 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 // See the License for the specific language governing permissions and

 // limitations under the License.

 package net.sf.beanform;

 import java.beans.BeanInfo;

 import java.beans.IntrospectionException;

 import java.beans.Introspector;

 import java.beans.PropertyDescriptor;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.Map.Entry;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 import net.sf.beanform.binding.ObjectBinding;

 import net.sf.beanform.prop.BeanProperty;

 import net.sf.beanform.prop.PseudoProperty;

 import net.sf.beanform.util.EnumPropertySelectionModel;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import org.apache.hivemind.ApplicationRuntimeException;

 import org.apache.hivemind.Location;

 import org.apache.tapestry.IActionListener;

 import org.apache.tapestry.IBinding;

 import org.apache.tapestry.IComponent;

 import org.apache.tapestry.IDirect;

 import org.apache.tapestry.IForm;

 import org.apache.tapestry.IMarkupWriter;

 import org.apache.tapestry.IRender;

 import org.apache.tapestry.IRequestCycle;

 import org.apache.tapestry.TapestryUtils;

 import org.apache.tapestry.coerce.ValueConverter;

 import org.apache.tapestry.coerce.ValueConverterImpl;

 import org.apache.tapestry.event.PageDetachListener;

 import org.apache.tapestry.event.PageEvent;

 import org.apache.tapestry.form.IPropertySelectionModel;

 /**

  * A form that provides edit capabilities for a Java Bean.

  *

  * @author Daniel Gredler

  */

 public abstract class BeanForm extends BeanFormComponent implements PageDetachListener, IDirect {

     public final static String BEAN_FORM_ATTRIBUTE = BeanForm.class.getName();

     private final static Log LOG = LogFactory.getLog( BeanForm.class );

     private final static Pattern PROPERTIES_PATTERN = Pattern.compile( "\\s*(#?[\\w\\.]+)\\s*(?:=\\s*([\\w]+)\\s*)?(?:\\{\\s*([^\\}]+)\\s*\\}\\s*)?,?" );

     private final static Pattern EXCLUDE_PATTERN = Pattern.compile( "\\s*([\\w\\.]+)\\s*,?" );

     private final static String INNER_FORM_COMPONENT_ID = "form";

     private final static String PSEUDO_PROPERTY_PREFIX = "#";

     private boolean customized;

     private List<BeanProperty> properties;

     private Map<BeanProperty, Map<String, IBinding>> fieldBindings;

     public abstract Object getBean();

     public abstract void setBean( Object bean );

     public abstract String getProperties();

     public abstract void setProperties( String properties );

     public abstract String getExclude();

     public abstract void setExclude( String exclude );

     public abstract boolean getCacheProperties();

     public abstract void setCacheProperties( boolean cacheProperties );

     public abstract IActionListener getSave();

     public abstract void setSave( IActionListener save );

     public abstract IActionListener getCancel();

     public abstract void setCancel( IActionListener cancel );

     public abstract IActionListener getRefresh();

     public abstract void setRefresh( IActionListener refresh );

     public abstract IActionListener getDelete();

     public abstract void setDelete( IActionListener delete );

     @Override

     public void addBody( IRender element ) {

         if( this.customized == false && element instanceof IComponent) {

             this.customized = this.isOrHasBeanFormComponent( (IComponent) element );

         }

         super.addBody( element );

     }

     @SuppressWarnings( "unchecked" )

     private boolean isOrHasBeanFormComponent( IComponent component ) {

         if( component instanceof BeanFormComponent ) return true;

         Map<String, IComponent> children = component.getComponents();

         for( IComponent child : children.values() ) {

             if( this.isOrHasBeanFormComponent( child ) ) return true;

         }

         return false;

     }

     public void pageDetached( PageEvent event ) {

         if( this.getCacheProperties() == false ) this.cleanup();

     }

     public boolean getIsInsideAForm() {

         return this.getPage().getRequestCycle().getAttribute( TapestryUtils.FORM_ATTRIBUTE ) != null;

     }

     public boolean getIsNotCustomized() {

         return ! this.customized;

     }

     public Object getBeanSafely() {

         Object bean = this.getBean();

         if( bean != null ) return bean;

         else throw new ApplicationRuntimeException( BeanFormMessages.nullBean() );

     }

     public List<BeanProperty> getBeanProperties() {

         this.init();

         return this.properties;

     }

     public Map<String, IBinding> getFieldBindingsFor( BeanProperty property ) {

         this.init();

         return this.fieldBindings.get( property );

     }

     @SuppressWarnings( "unchecked" )

     public Map<String, IBinding> extractBindingOverrides( String prefix ) {

         Map<String, IBinding> bindings = new HashMap<String, IBinding>();

         Map<String, IBinding> allBindings = this.getBindings();

         for( Entry<String, IBinding> entry : allBindings.entrySet() ) {

             String name = entry.getKey();

             if( name.startsWith( prefix ) ) {

                 String newName = name.substring( prefix.length() );

                 IBinding binding = entry.getValue();

                 bindings.put( newName, binding );

             }

         }

         return bindings;

     }

     /**

      * Obvious shortcut.

      *

      * @see BeanFormComponent#getBeanForm()

      */

     @Override

     protected BeanForm getBeanForm() {

         return this;

     }

     /**

      * This method exists only for the convenience of users who wish to reference the current

      * property from within OGNL binding overrides that are applied to all property input

      * fields. It could be done without this method, but the user would have to know the ID of

      * the contained {@link BeanFormRows} component.

      */

     public BeanProperty getProperty() {

         IRequestCycle cycle = this.getPage().getRequestCycle();

         BeanFormRows rows = (BeanFormRows) cycle.getAttribute( BeanFormRows.BEAN_FORM_ROWS_ATTRIBUTE );

         return rows.getProperty();

     }

     /**

      * All low level BeanForm components expect to be able to retrieve

      * their containing BeanForm during the render phase.

      *

      * @see BeanFormComponent#getBeanForm()

      */

     @Override

     protected void renderComponent( IMarkupWriter writer, IRequestCycle cycle ) {

         Object old = cycle.getAttribute( BEAN_FORM_ATTRIBUTE );

         cycle.setAttribute( BEAN_FORM_ATTRIBUTE, this );

         super.renderComponent( writer, cycle );

         cycle.setAttribute( BEAN_FORM_ATTRIBUTE, old );

     }

     /**

      * All low level BeanForm components expect to be able to retrieve

      * their containing BeanForm during the rewind phase.

      *

      * @see BeanFormComponent#getBeanForm()

      * @see IDirect#trigger(IRequestCycle)

      */

     public void trigger( IRequestCycle cycle ) {

         Object old = cycle.getAttribute( BEAN_FORM_ATTRIBUTE );

         cycle.setAttribute( BEAN_FORM_ATTRIBUTE, this );

         IForm form = (IForm) this.getComponent( INNER_FORM_COMPONENT_ID );

         cycle.rewindForm( form );

         cycle.setAttribute( BEAN_FORM_ATTRIBUTE, old );

     }

     /* -------------------------------------------------------------------------------------------------------- */

     /* ------------------------------- cached state initialization and cleanup -------------------------------- */

     /* -------------------------------------------------------------------------------------------------------- */

     protected synchronized void init() {

         this.initProperties();

         this.initFieldBindings();

     }

     protected synchronized void cleanup() {

         this.properties = null;

         this.fieldBindings = null;

     }

     private void initProperties() {

         if( this.properties != null ) return;

         this.properties = new ArrayList<BeanProperty>();

         Class clazz = this.getBeanSafely().getClass();

         String props = this.getProperties();

         String exclude = this.getExclude();

         List<String> exclusions = new ArrayList<String>();

         if( exclude != null ) {

             Matcher m = EXCLUDE_PATTERN.matcher( exclude );

             while( m.find() ) {

                 String name = m.group( 1 );

                 exclusions.add( name );

             }

             if( LOG.isDebugEnabled() ) {

                 LOG.debug( "Excluding properties: " + exclusions );

             }

         }

         if( props == null ) {

             // No properties were specified explicitly; use bean introspection.

             BeanInfo info = this.getBeanInfo();

             PropertyDescriptor[] descriptors = info.getPropertyDescriptors();

             for( PropertyDescriptor descriptor : descriptors ) {

                 String name = descriptor.getName();

                 BeanProperty property = new BeanProperty( clazz, name, null, null );

                 if( this.shouldIncludeProperty( property, exclusions ) ) {

                     this.properties.add( property );

                 }

             }

             if( LOG.isDebugEnabled() ) {

                 LOG.debug( "No properties specified; defaulting to: " + this.properties );

             }

         }

         else {

             // Included properties were specified explicitly.

             Matcher m = PROPERTIES_PATTERN.matcher( props );

             while( m.find() ) {

                 String name = m.group( 1 );

                 String input = m.group( 2 );

                 String validators = m.group( 3 );

                 if( validators != null ) validators = validators.trim();

                 BeanProperty property;

                 if( name.startsWith( PSEUDO_PROPERTY_PREFIX ) ) {

                     name = name.substring( PSEUDO_PROPERTY_PREFIX.length() );

                     property = new PseudoProperty( clazz, name, validators, input );

                     if( this.hasCustomField( property ) == false ) {

                         String fieldName = this.getCustomFieldName( property );

                         String blockName = this.getCustomFieldBlockName( property );

                         String msg = BeanFormMessages.pseudoPropMissingField( property, fieldName, blockName );

                         throw new ApplicationRuntimeException( msg );

                     }

                 }

                 else {

                     property = new BeanProperty( clazz, name, validators, input );

                     if( this.shouldIncludeProperty( property, exclusions ) == false ) {

                         String msg = BeanFormMessages.unmodifiableExplicitProperty( property );

                         throw new ApplicationRuntimeException( msg );

                     }

                 }

                 this.properties.add( property );

             }

             if( LOG.isDebugEnabled() ) {

                 LOG.debug( "Using specified properties: " + this.properties );

             }

         }

     }

     private BeanInfo getBeanInfo() {

         Object bean = this.getBeanSafely();

         BeanInfo info;

         try {

             info = Introspector.getBeanInfo( bean.getClass() );

         }

         catch( IntrospectionException e ) {

             throw new ApplicationRuntimeException( e );

         }

         return info;

     }

     private boolean shouldIncludeProperty( BeanProperty property, List<String> exclusions ) {

         return

             exclusions.contains( property.getName() ) == false &&     // Not excluded by the user.

             (

                 property.isEditableType() ||                          // It's an editable type.

                 property.isEnum() ||                                  // It's not an editable type, but we're going to add an implicit IPropertySelectionModel.

                 this.hasPropertySelectionModel( property, false ) ||  // It's not an editable type, but the user provided an IPropertySelectionModel.

                 this.hasCustomField( property )                       // It's not an editable type, but the user provided an input override.

             );

     }

     @SuppressWarnings( "unchecked" )

     private void initFieldBindings() {

         if( this.fieldBindings != null ) return;

         this.fieldBindings = new HashMap<BeanProperty, Map<String, IBinding>>( this.properties.size() );

         for( BeanProperty prop : this.properties ) {

             Map<String, IBinding> bindings = new HashMap<String, IBinding>();

             // Add user-defined binding overrides.

             String prefix1 = prop.getName() + BINDING_OVERRIDE_SEPARATOR;

             String prefix2 = BINDING_OVERRIDE_SEPARATOR;

             bindings.putAll( this.extractBindingOverrides( prefix1 ) );

             bindings.putAll( this.extractBindingOverrides( prefix2 ) );

             // Add implicit enum IPropertySelectionModel bindings if the user didn't provide them explicitly.

             if( prop.isEnum() ) {

                 if( bindings.containsKey( MODEL ) == false ) {

                     String desc = "enum model for " + prop.getOwnerClass().getName() + "#" + prop.getName();

                     ValueConverter converter = new ValueConverterImpl();

                     Location location = null;

                     IPropertySelectionModel psm = new EnumPropertySelectionModel( prop.getType(), prop.isNullable(), this.getPage().getMessages() );

                     IBinding binding = new ObjectBinding( desc, converter, location, psm );

                     bindings.put( MODEL, binding );

                 }

             }

             this.fieldBindings.put( prop, bindings );

         }

     }

 }