/*
    * 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.ELException;
  import javax.el.ValueExpression;
  import javax.el.VariableMapper;
  import javax.faces.FacesWrapper;
  
  /**
   * Utility class for wrapping another VariableMapper with a new context, represented by a {@link java.util.Map Map}.
   * Modifications occur to the Map instance, but resolve against the wrapped VariableMapper if the Map doesn't contain
   * the ValueExpression requested.
   * 
   * @author Jacob Hookom
   * @version $Id$
   */
  public final class VariableMapperWrapper extends VariableMapperBase implements FacesWrapper<VariableMapper>
  {
  
      private final VariableMapper _target;
      
      private final VariableMapperBase _targetBase;
  
      private Map<String, ValueExpression> _vars;
      
      //private final boolean _checkTargetBase;
      
      public boolean _trackResolveVariables;
      
      public boolean _variableResolved;
  
      /**
       * 
       */
      public VariableMapperWrapper(VariableMapper orig)
      {
          super();
          _target = orig;
          _targetBase = (orig instanceof VariableMapperBase) ? (VariableMapperBase) orig : null;
          //_checkTargetBase = true;
          _trackResolveVariables = false;
          _variableResolved = false;
      }
  
      /**
       * First tries to resolve agains the inner Map, then the wrapped ValueExpression.
       * 
       * @see javax.el.VariableMapper#resolveVariable(java.lang.String)
       */
      public ValueExpression resolveVariable(String variable)
      {
          ValueExpression ve = null;
          try
          {
              if (_vars != null)
              {
                  ve = (ValueExpression) _vars.get(variable);
  
                  // Is this code in a block that wants to cache 
                  // the resulting expression(s) and variable has been resolved?
                  if (_trackResolveVariables && ve != null)
                  {
                      _variableResolved = true;
                  }
              }
              
              if (ve == null)
              {
                  return _target.resolveVariable(variable);
              }
              
              return ve;
          }
          catch (StackOverflowError e)
          {
              throw new ELException("Could not Resolve Variable [Overflow]: " + variable, e);
          }
      }
  
     /**
      * Set the ValueExpression on the inner Map instance.
      * 
      * @see javax.el.VariableMapper#setVariable(java.lang.String, javax.el.ValueExpression)
      */
     public ValueExpression setVariable(String variable, ValueExpression expression)
     {
         if (_vars == null)
         {
             _vars = new HashMap<String, ValueExpression>();
         }
         
         return _vars.put(variable, expression);
     }
 
     @Override
     public boolean isAnyFaceletsVariableResolved()
     {
         if (_trackResolveVariables)
         {
             if (_variableResolved)
             {
                 //Force EL creation!
                 return true;
             }
             else
             {
                 //Otherwise check parent variable mapper 
                 //if (_checkTargetBase)
                 //{
                     if (_targetBase != null)
                     {
                         return _targetBase.isAnyFaceletsVariableResolved();
                     }
                     else
                     {
                         // Another VariableMapper not extending from the base one was used. 
                         // (that's the reason why _targetBase is null).
                         // It is not possible to be sure the EL expression could use that mapper, 
                         // so return true to force EL expression creation.
                         return true;
                     }
                 //}
                 //else
                 //{
                     // If no check for targetBase is required, we are in a context that suppose there will not
                     // be variables resolved that could affect the expressions. So return false, indicating
                     // the resulting expression can be cached.
                     //return false;
                 //}
             }
         }
         else
         {
             // Force expression creation, because the call is outside caching block.
             return true;
         }
     }
 
     public VariableMapper getWrapped()
     {
         return _target;
     }
 
     @Override
     public void beforeConstructELExpression()
     {
         _trackResolveVariables = true;
         _variableResolved = false;
         //if (_checkTargetBase && _targetBase != null)
         if (_targetBase != null)
         {
             _targetBase.beforeConstructELExpression();
         }
     }
 
     @Override
     public void afterConstructELExpression()
     {
         //if (_checkTargetBase && _targetBase != null)
         if (_targetBase != null)
         {
             _targetBase.afterConstructELExpression();
         }
         _trackResolveVariables = false;
         _variableResolved = false;
     }
 }