/*
    * 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.el;
  
  import java.util.HashMap;
  import java.util.Map;
  
  import javax.el.ValueExpression;
  import javax.el.VariableMapper;
  
  import org.apache.myfaces.view.facelets.PageContext;
  import org.apache.myfaces.view.facelets.TemplateContext;
  
  /**
   * Default instance of a VariableMapper backed by a Map
   * 
   * @see javax.el.VariableMapper
   * @see javax.el.ValueExpression
   * @see java.util.Map
   * 
   * @author Jacob Hookom
   * @version $Id$
   */
  public final class DefaultVariableMapper extends VariableMapperBase
  {
      private Map<String, ValueExpression> _vars;
      
      private PageContext _pageContext;
      
      private TemplateContext _templateContext;
      
      private VariableMapper _delegate;
      
      public boolean _trackResolveVariables;
      
      public boolean _variableResolved;
  
      public DefaultVariableMapper()
      {
          super();
          _trackResolveVariables = false;
          _variableResolved = false;
      }
  
      public DefaultVariableMapper(VariableMapper delegate)
      {
          super();
          this._delegate = delegate;
      }
      
      /**
       * @see javax.el.VariableMapper#resolveVariable(java.lang.String)
       */
      public ValueExpression resolveVariable(String name)
      {
          ValueExpression returnValue = null;
          
          if (_vars != null)
          {
              returnValue = _vars.get(name);
          }
  
          //If the variable is not on the VariableMapper
          if (returnValue == null)
          {
              //Check on page and template context
              if (_pageContext != null && _pageContext.getAttributeCount() > 0)
              {
                  if (_pageContext.getAttributes().containsKey(name))
                  {
                      returnValue = _pageContext.getAttributes().get(name);
                      if (_trackResolveVariables)
                      {
                          if (returnValue instanceof CacheableValueExpression)
                          {
                              if (returnValue instanceof CacheableValueExpressionWrapper)
                              {
                                  returnValue = ((CacheableValueExpressionWrapper)returnValue).
                                      getWrapped();
                              }
                          }
                          else
                          {
                             _variableResolved = true;
                         }
                     }
                     return returnValue;
                 }
             }
             
             if (_templateContext != null)
             {
                 if (!_templateContext.isParameterEmpty() &&
                     _templateContext.containsParameter(name))
                 {
                     returnValue = _templateContext.getParameter(name);
                     if (_trackResolveVariables &&
                         !(returnValue instanceof CacheableValueExpression))
                     {
                         _variableResolved = true;
                     }
                     return returnValue;
                 }
                 else if (!_templateContext.isKnownParametersEmpty() &&
                     _templateContext.containsKnownParameter(name))
                 {
                     // This part is the most important in alwaysRecompile EL cache hack.
                     // The idea is maintain a list of the parameters used in a template,
                     // and if the name to be resolved match one of the list, even if the
                     // param was not set it is necessary to track it as variable resolved.
                     // This will force create a new EL expression each time the view is
                     // built, preserving ui:param and VariableMapper behavior, but allow
                     // cache all expressions that are not related.
                     if (_trackResolveVariables)
                     {
                         _variableResolved = true;
                     }
                 }
             }
             
             if (_delegate != null)
             {
                 returnValue = _delegate.resolveVariable(name);
             }
         }
         else if (_trackResolveVariables)
         {
             // Is this code in a block that wants to cache 
             // the resulting expression(s) and variable has been resolved?
             _variableResolved = true;
         }
         
         return returnValue;
     }
 
     /**
      * @see javax.el.VariableMapper#setVariable(java.lang.String, javax.el.ValueExpression)
      */
     public ValueExpression setVariable(String name, ValueExpression expression)
     {
         if (_vars == null)
         {
             _vars = new HashMap<String, ValueExpression>();
         }
         
         return _vars.put(name, expression);
     }
     
     /**
      * Set the current page context this variable mapper should resolve against.
      * 
      * @param pageContext
      */
     public void setPageContext(PageContext pageContext)
     {
         this._pageContext = pageContext;
     }
     
     /**
      * Set the current template context this variable mapper should resolve against.
      * 
      * @param templateContext
      */
     public void setTemplateContext(TemplateContext templateContext)
     {
         this._templateContext = templateContext;
     }
 
     @Override
     public boolean isAnyFaceletsVariableResolved()
     {
         if (_trackResolveVariables)
         {
             return _variableResolved;
         }
         else
         {
             //Force expression creation
             return true;
         }
     }
 
     @Override
     public void beforeConstructELExpression()
     {
         _trackResolveVariables = true;
         _variableResolved = false;
     }
 
     @Override
     public void afterConstructELExpression()
     {
         _trackResolveVariables = false;
         _variableResolved = false;
     }
 }