/*
    * 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 javax.faces.component.html;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.lang.reflect.Array;
  import java.net.URL;
  import java.security.AccessController;
  import java.security.PrivilegedActionException;
  import java.security.PrivilegedExceptionAction;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.el.ExpressionFactory;
  import javax.faces.FacesException;
  import javax.faces.context.FacesContext;
  
  final class _ClassUtils
  {
      // ~ Static fields/initializers -----------------------------------------------------------------
  
      //private static final Log log = LogFactory.getLog(_ClassUtils.class);
      private static final Logger log = Logger.getLogger(_ClassUtils.class.getName());
  
      public static final Class<boolean[]> BOOLEAN_ARRAY_CLASS = boolean[].class;
      public static final Class<byte[]> BYTE_ARRAY_CLASS = byte[].class;
      public static final Class<char[]> CHAR_ARRAY_CLASS = char[].class;
      public static final Class<short[]> SHORT_ARRAY_CLASS = short[].class;
      public static final Class<int[]> INT_ARRAY_CLASS = int[].class;
      public static final Class<long[]> LONG_ARRAY_CLASS = long[].class;
      public static final Class<float[]> FLOAT_ARRAY_CLASS = float[].class;
      public static final Class<double[]> DOUBLE_ARRAY_CLASS = double[].class;
      public static final Class<Object[]> OBJECT_ARRAY_CLASS = Object[].class;
      public static final Class<Boolean[]> BOOLEAN_OBJECT_ARRAY_CLASS = Boolean[].class;
      public static final Class<Byte[]> BYTE_OBJECT_ARRAY_CLASS = Byte[].class;
      public static final Class<Character[]> CHARACTER_OBJECT_ARRAY_CLASS = Character[].class;
      public static final Class<Short[]> SHORT_OBJECT_ARRAY_CLASS = Short[].class;
      public static final Class<Integer[]> INTEGER_OBJECT_ARRAY_CLASS = Integer[].class;
      public static final Class<Long[]> LONG_OBJECT_ARRAY_CLASS = Long[].class;
      public static final Class<Float[]> FLOAT_OBJECT_ARRAY_CLASS = Float[].class;
      public static final Class<Double[]> DOUBLE_OBJECT_ARRAY_CLASS = Double[].class;
      public static final Class<String[]> STRING_OBJECT_ARRAY_CLASS = String[].class;
  
      public static final Map<String, Class<?>> COMMON_TYPES = new HashMap<String, Class<?>>(64);
      static
      {
          COMMON_TYPES.put("byte", Byte.TYPE);
          COMMON_TYPES.put("char", Character.TYPE);
          COMMON_TYPES.put("double", Double.TYPE);
          COMMON_TYPES.put("float", Float.TYPE);
          COMMON_TYPES.put("int", Integer.TYPE);
          COMMON_TYPES.put("long", Long.TYPE);
          COMMON_TYPES.put("short", Short.TYPE);
          COMMON_TYPES.put("boolean", Boolean.TYPE);
          COMMON_TYPES.put("void", Void.TYPE);
          COMMON_TYPES.put("java.lang.Object", Object.class);
          COMMON_TYPES.put("java.lang.Boolean", Boolean.class);
          COMMON_TYPES.put("java.lang.Byte", Byte.class);
          COMMON_TYPES.put("java.lang.Character", Character.class);
          COMMON_TYPES.put("java.lang.Short", Short.class);
          COMMON_TYPES.put("java.lang.Integer", Integer.class);
          COMMON_TYPES.put("java.lang.Long", Long.class);
          COMMON_TYPES.put("java.lang.Float", Float.class);
          COMMON_TYPES.put("java.lang.Double", Double.class);
          COMMON_TYPES.put("java.lang.String", String.class);
  
          COMMON_TYPES.put("byte[]", BYTE_ARRAY_CLASS);
          COMMON_TYPES.put("char[]", CHAR_ARRAY_CLASS);
          COMMON_TYPES.put("double[]", DOUBLE_ARRAY_CLASS);
          COMMON_TYPES.put("float[]", FLOAT_ARRAY_CLASS);
          COMMON_TYPES.put("int[]", INT_ARRAY_CLASS);
          COMMON_TYPES.put("long[]", LONG_ARRAY_CLASS);
          COMMON_TYPES.put("short[]", SHORT_ARRAY_CLASS);
          COMMON_TYPES.put("boolean[]", BOOLEAN_ARRAY_CLASS);
          COMMON_TYPES.put("java.lang.Object[]", OBJECT_ARRAY_CLASS);
          COMMON_TYPES.put("java.lang.Boolean[]", BOOLEAN_OBJECT_ARRAY_CLASS);
         COMMON_TYPES.put("java.lang.Byte[]", BYTE_OBJECT_ARRAY_CLASS);
         COMMON_TYPES.put("java.lang.Character[]", CHARACTER_OBJECT_ARRAY_CLASS);
         COMMON_TYPES.put("java.lang.Short[]", SHORT_OBJECT_ARRAY_CLASS);
         COMMON_TYPES.put("java.lang.Integer[]", INTEGER_OBJECT_ARRAY_CLASS);
         COMMON_TYPES.put("java.lang.Long[]", LONG_OBJECT_ARRAY_CLASS);
         COMMON_TYPES.put("java.lang.Float[]", FLOAT_OBJECT_ARRAY_CLASS);
         COMMON_TYPES.put("java.lang.Double[]", DOUBLE_OBJECT_ARRAY_CLASS);
         COMMON_TYPES.put("java.lang.String[]", STRING_OBJECT_ARRAY_CLASS);
         // array of void is not a valid type
     }
 
     /** utility class, do not instantiate */
     private _ClassUtils()
     {
         // utility class, disable instantiation
     }
 
     // ~ Methods ------------------------------------------------------------------------------------
 
     /**
      * Tries a Class.loadClass with the context class loader of the current thread first and automatically falls back to
      * the ClassUtils class loader (i.e. the loader of the myfaces.jar lib) if necessary.
      * 
      * @param type
      *            fully qualified name of a non-primitive non-array class
      * @return the corresponding Class
      * @throws NullPointerException
      *             if type is null
      * @throws ClassNotFoundException
      */
     public static Class<?> classForName(String type) throws ClassNotFoundException
     {
         if (type == null)
         {
             throw new NullPointerException("type");
         }
         try
         {
             // Try WebApp ClassLoader first
             return Class.forName(type, false, // do not initialize for faster startup
                 getContextClassLoader());
         }
         catch (ClassNotFoundException ignore)
         {
             // fallback: Try ClassLoader for ClassUtils (i.e. the myfaces.jar lib)
             return Class.forName(type, false, // do not initialize for faster startup
                 _ClassUtils.class.getClassLoader());
         }
     }
 
     /**
      * Same as {@link #classForName(String)}, but throws a RuntimeException (FacesException) instead of a
      * ClassNotFoundException.
      * 
      * @return the corresponding Class
      * @throws NullPointerException
      *             if type is null
      * @throws FacesException
      *             if class not found
      */
     public static Class<?> simpleClassForName(String type)
     {
         try
         {
             return classForName(type);
         }
         catch (ClassNotFoundException e)
         {
             log.log(Level.SEVERE, "Class " + type + " not found", e);
             throw new FacesException(e);
         }
     }
 
     /**
      * Similar as {@link #classForName(String)}, but also supports primitive types and arrays as specified for the
      * JavaType element in the JavaServer Faces Config DTD.
      * 
      * @param type
      *            fully qualified class name or name of a primitive type, both optionally followed by "[]" to indicate
      *            an array type
      * @return the corresponding Class
      * @throws NullPointerException
      *             if type is null
      * @throws ClassNotFoundException
      */
     public static Class<?> javaTypeToClass(String type) throws ClassNotFoundException
     {
         if (type == null)
         {
             throw new NullPointerException("type");
         }
 
         // try common types and arrays of common types first
         Class<?> clazz = COMMON_TYPES.get(type);
         if (clazz != null)
         {
             return clazz;
         }
 
         int len = type.length();
         if (len > 2 && type.charAt(len - 1) == ']' && type.charAt(len - 2) == '[')
         {
             String componentType = type.substring(0, len - 2);
             Class<?> componentTypeClass = classForName(componentType);
             return Array.newInstance(componentTypeClass, 0).getClass();
         }
 
         return classForName(type);
 
     }
 
     /**
      * Same as {@link #javaTypeToClass(String)}, but throws a RuntimeException (FacesException) instead of a
      * ClassNotFoundException.
      * 
      * @return the corresponding Class
      * @throws NullPointerException
      *             if type is null
      * @throws FacesException
      *             if class not found
      */
     public static Class<?> simpleJavaTypeToClass(String type)
     {
         try
         {
             return javaTypeToClass(type);
         }
         catch (ClassNotFoundException e)
         {
             log.log(Level.SEVERE, "Class " + type + " not found", e);
             throw new FacesException(e);
         }
     }
 
     public static InputStream getResourceAsStream(String resource)
     {
         InputStream stream = getContextClassLoader().getResourceAsStream(resource);
         if (stream == null)
         {
             // fallback
             stream = _ClassUtils.class.getClassLoader().getResourceAsStream(resource);
         }
         return stream;
     }
 
     /**
      * @param resource
      *            Name of resource(s) to find in classpath
      * @param defaultObject
      *            The default object to use to determine the class loader (if none associated with current thread.)
      * @return Iterator over URL Objects
      */
     public static Collection<? extends URL> getResources(String resource, Object defaultObject)
     {
         try
         {
             Enumeration<URL> resources = getCurrentLoader(defaultObject).getResources(resource);
             List<URL> lst = new ArrayList<URL>();
             while (resources.hasMoreElements())
             {
                 lst.add(resources.nextElement());
             }
             return lst;
         }
         catch (IOException e)
         {
             log.log(Level.SEVERE, e.getMessage(), e);
             throw new FacesException(e);
         }
     }
 
     public static Object newInstance(String type) throws FacesException
     {
         if (type == null)
         {
             return null;
         }
         return newInstance(simpleClassForName(type));
     }
 
     public static Object newInstance(String type, Class<?> expectedType) throws FacesException
     {
         return newInstance(type, expectedType == null ? null : new Class[] { expectedType });
     }
 
     public static Object newInstance(String type, Class<?>[] expectedTypes)
     {
         if (type == null)
         {
             return null;
         }
 
         Class<?> clazzForName = simpleClassForName(type);
 
         if (expectedTypes != null)
         {
             for (int i = 0, size = expectedTypes.length; i < size; i++)
             {
                 if (!expectedTypes[i].isAssignableFrom(clazzForName))
                 {
                     throw new FacesException("'" + type + "' does not implement expected type '" + expectedTypes[i]
                             + "'");
                 }
             }
         }
 
         return newInstance(clazzForName);
     }
 
     public static Object newInstance(Class<?> clazz) throws FacesException
     {
         try
         {
             return clazz.newInstance();
         }
         catch (NoClassDefFoundError e)
         {
             log.log(Level.SEVERE, "Class : " + clazz.getName() + " not found.", e);
             throw new FacesException(e);
         }
         catch (InstantiationException e)
         {
             log.log(Level.SEVERE, e.getMessage(), e);
             throw new FacesException(e);
         }
         catch (IllegalAccessException e)
         {
             log.log(Level.SEVERE, e.getMessage(), e);
             throw new FacesException(e);
         }
     }
 
     public static Object convertToType(Object value, Class<?> desiredClass)
     {
         if (value == null)
         {
             return null;
         }
 
         try
         {
             ExpressionFactory expFactory = FacesContext.getCurrentInstance().getApplication().getExpressionFactory();
             return expFactory.coerceToType(value, desiredClass);
         }
         catch (Exception e)
         {
             String message = "Cannot coerce " + value.getClass().getName() + " to " + desiredClass.getName();
             log.log(Level.SEVERE, message, e);
             throw new FacesException(message, e);
         }
     }
 
     public static Object convertToTypeNoLogging(FacesContext facesContext, Object value, Class<?> desiredClass)
         throws Exception
     {
         if (value == null)
         {
             return null;
         }
 
         ExpressionFactory expFactory = facesContext.getApplication().getExpressionFactory();
         return expFactory.coerceToType(value, desiredClass);
     }    
 
     /**
      * Gets the ClassLoader associated with the current thread. Returns the class loader associated with the specified
      * default object if no context loader is associated with the current thread.
      * 
      * @param defaultObject
      *            The default object to use to determine the class loader (if none associated with current thread.)
      * @return ClassLoader
      */
     protected static ClassLoader getCurrentLoader(Object defaultObject)
     {
         ClassLoader loader = getContextClassLoader();
         
         if (loader == null)
         {
             loader = defaultObject.getClass().getClassLoader();
         }
         return loader;
     }
     
     /**
      * Gets the ClassLoader associated with the current thread. Returns the class loader associated with the specified
      * default object if no context loader is associated with the current thread.
      * 
      * @return ClassLoader
      */
     protected static ClassLoader getContextClassLoader()
     {
         if (System.getSecurityManager() != null)
         {
             try
             {
                 Object cl = AccessController.doPrivileged(new PrivilegedExceptionAction()
                 {
                             public Object run() throws PrivilegedActionException
                             {
                                 return Thread.currentThread().getContextClassLoader();
                             }
                 });
                 return (ClassLoader) cl;
             }
             catch (PrivilegedActionException pae)
             {
                 throw new FacesException(pae);
             }
         }
         else
         {
             return Thread.currentThread().getContextClassLoader();
         }
     }   
 }