/*
    * 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.dynaForm.lib;
  
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  
  import javax.faces.FacesException;
  import javax.faces.application.Application;
  import javax.faces.component.UIComponent;
  import javax.faces.context.FacesContext;
  import javax.faces.el.ValueBinding;
  import javax.el.ELContext;
  import javax.el.ExpressionFactory;
  import javax.el.ValueExpression;
  
  /**
   * Some JSF helpers to smooth over the differences between JSF1.1 and JSF1.2.
   */
  public final class _FacesUtils
  {
      private static final Class<?>[] ARGS_SET_VALUE_EXPR = new Class[]
      {
          String.class,
          ValueExpression.class
      };
  
      private static final Class<?>[] ARGS_GET_VALUE_EXPR = new Class[]
      {
          String.class
      };
  
      private static final Method _METHOD_GELC = getMethod(FacesContext.class, "getELContext", (Class[]) null);
      private static final Method _METHOD_GVE = getMethod(UIComponent.class, "getValueExpression", ARGS_GET_VALUE_EXPR);
      private static final Method _METHOD_SVE = getMethod(UIComponent.class, "setValueExpression", ARGS_SET_VALUE_EXPR);
      private static final Method _METHOD_EF = getMethod(Application.class, "getExpressionFactory", (Class[]) null);
  
      private _FacesUtils()
      {
      }
  
      private static Method getMethod(Class<?> clazz, String name, Class<?>[] args)
      {
          try
          {
              return clazz.getMethod(name, args);
          }
          catch(Exception e)
          {
              return null;
          }
      }
  
      private static <T> T invoke(Class<T> retType, Method method, Object target, Object[] args)
      throws FacesException
      {
          try
          {
              @SuppressWarnings("unchecked")
              T result = (T) method.invoke(target, args);
              return result;
          }
          catch(IllegalAccessException e)
          {
              // should never happen
              throw new FacesException("Unable to invoke standard JSF method", e);
          }
          catch(InvocationTargetException e)
          {
              // should never happen
              throw new FacesException("Unable to invoke standard JSF method", e);
          }
      }
  
      public static void copyRendered(UIComponent source, UIComponent destination)
      {
          boolean renderedSet = false;
          if (_METHOD_GVE != null)
          {
              ValueExpression ve = invoke(ValueExpression.class, _METHOD_GVE, source, new Object[] {"rendered"});
              if (ve != null)
              {
                  invoke(Void.class, _METHOD_SVE, destination, new Object[]{"rendered", ve});
                 renderedSet = true;
             }
         }
         else
         {
             ValueBinding vb = source.getValueBinding("rendered");
             if (vb != null)
             {
                 destination.setValueBinding("rendered", vb);
                 renderedSet = true;
             }
         }
         if (!renderedSet)
         {
             destination.setRendered(destination.isRendered());
         }
     }
 
     /**
      * This associates an EL expression with the "value" attribute of the specified UIComponent.
      * <p> 
      * @param cmp is the component whose value attribute is to be updated.
      * 
      * @param elCtx is optional; when specified and this is a JSF1.2 environment then this is
      * used when resolving the expression. When this is not a JSF1.2 environment then this
      * parameter is ignored.
      * 
      * @param context is the JSF FacesContext to use.
      * 
      * @param vbString is the expression string, eg "#{someBean.someProperty}"
      */
     public static void setValueExpression(UIComponent cmp, ELContext elCtx, FacesContext context, String vbString)
     {
         Application app = context.getApplication();
         if (_METHOD_GELC != null)
         {
             if (elCtx == null)
             {
                 elCtx = invoke(ELContext.class, _METHOD_GELC, context, (Object[]) null);
             }
 
             ExpressionFactory expressionFactory = invoke(ExpressionFactory.class, _METHOD_EF, app, (Object[]) null);
             ValueExpression ve = expressionFactory.createValueExpression(elCtx, vbString, Object.class);
 
             invoke(Void.class, _METHOD_SVE, cmp, new Object[] {"value", ve});
         }
         else
         {
             ValueBinding vb = app.createValueBinding(vbString);
             cmp.setValueBinding("value", vb);
         }
     }
 }