/*

  * 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.spi.impl;

 import java.lang.reflect.InvocationTargetException;

 import java.security.AccessController;

 import java.security.PrivilegedActionException;

 import java.util.Iterator;

 import java.util.List;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.faces.FacesException;

 import javax.faces.context.ExternalContext;

 import javax.faces.context.FacesContext;

 import javax.naming.Context;

 import javax.naming.InitialContext;

 import javax.naming.NamingException;

 import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFWebConfigParam;

 import org.apache.myfaces.shared.util.ClassUtils;

 import org.apache.myfaces.spi.InjectionProvider;

 import org.apache.myfaces.spi.InjectionProviderFactory;

 import org.apache.myfaces.spi.ServiceProviderFinderFactory;

 /**

  * 

  * 

  */

 public class DefaultInjectionProviderFactory extends InjectionProviderFactory

 {

     //private static Log log = LogFactory.getLog(DefaultLifecycleProviderFactory.class);

     private static Logger log = Logger.getLogger(DefaultInjectionProviderFactory.class.getName());

     /**

      * Define the class implementing InjectionProvider interface to handle PostConstruct 

      * and PreDestroy annotations.

      * 

      * <p>This also can be configured using a SPI entry (/META-INF/services/...).

      * </p>

      */

     public static final String INJECTION_PROVIDER_INSTANCE_KEY

             = InjectionProvider.class.getName() + ".INJECTION_PROVIDER_INSTANCE";

     @JSFWebConfigParam(name="org.apache.myfaces.spi.InjectionProvider", since="2.2")

     public static final String INJECTION_PROVIDER = InjectionProvider.class.getName();

     public DefaultInjectionProviderFactory()

     {

     }

     @Override

     public InjectionProvider getInjectionProvider(ExternalContext externalContext)

     {

         InjectionProvider lifecycleProvider = null;

         if (externalContext == null)

         {

             // Really in jsf 2.0, this will not happen, because a Startup/Shutdown

             // FacesContext and ExternalContext are provided on initialization and shutdown,

             // and in other scenarios the real FacesContext/ExternalContext is provided.

             log.info("No ExternalContext using fallback InjectionProvider.");

             lifecycleProvider = resolveFallbackInjectionProvider();

         }

         else

         {

             lifecycleProvider = (InjectionProvider)

                     externalContext.getApplicationMap().get(INJECTION_PROVIDER_INSTANCE_KEY);

         }

         if (lifecycleProvider == null)

         {

             if (!resolveInjectionProviderFromExternalContext(externalContext))

             {

                 if (!resolveInjectionProviderFromService(externalContext))

                 {

                     lifecycleProvider = resolveFallbackInjectionProvider();

                     externalContext.getApplicationMap().put(INJECTION_PROVIDER_INSTANCE_KEY, lifecycleProvider);

                 }

                 else

                 {

                     //Retrieve it because it was resolved

                     lifecycleProvider = (InjectionProvider)

                             externalContext.getApplicationMap().get(INJECTION_PROVIDER_INSTANCE_KEY);

                 }

             }

             else

             {

                 //Retrieve it because it was resolved

                 lifecycleProvider = (InjectionProvider)

                         externalContext.getApplicationMap().get(INJECTION_PROVIDER_INSTANCE_KEY);

             }

             log.info("Using InjectionProvider "+ lifecycleProvider.getClass().getName());

         }

         return lifecycleProvider;

     }

     @Override

     public void release()

     {

     }

     private boolean resolveInjectionProviderFromExternalContext(ExternalContext externalContext)

     {

         try

         {

             String lifecycleProvider = externalContext.getInitParameter(INJECTION_PROVIDER);

             if (lifecycleProvider != null)

             {

                 Object obj = createClass(lifecycleProvider, externalContext);

                 if (obj instanceof InjectionProvider)

                 {

                     externalContext.getApplicationMap().put(INJECTION_PROVIDER_INSTANCE_KEY, obj);

                     return true;

                 }

             }

         }

         catch (ClassNotFoundException e)

         {

             log.log(Level.SEVERE, "", e);

         }

         catch (InstantiationException e)

         {

             log.log(Level.SEVERE, "", e);

         }

         catch (IllegalAccessException e)

         {

             log.log(Level.SEVERE, "", e);

         }

         catch (InvocationTargetException e)

         {

             log.log(Level.SEVERE, "", e);

         }

         return false;

     }

     private boolean resolveInjectionProviderFromService(

             ExternalContext externalContext)

     {

         boolean returnValue = false;

         final ExternalContext extContext = externalContext;

         try

         {

             if (System.getSecurityManager() != null)

             {

                 returnValue = AccessController.doPrivileged(new java.security.PrivilegedExceptionAction<Boolean>()

                         {

                             public Boolean run() throws ClassNotFoundException,

                                     NoClassDefFoundError,

                                     InstantiationException,

                                     IllegalAccessException,

                                     InvocationTargetException,

                                     PrivilegedActionException

                             {

                                 List<String> classList

                                         = ServiceProviderFinderFactory.getServiceProviderFinder(extContext).

                                                                        getServiceProviderList(INJECTION_PROVIDER);

                                 Iterator<String> iter = classList.iterator();

                                 while (iter.hasNext())

                                 {

                                     String className = iter.next();

                                     Object obj = createClass(className,extContext);

                                     if (InjectionProvider.class.isAssignableFrom(obj.getClass()))

                                     {

                                         InjectionProvider discoverableInjectionProvider =

                                                 (InjectionProvider) obj;

                                         if (discoverableInjectionProvider.isAvailable())

                                         {

                                             extContext.getApplicationMap().put(INJECTION_PROVIDER_INSTANCE_KEY,

                                                                                discoverableInjectionProvider);

                                             return true;

                                         }

                                     }

                                 }

                                 return false;

                             }

                         });

             }

             else

             {

                 List<String> classList = ServiceProviderFinderFactory.getServiceProviderFinder(extContext).

                         getServiceProviderList(INJECTION_PROVIDER);

                 Iterator<String> iter = classList.iterator();

                 while (iter.hasNext())

                 {

                     String className = iter.next();

                     Object obj = createClass(className,extContext);

                     if (InjectionProvider.class.isAssignableFrom(obj.getClass()))

                     {

                         InjectionProvider discoverableInjectionProvider

                                 = (InjectionProvider) obj;

                         if (discoverableInjectionProvider.isAvailable())

                         {

                             extContext.getApplicationMap().put(INJECTION_PROVIDER_INSTANCE_KEY,

                                                                discoverableInjectionProvider);

                             return (Boolean) true;

                         }

                     }

                 }

             }

         }

         catch (ClassNotFoundException e)

         {

             // ignore

         }

         catch (NoClassDefFoundError e)

         {

             // ignore

         }

         catch (InstantiationException e)

         {

             log.log(Level.SEVERE, "", e);

         }

         catch (IllegalAccessException e)

         {

             log.log(Level.SEVERE, "", e);

         }

         catch (InvocationTargetException e)

         {

             log.log(Level.SEVERE, "", e);

         }

         catch (PrivilegedActionException e)

         {

             throw new FacesException(e);

         }

         return returnValue;

     }

     private Object createClass(String className, ExternalContext externalContext)

             throws InstantiationException, IllegalAccessException, InvocationTargetException, ClassNotFoundException

     {

         Class<?> clazz = ClassUtils.classForName(className);

         try

         {

             return ClassUtils.newInstance(clazz, new Class<?>[]{ ExternalContext.class }, externalContext);

         }

         catch (NoSuchMethodException e)

         {

             return ClassUtils.newInstance(clazz);

         }

     }

     private InjectionProvider resolveFallbackInjectionProvider()

     {

         return resolveFallbackInjectionProvider(FacesContext.getCurrentInstance().getExternalContext());

     }

     private InjectionProvider resolveFallbackInjectionProvider(ExternalContext externalContext)

     {

         /* Added entry in META-INF/services/org.apache.myfaces.spi.InjectionProvider to

          * give precedence to CDI integration instead server integration.

         if (ExternalSpecifications.isCDIAvailable(externalContext))

         {

             try

             {

                 Class clazz = ClassUtils.simpleClassForName(

                     "org.apache.myfaces.cdi.impl.CDIAnnotationInjectionProvider");

                 return (InjectionProvider) clazz.getConstructor(

                     ExternalContext.class).newInstance(externalContext);

             }

             catch(Exception e)

             {

                 //Ignore

             }

         }

         */

         try

         {

             ClassUtils.classForName("javax.annotation.PreDestroy");

         }

         catch (ClassNotFoundException e)

         {

             // no annotation available don't process annotations

             return new NoAnnotationInjectionProvider(); 

         }

         Context context;

         try

         {

             context = new InitialContext();

             try

             {

                 ClassUtils.classForName("javax.ejb.EJB");

                 // Asume full JEE 5 container

                 return new AllAnnotationInjectionProvider(context);

             }

             catch (ClassNotFoundException e)

             {

                 // something else

                 return new ResourceAnnotationInjectionProvider(context);

             }

         }

         catch (NamingException e)

         {

             // no initial context available no injection

             log.log(Level.SEVERE, "No InitialContext found. Using NoInjectionAnnotationProcessor.", e);

             return new NoInjectionAnnotationInjectionProvider();

         }

         catch (NoClassDefFoundError e)

         {

             //On Google App Engine, javax.naming.Context is a restricted class.

             //In that case, NoClassDefFoundError is thrown. stageName needs to be configured

             //below by context parameter.

             log.log(Level.SEVERE, "No InitialContext class definition found. Using NoInjectionAnnotationProcessor.");

             return new NoInjectionAnnotationInjectionProvider();

         }

     }

 }