/*
    * 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.view.facelets.tag.composite;
  
  import java.beans.IntrospectionException;
  import java.beans.PropertyDescriptor;
  import java.io.IOException;
  import java.util.List;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.faces.application.ProjectStage;
  import javax.faces.component.UIComponent;
  import javax.faces.context.FacesContext;
  import javax.faces.view.facelets.FaceletContext;
  import javax.faces.view.facelets.TagAttribute;
  import javax.faces.view.facelets.TagConfig;
  import javax.faces.view.facelets.TagException;
  import javax.faces.view.facelets.TagHandler;
  
  import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFFaceletAttribute;
  import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFFaceletTag;
  import org.apache.myfaces.shared.util.ClassUtils;
  import org.apache.myfaces.view.facelets.FaceletCompositionContext;
  
  /**
   * @author Leonardo Uribe (latest modification by $Author$)
   * @version $Revision$ $Date$
   */
  @JSFFaceletTag(name="composite:attribute")
  public class AttributeHandler extends TagHandler implements InterfaceDescriptorCreator
  {
      
      private static final Logger log = Logger.getLogger(AttributeHandler.class.getName());
      
      /**
       * String array defining all standard attributes of this tag.
       * ATTENTION: this array MUST be sorted alphabetically in order to use binary search!!
       */
      private static final String[] STANDARD_ATTRIBUTES_SORTED = new String[]
      {
          "default",
          "displayName",
          "expert",
          "hidden",
          "method-signature",
          "name",
          "preferred",
          "required",
          "shortDescription",
          "targetAttributeName",
          "targets",
          "type"
      };
  
      @JSFFaceletAttribute(name="name",
              className="javax.el.ValueExpression",
              deferredValueType="java.lang.String",
              required=true)
      private final TagAttribute _name;
      
      @JSFFaceletAttribute(name="targets",
              className="javax.el.ValueExpression",
              deferredValueType="java.lang.String")
      private final TagAttribute _targets;
      
      /**
       * If this property is set and the attribute does not have any
       * value (null), the value set on this property is returned as default
       * instead null.
       */
      @JSFFaceletAttribute(name="default",
              className="javax.el.ValueExpression",
              deferredValueType="java.lang.String")
      private final TagAttribute _default;
      
      /**
       * Only available if ProjectStage is Development.
       */
      @JSFFaceletAttribute(name="displayName",
              className="javax.el.ValueExpression",
              deferredValueType="java.lang.String")
      private final TagAttribute _displayName;
 
     /**
      * Indicate if the attribute is required or not
      * <p>
      * Myfaces specific feature: this attribute is checked only if project stage is
      * not ProjectStage.Production when a composite component is created.</p>
      */
     @JSFFaceletAttribute(name="required",
             className="javax.el.ValueExpression",
             deferredValueType="boolean")
     private final TagAttribute _required;
 
     /**
      * Only available if ProjectStage is Development.
      */
     @JSFFaceletAttribute(name="preferred",
             className="javax.el.ValueExpression",
             deferredValueType="boolean")
     private final TagAttribute _preferred;
 
     /**
      * Only available if ProjectStage is Development.
      */
     @JSFFaceletAttribute(name="expert",
             className="javax.el.ValueExpression",
             deferredValueType="boolean")
     private final TagAttribute _expert;
 
     /**
      * Only available if ProjectStage is Development.
      */
     @JSFFaceletAttribute(name="shortDescription",
             className="javax.el.ValueExpression",
             deferredValueType="java.lang.String")
     private final TagAttribute _shortDescription;
 
     @JSFFaceletAttribute(name="method-signature",
             className="javax.el.ValueExpression",
             deferredValueType="java.lang.String")
     private final TagAttribute _methodSignature;
 
     @JSFFaceletAttribute(name="type",
             className="javax.el.ValueExpression",
             deferredValueType="java.lang.String")
     private final TagAttribute _type;
     
     /**
      * The "hidden" flag is used to identify features that are intended only 
      * for tool use, and which should not be exposed to humans.
      * Only available if ProjectStage is Development.
      */
     @JSFFaceletAttribute(name="hidden",
             className="javax.el.ValueExpression",
             deferredValueType="boolean")
     protected final TagAttribute _hidden;
     
     @JSFFaceletAttribute(name="targetAttributeName",
             className="javax.el.ValueExpression",
             deferredValueType="java.lang.String")
     private final TagAttribute _targetAttributeName;
     
     /**
      * Check if the PropertyDescriptor instance created by this handler
      * can be cacheable or not. 
      */
     private boolean _cacheable;
     
     /**
      * Cached instance used by this component. Note here we have a 
      * "racy single-check". If this field is used, it is supposed 
      * the object cached by this handler is immutable, and this is
      * granted if all properties not saved as ValueExpression are
      * "literal". 
      */
     private PropertyDescriptor _propertyDescriptor; 
     
     public AttributeHandler(TagConfig config)
     {
         super(config);
         _name = getRequiredAttribute("name");
         _targets = getAttribute("targets");
         _default = getAttribute("default");
         _displayName = getAttribute("displayName");
         _required = getAttribute("required");
         _preferred = getAttribute("preferred");
         _expert = getAttribute("expert");
         _shortDescription = getAttribute("shortDescription");
         _methodSignature = getAttribute("method-signature");
         _type = getAttribute("type");
         _hidden = getAttribute("hidden");
         _targetAttributeName = getAttribute("targetAttributeName");
         
         // We can reuse the same PropertyDescriptor only if the properties
         // that requires to be evaluated when apply (build view time)
         // occur are literal or null. Otherwise we need to create it.
         // Note that only if ProjectStage is Development, The "displayName",
         // "shortDescription", "expert", "hidden", and "preferred" attributes are exposed
         final boolean development = FacesContext.getCurrentInstance()
                 .isProjectStage(ProjectStage.Development);
         
         if (_name.isLiteral() 
                 && (!development || _areDevelopmentAttributesLiteral()))
         {
             // Unfortunately its not possible to create the required 
             // PropertyDescriptor instance here, because there is no way 
             // to get a FaceletContext to create ValueExpressions. It is
             // possible to create it if we not have set all this properties:
             // targets, default, required, methodSignature, type and possible
             // unspecified attributes. This prevents the racy single-check.
             _cacheable = true;
             if ( _targets == null && _default == null && _required == null &&
                  _methodSignature == null && _type == null && _targetAttributeName == null &&
                  !CompositeTagAttributeUtils.containsUnspecifiedAttributes(tag, 
                          STANDARD_ATTRIBUTES_SORTED))
             {
                 _propertyDescriptor = _createPropertyDescriptor(development);
             }
         }
         else
         {
             _cacheable = false;
         }
     }
     
     /**
      * True if the "displayName", "shortDescription", "expert", "hidden", and
      * "preferred" attributes are either null or literal.
      * @return
      */
     private boolean _areDevelopmentAttributesLiteral()
     {
         return CompositeTagAttributeUtils.areAttributesLiteral(
                 _displayName, _shortDescription, _expert, _hidden, _preferred);
     }
     
     public void apply(FaceletContext ctx, UIComponent parent)
             throws IOException
     {
         UIComponent compositeBaseParent
                 = FaceletCompositionContext.getCurrentInstance(ctx).getCompositeComponentFromStack();
 
         CompositeComponentBeanInfo beanInfo = 
             (CompositeComponentBeanInfo) compositeBaseParent.getAttributes()
             .get(UIComponent.BEANINFO_KEY);
         
         if (beanInfo == null)
         {
             if (log.isLoggable(Level.SEVERE))
             {
                 log.severe("Cannot find composite bean descriptor UIComponent.BEANINFO_KEY ");
             }
             return;
         }
         
         List<PropertyDescriptor> attributeList = beanInfo.getPropertyDescriptorsList();
         
         if (isCacheable())
         {
             if (_propertyDescriptor == null)
             {
                 _propertyDescriptor = _createPropertyDescriptor(ctx);
             }
             attributeList.add(_propertyDescriptor);
         }
         else
         {
             PropertyDescriptor attribute = _createPropertyDescriptor(ctx);
             attributeList.add(attribute);
         }
         
         // Any "next" handler is going to be used to process nested attributes, which we don't want
         // to do since they can only possibly refer to bean properties.
         
         //nextHandler.apply(ctx, parent);
     }
     
     /**
      * This method could be called only if it is not necessary to set the following properties:
      * targets, default, required, methodSignature and type
      * 
      * @param development true if the current ProjectStage is Development
      * @return
      */
     private PropertyDescriptor _createPropertyDescriptor(boolean development)
     {
         try
         {
             CompositeComponentPropertyDescriptor attributeDescriptor = 
                 new CompositeComponentPropertyDescriptor(_name.getValue());
             
             // If ProjectStage is Development, The "displayName", "shortDescription",
             // "expert", "hidden", and "preferred" attributes are exposed
             if (development)
             {
                 CompositeTagAttributeUtils.addDevelopmentAttributesLiteral(attributeDescriptor,
                         _displayName, _shortDescription, _expert, _hidden, _preferred);
             }
             
             // note that no unspecified attributes are handled here, because the current
             // tag does not contain any, otherwise this code would not have been called.
             
             return attributeDescriptor;
         }
         catch (IntrospectionException e)
         {
             if (log.isLoggable(Level.SEVERE))
             {
                 log.log(Level.SEVERE, "Cannot create PropertyDescriptor for attribute ",e);
             }
             throw new TagException(tag,e);
         }
     }
     
     private PropertyDescriptor _createPropertyDescriptor(FaceletContext ctx)
         throws TagException, IOException
     {
         try
         {
             CompositeComponentPropertyDescriptor attributeDescriptor = 
                 new CompositeComponentPropertyDescriptor(_name.getValue(ctx));
             
             // The javadoc of ViewDeclarationLanguage.retargetMethodExpressions says that
             // 'type', 'method-signature', 'targets' should return ValueExpressions.
             if (_targets != null)
             {
                 attributeDescriptor.setValue("targets", _targets.getValueExpression(ctx, String.class));
             }
             if (_default != null)
             {
                 if (_type != null)
                 {
                     Class clazz = String.class;
                     
                     String type = _type.getValue(ctx);
                     if (type != null && !type.trim().isEmpty())
                     {
                         try
                         {
                             clazz = ClassUtils.javaDefaultTypeToClass(type);
                         }
                         catch (ClassNotFoundException e)
                         {
                             log.log(Level.WARNING,
                                     "composite:attribute 'type' with value'" + type + "' not resolveable. "
                                     + "Fallback to string.",
                                     e);
                         }
                     }
                     
                     if (_default.isLiteral())
                     {
                         //If it is literal, calculate it and store it on a ValueExpression
                         attributeDescriptor.setValue("default", _default.getObject(ctx, clazz));
                     }
                     else
                     {
                         attributeDescriptor.setValue("default", _default.getValueExpression(ctx, clazz));
                     }
                 }
                 else
                 {
                     attributeDescriptor.setValue("default", _default.getValueExpression(ctx, String.class));
                 }
             }
             if (_required != null)
             {
                 attributeDescriptor.setValue("required", _required.getValueExpression(ctx, Boolean.class));
             }
             if (_methodSignature != null)
             {
                 attributeDescriptor.setValue("method-signature",
                                              _methodSignature.getValueExpression(ctx, String.class));
             }
             if (_type != null)
             {
                 attributeDescriptor.setValue("type", _type.getValueExpression(ctx, String.class));
             }
             if (_targetAttributeName != null)
             {
                 attributeDescriptor.setValue("targetAttributeName",
                                              _targetAttributeName.getValueExpression(ctx, String.class));
             }
             
             // If ProjectStage is Development, The "displayName", "shortDescription",
             // "expert", "hidden", and "preferred" attributes are exposed
             if (ctx.getFacesContext().isProjectStage(ProjectStage.Development))
             {
                 CompositeTagAttributeUtils.addDevelopmentAttributes(attributeDescriptor, ctx, 
                         _displayName, _shortDescription, _expert, _hidden, _preferred);
             }
             
             // Any additional attributes are exposed as attributes accessible
             // from the getValue() and attributeNames() methods on FeatureDescriptor
             CompositeTagAttributeUtils.addUnspecifiedAttributes(attributeDescriptor, tag, 
                     STANDARD_ATTRIBUTES_SORTED, ctx);
             
             return attributeDescriptor;
         }
         catch (IntrospectionException e)
         {
             if (log.isLoggable(Level.SEVERE))
             {
                 log.log(Level.SEVERE, "Cannot create PropertyDescriptor for attribute ",e);
             }
             throw new TagException(tag,e);
         }
     }
 
     public boolean isCacheable()
     {
         return _cacheable;
     }
     
     public void setCacheable(boolean cacheable)
     {
         _cacheable = cacheable;
     }
 }