/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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 org.apache.myfaces.orchestra.dynaForm.jsf.component;
  
  import org.apache.myfaces.orchestra.dynaForm.metadata.MetaFieldWritable;
  
  import javax.faces.component.UIComponent;
  import javax.faces.component.UIComponentBase;
  import javax.faces.context.FacesContext;
  import javax.faces.el.ValueBinding;
  
  /**
   * Overrule the way DynaForm presents a specific persistent attribute.
   * <p>
   * The DynaForm uses a pluggable Extractor to analyse a particular class and determine what
   * persistent properties it has, and how to render them. By default the dynaform will
   * create a JSF component for each one of the detected persistent properties, using the
   * detected metadata. 
   * <p>
   * Any number of instances of this component can be added as children to a DynaForm component
   * to override the settings auto-detected by the Extractor. Each instance overrides the properties
   * of a single persistent field. The attribute "for" on this component should specify the name
   * of the property to be overridden on the persistent object associated with the DynaForm.
   * <p>
   * This component can also have a single child component, in which case that is used as the
   * component for rendering this dynamic field.
   */
  public class DynaConfig extends UIComponentBase
  {
      public static final String COMPONENT_TYPE = "org.apache.myfaces.orchestra.dynaForm.DynaConfig";
      public static final String COMPONENT_FAMILY = "org.apache.myfaces.orchestra.dynaForm.DynaForm";
  
      private String forProperty;
      private Integer displaySize;
      private Boolean displayOnly;
      private Boolean readOnly;
      private Boolean disabled;
      private Object componentHandler;
  
      @Override
      public String getFamily()
      {
          return COMPONENT_FAMILY;
      }
  
      /**
       * @see #setDisplaySize(Integer)
       */
      public Integer getDisplaySize()
      {
          if (displaySize != null)
          {
              return displaySize;
          }
          ValueBinding vb = getValueBinding("displaySize");
          return vb != null ? (Integer) vb.getValue(getFacesContext()) : null;
      }
  
      /**
       * a hint for the size the ui should use when rendering the field
       */
      public void setDisplaySize(Integer displaySize)
      {
          this.displaySize = displaySize;
      }
  
      /**
       * @see #setDisplayOnly(Boolean)
       */
      public Boolean getDisplayOnly()
      {
          if (displayOnly != null)
          {
              return displayOnly;
          }
          ValueBinding vb = getValueBinding("displayOnly");
          return vb != null ? (Boolean) vb.getValue(getFacesContext()) : null;
      }
  
      /**
       * set the field to display only
       */
      public void setDisplayOnly(Boolean displayOnly)
     {
         this.displayOnly = displayOnly;
     }
 
     /**
      * @see #setReadOnly(Boolean)
      */
     public Boolean getReadOnly()
     {
         if (readOnly != null)
         {
             return readOnly;
         }
         ValueBinding vb = getValueBinding("readOnly");
         return vb != null ? (Boolean) vb.getValue(getFacesContext()) : null;
     }
 
     /**
      * configure this field as readOnly - noneditable input field
      */
     public void setReadOnly(Boolean readOnly)
     {
         this.readOnly = readOnly;
     }
 
     /**
      * @see #setDisabled(Boolean)
      */
     public Boolean getDisabled()
     {
         if (disabled != null)
         {
             return disabled;
         }
         ValueBinding vb = getValueBinding("disabled");
         return vb != null ? (Boolean) vb.getValue(getFacesContext()) : null;
     }
 
     /**
      * configure this field as disabled - like readOnly but grayed too
      */
     public void setDisabled(Boolean disabled)
     {
         this.disabled = disabled;
     }
 
     /**
      * Specifies the "controller bean" used to render this specific field.
      * <p>
      * This may return:
      * <ul>
      * <li>Null when there is no special component-handler..</li>
      * <li>A String which is the name of a managed-bean that implements DynaFormComponentHandler</li>
      * <li>A DynaFormComponentHandler object</li>
      * </ul>
      * <p>
      * The configureMetaData method of this class just copies this setting into a MetaField object
      * which is later used when building the components necessary to manage this field.
      * <p>  
      *  When the value is null, dynaform will create a default component to manage this field,
      *  depending on its type.
      *  <p>
      *  In the other cases, the DynaFormComponentHandler object is responsible for creating the
      *  necessary UI components to manage this field.
      *  <p>
      *  Normally, the JSP/Facelets framework will set this property to a String when the user
      *  provides a non-EL-expression, and will put a ValueBinding object into this component's
      *  value-binding map when the user provides an EL expression. As the value-binding could
      *  return a DynaFormComponentHandler or a String, this property type must be Object. 
      */
     public Object getComponentHandler()
     {
         if (componentHandler != null)
         {
             return componentHandler;
         }
         ValueBinding vb = getValueBinding("componentHandler");
         return vb != null ? vb.getValue(getFacesContext()) : null;
     }
 
     /**
      * Specifies the "controller bean" used to render this specific field.
      * <p>
      * This should be the name of a managed bean which implements DynaFormComponentHandler,
      * or an actual DynaFormComponentHandler instance.
      */
     public void setComponentHandler(Object value)
     {
         this.componentHandler = value;
     }
 
     /**
      * @see #setFor(String)
      */
     public String getFor()
     {
         if (forProperty != null)
         {
             return forProperty;
         }
         ValueBinding vb = getValueBinding("for");
         return vb != null ? (String) vb.getValue(getFacesContext()) : null;
     }
 
     /**
      * the name of the property this configuration is for
      */
     public void setFor(String forProperty)
     {
         this.forProperty = forProperty;
     }
 
     @Override
     public void restoreState(FacesContext context, Object stateArray)
     {
         Object[] states = (Object[]) stateArray;
         super.restoreState(context, states[0]);
         displaySize = (Integer) states[1];
         forProperty = (String) states[2];
         displayOnly = (Boolean) states[3];
         readOnly = (Boolean) states[4];
         disabled = (Boolean) states[5];
         componentHandler = (String) states[6];
     }
 
     @Override
     public Object saveState(FacesContext context)
     {
         return new Object[]
             {
                 super.saveState(context),
                 displaySize,
                 forProperty,
                 displayOnly,
                 readOnly,
                 disabled,
                 componentHandler
             };
     }
 
     /**
      * Update the specified field with the settings the user has configured from this JSF component.
      * <p>
      * This method is called <i>after</i> the user-specified extractor implementation is called. This
      * means that any settings the user has defined in the JSF can override those auto-detected via
      * the earlier extractor. However here we must only override earlier settings if they really
      * have been set in the JSF config. 
      */
     public void configureMetaData(MetaFieldWritable field)
     {
         Integer displaySize = getDisplaySize();
         if (displaySize != null)
         {
             field.setDisplaySize(displaySize.intValue());
         }
 
         Boolean displayOnly = getDisplayOnly();
         if (displayOnly != null)
         {
             field.setDisplayOnly(displayOnly.booleanValue());
         }
 
         // readOnly is a synonym for displayOnly
         Boolean readOnly = getReadOnly();
         if (readOnly != null)
         {
             field.setDisplayOnly(readOnly.booleanValue());
         }
 
         Boolean disabled = getDisabled();
         if (disabled != null)
         {
             // Note: the disabled property is deprecated
             field.setDisabled(disabled.booleanValue());
         }
 
         Object ch = getComponentHandler();
         if (ch != null)
         {
             field.setComponentHandler(ch);
         }
 
         if (getChildCount() > 0)
         {
             field.setWantedComponent((UIComponent) getChildren().get(0));
         }
     }
 }