/*

  * 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.tag.composite;

 import java.lang.reflect.Method;

 import java.net.URL;

 import java.util.regex.Pattern;

 import javax.faces.FacesException;

 import javax.faces.application.Resource;

 import javax.faces.application.ResourceHandler;

 import javax.faces.application.ViewHandler;

 import javax.faces.context.ExternalContext;

 import javax.faces.context.FacesContext;

 import javax.faces.view.facelets.ComponentConfig;

 import javax.faces.view.facelets.FaceletHandler;

 import javax.faces.view.facelets.Tag;

 import javax.faces.view.facelets.TagConfig;

 import javax.faces.view.facelets.TagHandler;

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

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

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

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

 /**

  * This class create composite component tag handlers for "http://java.sun.com/jsf/composite/"

  * namespace. Note that the class that create composite component tag handlers using its own 

  * namespace defined in facelet taglib .xml file see TagLibraryConfig.TagLibraryImpl

  * 

  * @author Leonardo Uribe (latest modification by $Author$)

  * @version $Revision$ $Date$

  */

 public class CompositeResourceLibrary implements TagLibrary

 {

     public final static String NAMESPACE_PREFIX = "http://xmlns.jcp.org/jsf/composite/";

     public final static String ALIAS_NAMESPACE_PREFIX = "http://java.sun.com/jsf/composite/";

     private final ResourceHandler _resourceHandler;

     private Pattern _acceptPatterns;

     private String _extension;

     private String[] _defaultSuffixesArray;

     private String _namespacePrefix;

     public CompositeResourceLibrary(FacesContext facesContext, String namespacePrefix)

     {

         super();

         _namespacePrefix = namespacePrefix;

         _resourceHandler = facesContext.getApplication().getResourceHandler();

         ExternalContext externalContext = FacesContext.getCurrentInstance().getExternalContext();

         _acceptPatterns = loadAcceptPattern(externalContext);

         _extension = loadFaceletExtension(externalContext);

         String defaultSuffixes = WebConfigParamUtils.getStringInitParameter(externalContext,

                 ViewHandler.DEFAULT_SUFFIX_PARAM_NAME, ViewHandler.DEFAULT_SUFFIX );

         _defaultSuffixesArray = StringUtils.splitShortString(defaultSuffixes, ' ');

         boolean faceletsExtensionFound = false;

         for (String ext : _defaultSuffixesArray)

         {

             if (_extension.equals(ext))

             {

                 faceletsExtensionFound = true;

                 break;

             }

         }

         if (!faceletsExtensionFound)

         {

             _defaultSuffixesArray = (String[]) ArrayUtils.concat(_defaultSuffixesArray, new String[]{_extension});

         }

     }

     /**

      * Load and compile a regular expression pattern built from the Facelet view mapping parameters.

      * 

      * @param context

      *            the application's external context

      * 

      * @return the compiled regular expression

      */

     private Pattern loadAcceptPattern(ExternalContext context)

     {

         assert context != null;

         String mappings = context.getInitParameter(ViewHandler.FACELETS_VIEW_MAPPINGS_PARAM_NAME);

         if (mappings == null)

         {

             return null;

         }

         // Make sure the mappings contain something

         mappings = mappings.trim();

         if (mappings.length() == 0)

         {

             return null;

         }

         return Pattern.compile(toRegex(mappings));

     }

     private String loadFaceletExtension(ExternalContext context)

     {

         assert context != null;

         String suffix = context.getInitParameter(ViewHandler.FACELETS_SUFFIX_PARAM_NAME);

         if (suffix == null)

         {

             suffix = ViewHandler.DEFAULT_FACELETS_SUFFIX;

         }

         else

         {

             suffix = suffix.trim();

             if (suffix.length() == 0)

             {

                 suffix = ViewHandler.DEFAULT_FACELETS_SUFFIX;

             }

         }

         return suffix;

     }

     /**

      * Convert the specified mapping string to an equivalent regular expression.

      * 

      * @param mappings

      *            le mapping string

      * 

      * @return an uncompiled regular expression representing the mappings

      */

     private String toRegex(String mappings)

     {

         assert mappings != null;

         // Get rid of spaces

         mappings = mappings.replaceAll("\\s", "");

         // Escape '.'

         mappings = mappings.replaceAll("\\.", "\\\\.");

         // Change '*' to '.*' to represent any match

         mappings = mappings.replaceAll("\\*", ".*");

         // Split the mappings by changing ';' to '|'

         mappings = mappings.replaceAll(";", "|");

         return mappings;

     }

     public boolean handles(String resourceName)

     {

         if (resourceName == null)

         {

             return false;

         }

         // Check extension first as it's faster than mappings

         if (resourceName.endsWith(_extension))

         {

             // If the extension matches, it's a Facelet viewId.

             return true;

         }

         // Otherwise, try to match the view identifier with the facelet mappings

         return _acceptPatterns != null && _acceptPatterns.matcher(resourceName).matches();

     }

     public boolean containsFunction(String ns, String name)

     {

         // Composite component tag library does not suport functions

         return false;

     }

     public boolean containsNamespace(String ns)

     {

         if (ns != null && ns.startsWith(_namespacePrefix))

         {

             if (ns.length() > _namespacePrefix.length())

             {

                 String libraryName = ns.substring(_namespacePrefix.length());

                 return _resourceHandler.libraryExists(libraryName);

             }

         }        

         return false;

     }

     public boolean containsTagHandler(String ns, String localName)

     {

         if (ns != null && ns.startsWith(_namespacePrefix))

         {

             if (ns.length() > _namespacePrefix.length())

             {

                 String libraryName = ns.substring(_namespacePrefix.length());

                 for (String defaultSuffix : _defaultSuffixesArray)

                 {

                     String resourceName = localName + defaultSuffix;

                     if (handles(resourceName))

                     {

                         Resource compositeComponentResource = 

                             _resourceHandler.createResource(resourceName, libraryName);

                         if (compositeComponentResource != null)

                         {

                             URL url = compositeComponentResource.getURL();

                             return (url != null);

                         }

                     }

                 }

             }

         }

         return false;

     }

     public Method createFunction(String ns, String name)

     {

         // Composite component tag library does not suport functions

         return null;

     }

     public TagHandler createTagHandler(String ns, String localName,

             TagConfig tag) throws FacesException

     {

         if (ns != null && ns.startsWith(_namespacePrefix))

         {

             if (ns.length() > _namespacePrefix.length())

             {

                 String libraryName = ns.substring(_namespacePrefix.length());

                 for (String defaultSuffix : _defaultSuffixesArray)

                 {

                     String resourceName = localName + defaultSuffix;

                     if (handles(resourceName))

                     {

                         // MYFACES-3308 If a composite component exists, it requires to 

                         // be always resolved. In other words, it should always exists a default.

                         // The call here for resourceHandler.createResource, just try to get

                         // the Resource and if it does not exists, it just returns null.

                         // The intention of this code is just create an instance and pass to

                         // CompositeComponentResourceTagHandler. Then, its values 

                         // (resourceName, libraryName) will be used to derive the real instance

                         // to use in a view, based on the locale used.

                         Resource compositeComponentResourceWrapped

                                 = _resourceHandler.createResource(resourceName, libraryName);

                         if (compositeComponentResourceWrapped != null)

                         {

                             Resource compositeComponentResource

                                     = new CompositeResouceWrapper(compositeComponentResourceWrapped);

                             ComponentConfig componentConfig = new ComponentConfigWrapper(tag,

                                     "javax.faces.NamingContainer", null);

                             return new CompositeComponentResourceTagHandler(componentConfig,

                                                                             compositeComponentResource);

                         }

                     }

                 }

             }

         }

         return null;

     }

     private static class ComponentConfigWrapper implements ComponentConfig

     {

         protected final TagConfig parent;

         protected final String componentType;

         protected final String rendererType;

         public ComponentConfigWrapper(TagConfig parent, String componentType,

                                       String rendererType)

         {

             this.parent = parent;

             this.componentType = componentType;

             this.rendererType = rendererType;

         }

         public String getComponentType()

         {

             return this.componentType;

         }

         public String getRendererType()

         {

             return this.rendererType;

         }

         public FaceletHandler getNextHandler()

         {

             return this.parent.getNextHandler();

         }

         public Tag getTag()

         {

             return this.parent.getTag();

         }

         public String getTagId()

         {

             return this.parent.getTagId();

         }

     }

 }