/*
    * 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.flow.utils;
  
  import java.util.Stack;
  
  import javax.el.ELContext;
  import javax.el.ExpressionFactory;
  import javax.el.MethodExpression;
  import javax.el.ValueExpression;
  import javax.faces.context.FacesContext;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.myfaces.orchestra.lib.OrchestraException;
  
  import com.sun.facelets.FaceletContext;
  
  /**
   * Creates ValueExpression objects based on the "current" ELContext.
   * <p>
   * This class allows an ELContext to be "tunnelled" as a thread-local variable to places where code
   * wants to create a ValueExpression even though the ELContext is not available as a parameter.
   */
  public class _ExpressionFactory
  {
      private static final ThreadLocal<Stack<ELContext>> _contextsThreadLocal = new ThreadLocal<Stack<ELContext>>();
  
      public static void pushContext(ELContext ctx)
      {
          if (ctx == null)
          {
              throw new IllegalArgumentException("ctx must not be null");
          }
          Stack<ELContext> s = _contextsThreadLocal.get();
          if (s == null)
          {
              s = new Stack<ELContext>();
              _contextsThreadLocal.set(s);
          }
          s.push(ctx);
      }
  
      public static void popContext(ELContext ctx)
      {
          Stack<ELContext> s = _contextsThreadLocal.get();
          if (s == null)
          {
              throw new IllegalStateException("context stack is null");
          }
          if (s.isEmpty())
          {
              throw new IllegalStateException("context stack is empty");
          }
          Object o = s.pop();
          if (o != ctx)
          {
              throw new IllegalStateException("context stack unbalanced");
          }
          if (s.isEmpty())
          {
              _contextsThreadLocal.remove();
          }
      }
  
      private static FaceletContext peekContext()
      {
          Stack<ELContext> s = _contextsThreadLocal.get();
          if (s == null)
          {
              return null;
          }
          return (FaceletContext) s.peek();
      }
  
      public static ValueExpression createValueExpression(FacesContext facesContext, String expr)
      {
          ELContext elContext = peekContext();
          if (elContext == null)
          {
              // ok, we are not running within the context of some particular UIComponent, ie we are
              // not processing xml embedded within an of:flowCall tag in a JSP page. We are probably
             // processing a flow.xml file loaded from the disk. In this case, just use the "global"
             // el context held by the FacesContext object.
             elContext = facesContext.getELContext();
         }
 
         try
         {
             ExpressionFactory ef = facesContext.getApplication().getExpressionFactory();
             ValueExpression ve = ef.createValueExpression(elContext, expr, Object.class);
             return ve;
         }
         catch(Exception e)
         {
             Log log = LogFactory.getLog(_ExpressionFactory.class);
             String msg = "Unable to parse value expression in flow:" + expr;
             log.warn(msg, e);
             throw new OrchestraException(msg, e);
         }
     }
 
     public static MethodExpression createMethodExpression(FacesContext facesContext, String expr)
     {
         ELContext elContext = peekContext();
         if (elContext == null)
         {
             // ok, we are not running within the context of some particular UIComponent, ie we are
             // not processing xml embedded within an of:flowCall tag in a JSP page. We are probably
             // processing a flow.xml file loaded from the disk. In this case, just use the "global"
             // el context held by the FacesContext object.
             elContext = facesContext.getELContext();
         }
 
         try
         {
             ExpressionFactory ef = facesContext.getApplication().getExpressionFactory();
             MethodExpression me = ef.createMethodExpression(elContext, expr, Object.class, null);
             return me;
         }
         catch(Exception e)
         {
             Log log = LogFactory.getLog(_ExpressionFactory.class);
             String msg = "Unable to parse method expression in flow:" + expr;
             log.warn(msg, e);
             throw new OrchestraException(msg, e);
         }
     }
 }