/*
    * 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;
  
  import java.util.Arrays;
  
  import javax.el.ELException;
  import javax.el.ExpressionFactory;
  import javax.el.MethodExpression;
  import javax.el.ValueExpression;
  import javax.faces.component.UIComponent;
  import javax.faces.view.Location;
  import javax.faces.view.facelets.FaceletContext;
  import javax.faces.view.facelets.TagAttribute;
  import javax.faces.view.facelets.TagAttributeException;
  
  import org.apache.myfaces.util.ExternalSpecifications;
  import org.apache.myfaces.view.facelets.AbstractFaceletContext;
  import org.apache.myfaces.view.facelets.el.CompositeComponentELUtils;
  import org.apache.myfaces.view.facelets.el.ContextAwareTagMethodExpression;
  import org.apache.myfaces.view.facelets.el.ContextAwareTagValueExpression;
  import org.apache.myfaces.view.facelets.el.ContextAwareTagValueExpressionUEL;
  import org.apache.myfaces.view.facelets.el.ELText;
  import org.apache.myfaces.view.facelets.el.LocationMethodExpression;
  import org.apache.myfaces.view.facelets.el.LocationValueExpression;
  import org.apache.myfaces.view.facelets.el.LocationValueExpressionUEL;
  import org.apache.myfaces.view.facelets.el.ResourceELUtils;
  import org.apache.myfaces.view.facelets.el.ResourceLocationValueExpression;
  import org.apache.myfaces.view.facelets.el.ResourceLocationValueExpressionUEL;
  import org.apache.myfaces.view.facelets.el.TagMethodExpression;
  import org.apache.myfaces.view.facelets.el.TagValueExpression;
  import org.apache.myfaces.view.facelets.el.TagValueExpressionUEL;
  import org.apache.myfaces.view.facelets.el.ValueExpressionMethodExpression;
  
  /**
   * Representation of a Tag's attribute in a Facelet File
   * 
   * @author Jacob Hookom
   * @version $Id$
   */
  public final class TagAttributeImpl extends TagAttribute
  {
  
      private final static int EL_LITERAL = 1;
      
      private final static int EL_CC = 2;
      
      private final static int EL_CC_ATTR_ME = 4;
      
      private final static int EL_RESOURCE = 8;
      
      private final int capabilities;
  
      private final String localName;
  
      private final Location location;
  
      private final String namespace;
  
      private final String qName;
  
      private final String value;
  
      private String string;
  
      /**
       * This variable is used to cache created expressions using
       * getValueExpression or getMethodExpression methods. It uses
       * a racy single check strategy, because if the expression can be
       * cached the same instance will be built.
       */
      private volatile Object[] cachedExpression;
  
      public TagAttributeImpl(Location location, String ns, String localName, String qName, String value)
      {
          boolean literal;
          boolean compositeComponentExpression;
          boolean compositeComponentAttrMethodExpression;
          boolean resourceExpression;
          this.location = location;
          this.namespace = ns;
          // "xmlns" attribute name can be swallowed by SAX compiler, so we should check if
          // localName is null or empty and if that so, assign it from the qName 
         // (if localName is empty it is not prefixed, so it is save to set it directly). 
         this.localName = (localName == null) ? qName : ((localName.length() > 0) ? localName : qName);
         this.qName = qName;
         this.value = value;
 
         try
         {
             literal = ELText.isLiteral(this.value);
         }
         catch (ELException e)
         {
             throw new TagAttributeException(this, e);
         }
         
         compositeComponentExpression = !literal ? 
                 CompositeComponentELUtils.isCompositeComponentExpression(this.value) : 
                     false;
         compositeComponentAttrMethodExpression = compositeComponentExpression ? 
                 CompositeComponentELUtils.isCompositeComponentAttrsMethodExpression(this.value) : 
                     false;
         resourceExpression = !literal ? ResourceELUtils.isResourceExpression(this.value) : false;
 
         this.capabilities = (literal ? EL_LITERAL : 0) | (compositeComponentExpression ? EL_CC : 0) | 
             (compositeComponentAttrMethodExpression ? EL_CC_ATTR_ME : 0) | ( resourceExpression ? EL_RESOURCE : 0); 
     }
 
     /**
      * If literal, return {@link Boolean#getBoolean(java.lang.String) Boolean.getBoolean(java.lang.String)} passing our
      * value, otherwise call {@link #getObject(FaceletContext, Class) getObject(FaceletContext, Class)}.
      * 
      * @see Boolean#getBoolean(java.lang.String)
      * @see #getObject(FaceletContext, Class)
      * @param ctx
      *            FaceletContext to use
      * @return boolean value
      */
     public boolean getBoolean(FaceletContext ctx)
     {
         if ((this.capabilities & EL_LITERAL) != 0)
         {
             return Boolean.valueOf(this.value).booleanValue();
         }
         else
         {
             return ((Boolean) this.getObject(ctx, Boolean.class)).booleanValue();
         }
     }
 
     /**
      * If literal, call {@link Integer#parseInt(java.lang.String) Integer.parseInt(String)}, otherwise call
      * {@link #getObject(FaceletContext, Class) getObject(FaceletContext, Class)}.
      * 
      * @see Integer#parseInt(java.lang.String)
      * @see #getObject(FaceletContext, Class)
      * @param ctx
      *            FaceletContext to use
      * @return int value
      */
     public int getInt(FaceletContext ctx)
     {
         if ((this.capabilities & EL_LITERAL) != 0)
         {
             return Integer.parseInt(this.value);
         }
         else
         {
             return ((Number) this.getObject(ctx, Integer.class)).intValue();
         }
     }
 
     /**
      * Local name of this attribute
      * 
      * @return local name of this attribute
      */
     public String getLocalName()
     {
         return this.localName;
     }
 
     /**
      * The location of this attribute in the FaceletContext
      * 
      * @return the TagAttribute's location
      */
     public Location getLocation()
     {
         return this.location;
     }
 
     /**
      * Create a MethodExpression, using this attribute's value as the expression String.
      * 
      * @see ExpressionFactory#createMethodExpression(javax.el.ELContext, java.lang.String, java.lang.Class,
      *      java.lang.Class[])
      * @see MethodExpression
      * @param ctx
      *            FaceletContext to use
      * @param type
      *            expected return type
      * @param paramTypes
      *            parameter type
      * @return a MethodExpression instance
      */
     public MethodExpression getMethodExpression(FaceletContext ctx, Class type, Class[] paramTypes)
     {
         AbstractFaceletContext actx = (AbstractFaceletContext) ctx;
         
         //volatile reads are atomic, so take the tuple to later comparison.
         Object[] localCachedExpression = cachedExpression; 
         
         if (actx.isAllowCacheELExpressions() && localCachedExpression != null &&
             (localCachedExpression.length % 3 == 0))
         {
             //If the expected type and paramTypes are the same return the cached one
             for (int i = 0; i < (localCachedExpression.length/3); i++)
             {
                 if ( ((type == null && localCachedExpression[(i*3)] == null ) ||
                      (type != null && type.equals(localCachedExpression[(i*3)])) ) &&
                      (Arrays.equals(paramTypes, (Class[]) localCachedExpression[(i*3)+1])) )
                 {
                     if ((this.capabilities & EL_CC) != 0 &&
                         localCachedExpression[(i*3)+2] instanceof LocationMethodExpression)
                     {
                         UIComponent cc = actx.getFaceletCompositionContext().getCompositeComponentFromStack();
                         if (cc != null)
                         {
                             Location location = (Location) cc.getAttributes().get(
                                     CompositeComponentELUtils.LOCATION_KEY);
                             if (location != null)
                             {
                                 return ((LocationMethodExpression)localCachedExpression[(i*3)+2]).apply(
                                         actx.getFaceletCompositionContext().getCompositeComponentLevel(), location);
                             }
                         }
                         return ((LocationMethodExpression)localCachedExpression[(i*3)+2]).apply(
                                 actx.getFaceletCompositionContext().getCompositeComponentLevel());
                     }
                     return (MethodExpression) localCachedExpression[(i*3)+2];
                 }
             }
         }
         
         actx.beforeConstructELExpression();
         try
         {
             MethodExpression methodExpression = null;
             
             // From this point we can suppose this attribute contains a ELExpression
             // Now we have to check if the expression points to a composite component attribute map
             // and if so deal with it as an indirection.
             // NOTE that we have to check if the expression refers to cc.attrs for a MethodExpression
             // (#{cc.attrs.myMethod}) or only for MethodExpression parameters (#{bean.method(cc.attrs.value)}).
             if ((this.capabilities & EL_CC_ATTR_ME) != 0)
             {
                 // The MethodExpression is on parent composite component attribute map.
                 // create a pointer that are referred to the real one that is created in other side
                 // (see VDL.retargetMethodExpressions for details)
                 
                 // check for params in the the MethodExpression
                 if (ExternalSpecifications.isUnifiedELAvailable() && this.value.contains("("))
                 {
                     // if we don't throw this exception here, another ELException will be
                     // thrown later, because #{cc.attrs.method(param)} will not work as a
                     // ValueExpression pointing to a MethodExpression
                     throw new ELException("Cannot add parameters to a MethodExpression "
                             + "pointing to cc.attrs");
                 }
                 
                 ValueExpression valueExpr = this.getValueExpression(ctx, Object.class);
                 methodExpression = new ValueExpressionMethodExpression(valueExpr);
                 
                 if (actx.getFaceletCompositionContext().isWrapTagExceptionsAsContextAware())
                 {
                     methodExpression = new ContextAwareTagMethodExpression(this, methodExpression);
                 }
                 else
                 {
                     methodExpression = new TagMethodExpression(this, methodExpression);
                 }
             }
             else
             {
                 ExpressionFactory f = ctx.getExpressionFactory();
                 methodExpression = f.createMethodExpression(ctx, this.value, type, paramTypes);
 
                 if (actx.getFaceletCompositionContext().isWrapTagExceptionsAsContextAware())
                 {
                     methodExpression = new ContextAwareTagMethodExpression(this, methodExpression);
                 }
                 else
                 {
                     methodExpression = new TagMethodExpression(this, methodExpression);
                 }
 
                 // if the MethodExpression contains a reference to the current composite
                 // component, the Location also has to be stored in the MethodExpression 
                 // to be able to resolve the right composite component (the one that was
                 // created from the file the Location is pointing to) later.
                 // (see MYFACES-2561 for details)
                 if ((this.capabilities & EL_CC) != 0)
                 {
                     Location currentLocation = getLocation();
                     Location ccLocation = (Location) actx.getFaceletCompositionContext().
                             getCompositeComponentFromStack().getAttributes().get(
                                     CompositeComponentELUtils.LOCATION_KEY);
                     if (ccLocation != null && !ccLocation.getPath().equals(currentLocation.getPath()))
                     {
                         // #{cc} from a template called from inside a composite component, disable caching on 
                         // this expression. The reason is we need to change the Location object used as
                         // reference as the one in the stack, and that depends on the template hierarchy.
                         currentLocation = ccLocation;
                     }
                     methodExpression = new LocationMethodExpression(currentLocation, methodExpression, 
                             actx.getFaceletCompositionContext().getCompositeComponentLevel());
                 }
             }
             
                 
             if (actx.isAllowCacheELExpressions() && !actx.isAnyFaceletsVariableResolved())
             {
                 if (localCachedExpression != null && (localCachedExpression.length % 3 == 0))
                 {
                     // If you use a racy single check, assign
                     // the volatile variable at the end.
                     Object[] array = new Object[localCachedExpression.length+3];
                     array[0] = type;
                     array[1] = paramTypes;
                     array[2] = methodExpression;
                     for (int i = 0; i < localCachedExpression.length; i++)
                     {
                         array[i+3] = localCachedExpression[i];
                     }
                     cachedExpression = array;
                 }
                 else
                 {
                     cachedExpression = new Object[]{type, paramTypes, methodExpression};
                 }
             }
 
             return methodExpression; 
         }
         catch (Exception e)
         {
             throw new TagAttributeException(this, e);
         }
         finally
         {
             actx.afterConstructELExpression();
         }
     }
     
     /**
      * The resolved Namespace for this attribute
      * 
      * @return resolved Namespace
      */
     public String getNamespace()
     {
         return this.namespace;
     }
 
     /**
      * Delegates to getObject with Object.class as a param
      * 
      * @see #getObject(FaceletContext, Class)
      * @param ctx
      *            FaceletContext to use
      * @return Object representation of this attribute's value
      */
     public Object getObject(FaceletContext ctx)
     {
         return this.getObject(ctx, Object.class);
     }
 
     /**
      * The qualified name for this attribute
      * 
      * @return the qualified name for this attribute
      */
     public String getQName()
     {
         return this.qName;
     }
 
     /**
      * Return the literal value of this attribute
      * 
      * @return literal value
      */
     public String getValue()
     {
         return this.value;
     }
 
     /**
      * If literal, then return our value, otherwise delegate to getObject, passing String.class.
      * 
      * @see #getObject(FaceletContext, Class)
      * @param ctx
      *            FaceletContext to use
      * @return String value of this attribute
      */
     public String getValue(FaceletContext ctx)
     {
         if ((this.capabilities & EL_LITERAL) != 0)
         {
             return this.value;
         }
         else
         {
             return (String) this.getObject(ctx, String.class);
         }
     }
 
     /**
      * If literal, simply coerce our String literal value using an ExpressionFactory, otherwise create a ValueExpression
      * and evaluate it.
      * 
      * @see ExpressionFactory#coerceToType(java.lang.Object, java.lang.Class)
      * @see ExpressionFactory#createValueExpression(javax.el.ELContext, java.lang.String, java.lang.Class)
      * @see ValueExpression
      * @param ctx
      *            FaceletContext to use
      * @param type
      *            expected return type
      * @return Object value of this attribute
      */
     public Object getObject(FaceletContext ctx, Class type)
     {
         if ((this.capabilities & EL_LITERAL) != 0)
         {
             if (String.class.equals(type))
             {
                 return this.value;
             }
             else
             {
                 try
                 {
                     return ctx.getExpressionFactory().coerceToType(this.value, type);
                 }
                 catch (Exception e)
                 {
                     throw new TagAttributeException(this, e);
                 }
             }
         }
         else
         {
             ValueExpression ve = this.getValueExpression(ctx, type);
             try
             {
                 return ve.getValue(ctx);
             }
             catch (Exception e)
             {
                 throw new TagAttributeException(this, e);
             }
         }
     }
 
     /**
      * Create a ValueExpression, using this attribute's literal value and the passed expected type.
      * 
      * @see ExpressionFactory#createValueExpression(javax.el.ELContext, java.lang.String, java.lang.Class)
      * @see ValueExpression
      * @param ctx
      *            FaceletContext to use
      * @param type
      *            expected return type
      * @return ValueExpression instance
      */
     public ValueExpression getValueExpression(FaceletContext ctx, Class type)
     {
         AbstractFaceletContext actx = (AbstractFaceletContext) ctx;
         
         //volatile reads are atomic, so take the tuple to later comparison.
         Object[] localCachedExpression = cachedExpression;
         if (actx.isAllowCacheELExpressions() && localCachedExpression != null && localCachedExpression.length == 2)
         {
             //If the expected type is the same return the cached one
             if (localCachedExpression[0] == null && type == null)
             {
                 // If #{cc} recalculate the composite component level
                 if ((this.capabilities & EL_CC) != 0)
                 {
                     UIComponent cc = actx.getFaceletCompositionContext().getCompositeComponentFromStack();
                     if (cc != null)
                     {
                         Location location = (Location) cc.getAttributes().get(
                                 CompositeComponentELUtils.LOCATION_KEY);
                         if (location != null)
                         {
                             return ((LocationValueExpression)localCachedExpression[1]).apply(
                                     actx.getFaceletCompositionContext().getCompositeComponentLevel(), location);
                         }
                     }
                     return ((LocationValueExpression)localCachedExpression[1]).apply(
                             actx.getFaceletCompositionContext().getCompositeComponentLevel());
                 }
                 return (ValueExpression) localCachedExpression[1];
             }
             else if (localCachedExpression[0] != null && localCachedExpression[0].equals(type))
             {
                 // If #{cc} recalculate the composite component level
                 if ((this.capabilities & EL_CC) != 0)
                 {
                     UIComponent cc = actx.getFaceletCompositionContext().getCompositeComponentFromStack();
                     if (cc != null)
                     {
                         Location location = (Location) cc.getAttributes().get(
                                 CompositeComponentELUtils.LOCATION_KEY);
                         if (location != null)
                         {
                             return ((LocationValueExpression)localCachedExpression[1]).apply(
                                     actx.getFaceletCompositionContext().getCompositeComponentLevel(), location);
                         }
                     }
                     return ((LocationValueExpression)localCachedExpression[1]).apply(
                             actx.getFaceletCompositionContext().getCompositeComponentLevel());
                 }
                 return (ValueExpression) localCachedExpression[1];
             }
         }
 
         actx.beforeConstructELExpression();
         try
         {
             ExpressionFactory f = ctx.getExpressionFactory();
             ValueExpression valueExpression = f.createValueExpression(ctx, this.value, type);
             
             if (ExternalSpecifications.isUnifiedELAvailable())
             {
                 if (actx.getFaceletCompositionContext().isWrapTagExceptionsAsContextAware())
                 {
                     valueExpression = new ContextAwareTagValueExpressionUEL(this, valueExpression);
                 }
                 else
                 {
                     valueExpression = new TagValueExpressionUEL(this, valueExpression);
                 }
             }
             else
             {
                 if (actx.getFaceletCompositionContext().isWrapTagExceptionsAsContextAware())
                 {
                     valueExpression = new ContextAwareTagValueExpression(this, valueExpression);
                 }
                 else
                 {
                     valueExpression = new TagValueExpression(this, valueExpression);
                 }
             }
 
             // if the ValueExpression contains a reference to the current composite
             // component, the Location also has to be stored in the ValueExpression 
             // to be able to resolve the right composite component (the one that was
             // created from the file the Location is pointing to) later.
             // (see MYFACES-2561 for details)
             if ((this.capabilities & EL_CC) != 0)
             {
                 // In MYFACES-4099 it was found that #{cc} could happen outside a composite component. In that
                 // case, getLocation() will point to the template. To solve the problem, it is better to get
                 // the location of the composite component from the stack directly, but only when the path
                 // is different.
                 Location currentLocation = getLocation();
                 Location ccLocation = (Location) actx.getFaceletCompositionContext().
                         getCompositeComponentFromStack().getAttributes().get(
                                 CompositeComponentELUtils.LOCATION_KEY);
                 if (ccLocation != null && !ccLocation.getPath().equals(currentLocation.getPath()))
                 {
                     // #{cc} from a template called from inside a composite component, disable caching on 
                     // this expression. The reason is we need to change the Location object used as
                     // reference as the one in the stack, and that depends on the template hierarchy.
                     //cacheable = false;
                     currentLocation = ccLocation;
                 }
                 if (ExternalSpecifications.isUnifiedELAvailable())
                 {
                     valueExpression = new LocationValueExpressionUEL(currentLocation, valueExpression, 
                             actx.getFaceletCompositionContext().getCompositeComponentLevel());
                 }
                 else
                 {
                     valueExpression = new LocationValueExpression(currentLocation, valueExpression, 
                             actx.getFaceletCompositionContext().getCompositeComponentLevel());
                 }
             }
             else if ((this.capabilities & EL_RESOURCE) != 0)
             {
                 if (ExternalSpecifications.isUnifiedELAvailable())
                 {
                     valueExpression = new ResourceLocationValueExpressionUEL(getLocation(), valueExpression);
                 }
                 else
                 {
                     valueExpression = new ResourceLocationValueExpression(getLocation(), valueExpression);
                 }
             }
             
             
             if (actx.isAllowCacheELExpressions() && !actx.isAnyFaceletsVariableResolved())
             {
                 cachedExpression = new Object[]{type, valueExpression};
             }
             return valueExpression;
         }
         catch (Exception e)
         {
             throw new TagAttributeException(this, e);
         }
         finally
         {
             actx.afterConstructELExpression();
         }
     }
 
     /**
      * If this TagAttribute is literal (not #{..} or ${..})
      * 
      * @return true if this attribute is literal
      */
     public boolean isLiteral()
     {
         return (this.capabilities & EL_LITERAL) != 0;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see java.lang.Object#toString()
      */
     public String toString()
     {
         if (this.string == null)
         {
             this.string = this.location + " " + this.qName + "=\"" + this.value + "\"";
         }
         return this.string;
     }
 
 }