/*

  * 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.compiler;

 import java.util.List;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.faces.application.ViewHandler;

 import javax.faces.component.UIComponent;

 import javax.faces.component.UIViewRoot;

 import javax.faces.context.ExternalContext;

 import javax.faces.context.FacesContext;

 import javax.faces.context.FacesContextWrapper;

 import javax.faces.view.facelets.TagDecorator;

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

 import org.apache.myfaces.config.RuntimeConfig;

 import org.apache.myfaces.config.element.ComponentTagDeclaration;

 import org.apache.myfaces.config.element.facelets.FaceletTagLibrary;

 import org.apache.myfaces.shared.config.MyfacesConfig;

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

 import org.apache.myfaces.view.facelets.tag.ComponentTagDeclarationLibrary;

 import org.apache.myfaces.view.facelets.tag.TagLibrary;

 import org.apache.myfaces.view.facelets.tag.composite.CompositeLibrary;

 import org.apache.myfaces.view.facelets.tag.composite.CompositeResourceLibrary;

 import org.apache.myfaces.view.facelets.tag.jsf.JsfLibrary;

 import org.apache.myfaces.view.facelets.tag.jsf.PassThroughLibrary;

 import org.apache.myfaces.view.facelets.tag.jsf.core.CoreLibrary;

 import org.apache.myfaces.view.facelets.tag.jsf.html.HtmlLibrary;

 import org.apache.myfaces.view.facelets.tag.jstl.core.JstlCoreLibrary;

 import org.apache.myfaces.view.facelets.tag.jstl.core.LegacyJstlCoreLibrary;

 import org.apache.myfaces.view.facelets.tag.jstl.fn.JstlFnLibrary;

 import org.apache.myfaces.view.facelets.tag.ui.LegacyUILibrary;

 import org.apache.myfaces.view.facelets.tag.ui.UILibrary;

 import org.apache.myfaces.view.facelets.util.ReflectionUtil;

 /**

  * Perform initialization steps for facelets compiler

  *

  * @since 2.2

  */

 public class FaceletsCompilerSupport

 {

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

     /**

      * Set of class names, separated by ';', implementing TagDecorator interface, used to transform

      * a view definition in a facelet abstract syntax tree, that is used later to generate a component tree.

      */

     @JSFWebConfigParam(since = "2.0", deprecated = true)

     private final static String PARAM_DECORATORS_DEPRECATED = "facelets.DECORATORS";

     private final static String[] PARAMS_DECORATORS = {ViewHandler.FACELETS_DECORATORS_PARAM_NAME, 

         PARAM_DECORATORS_DEPRECATED};

     /**

      * Skip comments found on a facelet file.

      */

     @JSFWebConfigParam(since = "2.0", deprecated = true)

     private final static String PARAM_SKIP_COMMENTS_DEPRECATED = "facelets.SKIP_COMMENTS";

     private final static String[] PARAMS_SKIP_COMMENTS = {ViewHandler.FACELETS_SKIP_COMMENTS_PARAM_NAME,

         PARAM_SKIP_COMMENTS_DEPRECATED};

     /**

      * Load the various tag libraries for Facelets.

      *

      * @param context

      *            the current FacesContext

      * @param compiler

      *            the page compiler

      */

     public void loadLibraries(FacesContext context, Compiler compiler)

     {

         ExternalContext eContext = context.getExternalContext();

         MyfacesConfig config = MyfacesConfig.getCurrentInstance(eContext);

         // Initialize Runtime Libraries

         compiler.addTagLibrary(new CoreLibrary());

         compiler.addTagLibrary(new HtmlLibrary());

         if (config.isStrictJsf2FaceletsCompatibility())

         {

             compiler.addTagLibrary(new LegacyUILibrary());

             compiler.addTagLibrary(new LegacyJstlCoreLibrary());

             compiler.addTagLibrary(new LegacyJstlCoreLibrary(JstlCoreLibrary.ALTERNATIVE_NAMESPACE));

         }

         else

         {

             compiler.addTagLibrary(new UILibrary());

             compiler.addTagLibrary(new JstlCoreLibrary());

             compiler.addTagLibrary(new JstlCoreLibrary(JstlCoreLibrary.ALTERNATIVE_NAMESPACE));            

         }

         compiler.addTagLibrary(new JstlFnLibrary());

         compiler.addTagLibrary(new CompositeLibrary());

         compiler.addTagLibrary(new CompositeResourceLibrary(context,

             CompositeResourceLibrary.NAMESPACE_PREFIX));

         compiler.addTagLibrary(new CompositeResourceLibrary(context,

             CompositeResourceLibrary.ALIAS_NAMESPACE_PREFIX));

         compiler.addTagLibrary(new JsfLibrary());

         compiler.addTagLibrary(new PassThroughLibrary());

         RuntimeConfig runtimeConfig = RuntimeConfig.getCurrentInstance(eContext);

         if (!runtimeConfig.getComponentTagDeclarations().isEmpty())

         {

             // Set a dummy view root, to avoid Application.createComponent() to fail

             ComponentTagDeclarationLibrary componentTagDeclarationLibrary = new ComponentTagDeclarationLibrary();

             LoadComponentTagDeclarationFacesContextWrapper wrappedFacesContext = 

                 new LoadComponentTagDeclarationFacesContextWrapper(context);

             try

             {

                 wrappedFacesContext.setWrapperAsCurrentFacesContext();

                 UIViewRoot root = new UIViewRoot();

                 root.setRenderKitId("HTML_BASIC");

                 wrappedFacesContext.setViewRoot(new UIViewRoot());

                 for (ComponentTagDeclaration declaration : runtimeConfig.getComponentTagDeclarations())

                 {

                     // We have here probably an inconsistency, because the annotation does not

                     // have a default renderer type. Let the renderer type be null will cause problems 

                     // later, because application.createComponent() may not scan the renderer class if

                     // a rendererType is not provided. The easy way to overcome this situation is create

                     // a dummy instance and check its rendererType. If is set the renderer if any will be

                     // scanned for annotations, if not it just do things as usual. It is unlikely to create

                     // a component and does not set a default renderer type if is required.

                     UIComponent component = context.getApplication().createComponent(declaration.getComponentType());

                     componentTagDeclarationLibrary.addComponent(declaration.getNamespace(), 

                             declaration.getTagName(), declaration.getComponentType(), component.getRendererType());

                 }

             }

             finally

             {

                 wrappedFacesContext.restoreCurrentFacesContext();

             }

             compiler.addTagLibrary(componentTagDeclarationLibrary);

         }

         List<FaceletTagLibrary> faceletTagLibraries = runtimeConfig.getFaceletTagLibraries();

         for (FaceletTagLibrary faceletTagLibrary : faceletTagLibraries)

         {

             //Create TagLibrary here, populate and add it to the compiler.

             TagLibrary tl = TagLibraryConfig.create(context, faceletTagLibrary);

             if (tl != null)

             {

                 compiler.addTagLibrary(tl);

             }

         }

     }

     /**

      * Load the various decorators for Facelets.

      *

      * @param context

      *            the current FacesContext

      * @param compiler

      *            the page compiler

      */

     public void loadDecorators(FacesContext context, Compiler compiler)

     {

         String param = WebConfigParamUtils.getStringInitParameter(context.getExternalContext(), PARAMS_DECORATORS);

         if (param != null)

         {

             for (String decorator : param.split(";"))

             {

                 try

                 {

                     compiler.addTagDecorator((TagDecorator) ReflectionUtil.forName(decorator).newInstance());

                     if (log.isLoggable(Level.FINE))

                     {

                         log.fine("Successfully loaded decorator: " + decorator);

                     }

                 }

                 catch (Exception e)

                 {

                     log.log(Level.SEVERE, "Error Loading decorator: " + decorator, e);

                 }

             }

         }

     }

     public void loadOptions(FacesContext context, Compiler compiler)

     {

         ExternalContext eContext = context.getExternalContext();

         // skip comments?

         compiler.setTrimmingComments(WebConfigParamUtils.getBooleanInitParameter(

                 eContext, PARAMS_SKIP_COMMENTS, false));

         compiler.setFaceletsProcessingConfigurations(

                 RuntimeConfig.getCurrentInstance(

                         context.getExternalContext()).getFaceletProcessingConfigurations());

     }

     private static class LoadComponentTagDeclarationFacesContextWrapper 

         extends FacesContextWrapper

     {

         private FacesContext delegate;

         private UIViewRoot root;

         public LoadComponentTagDeclarationFacesContextWrapper(FacesContext delegate)

         {

             this.delegate = delegate;

         }

         @Override

         public UIViewRoot getViewRoot()

         {

             return root;

         }

         @Override

         public void setViewRoot(UIViewRoot root)

         {

             this.root = root;

         }

         @Override

         public FacesContext getWrapped()

         {

             return delegate;

         }

         void setWrapperAsCurrentFacesContext()

         {

             setCurrentInstance(this);

         }

         void restoreCurrentFacesContext()

         {

             setCurrentInstance(delegate);

         }

     }

 }