/*

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

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

 import org.apache.myfaces.shared.resource.ResourceHandlerCache;

 import org.apache.myfaces.shared.resource.ResourceHandlerCache.ResourceValue;

 import org.apache.myfaces.shared.resource.ResourceHandlerSupport;

 import org.apache.myfaces.shared.resource.ResourceImpl;

 import org.apache.myfaces.shared.resource.ResourceLoader;

 import org.apache.myfaces.shared.resource.ResourceMeta;

 import org.apache.myfaces.shared.resource.ResourceValidationUtils;

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

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

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

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

 import javax.faces.application.Resource;

 import javax.faces.application.ResourceHandler;

 import javax.faces.application.ResourceWrapper;

 import javax.faces.context.ExternalContext;

 import javax.faces.context.FacesContext;

 import javax.servlet.http.HttpServletResponse;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.OutputStream;

 import java.util.List;

 import java.util.Locale;

 import java.util.Map;

 import java.util.MissingResourceException;

 import java.util.ResourceBundle;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import java.util.regex.Pattern;

 import org.apache.myfaces.shared.resource.ContractResource;

 import org.apache.myfaces.shared.resource.ContractResourceLoader;

 import org.apache.myfaces.shared.resource.ResourceCachedInfo;

 /**

  * DOCUMENT ME!

  *

  * @author Simon Lessard (latest modification by $Author$)

  * 

  * @version $Revision$ $Date$

  */

 public class ResourceHandlerImpl extends ResourceHandler

 {

     private static final String IS_RESOURCE_REQUEST = "org.apache.myfaces.IS_RESOURCE_REQUEST";

     private ResourceHandlerSupport _resourceHandlerSupport;

     private ResourceHandlerCache _resourceHandlerCache;

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

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

     /**

      * Allow slash in the library name of a Resource. 

      */

     @JSFWebConfigParam(since="2.1.6, 2.0.12", defaultValue="false", 

             expectedValues="true, false", group="resources")

     public static final String INIT_PARAM_STRICT_JSF_2_ALLOW_SLASH_LIBRARY_NAME = 

             "org.apache.myfaces.STRICT_JSF_2_ALLOW_SLASH_LIBRARY_NAME";

     public static final boolean INIT_PARAM_STRICT_JSF_2_ALLOW_SLASH_LIBRARY_NAME_DEFAULT = false;

     /**

      * Define the default buffer size that is used between Resource.getInputStream() and 

      * httpServletResponse.getOutputStream() when rendering resources using the default

      * ResourceHandler.

      */

     @JSFWebConfigParam(since="2.1.10, 2.0.16", defaultValue="2048", group="resources")

     public static final String INIT_PARAM_RESOURCE_BUFFER_SIZE = "org.apache.myfaces.RESOURCE_BUFFER_SIZE";

     public static final int INIT_PARAM_RESOURCE_BUFFER_SIZE_DEFAULT = 2048;

     public static final Pattern LIBRARY_VERSION_CHECKER = Pattern.compile("\\p{Digit}+(_\\p{Digit}*)*");

     public static final Pattern RESOURCE_VERSION_CHECKER = Pattern.compile("\\p{Digit}+(_\\p{Digit}*)*\\..*");    

     private Boolean _allowSlashLibraryName;

     private int _resourceBufferSize = -1;

     private String[] _excludedResourceExtensions;

     @Override

     public Resource createResource(String resourceName)

     {

         return createResource(resourceName, null);

     }

     @Override

     public Resource createResource(String resourceName, String libraryName)

     {

         return createResource(resourceName, libraryName, null);

     }

     @Override

     public Resource createResource(String resourceName, String libraryName,

             String contentType)

     {

         Resource resource = null;

         if (resourceName == null || resourceName.length() == 0) 

         {

             return null;

         }

         if (resourceName.charAt(0) == '/')

         {

             // If resourceName starts with '/', remove that character because it

             // does not have any meaning (with and without should point to the 

             // same resource).

             resourceName = resourceName.substring(1);

         }        

         if (!ResourceValidationUtils.isValidResourceName(resourceName))

         {

             return null;

         }

         if (libraryName != null && !ResourceValidationUtils.isValidLibraryName(

                 libraryName, isAllowSlashesLibraryName()))

         {

             return null;

         }

         FacesContext facesContext = FacesContext.getCurrentInstance();

         if (contentType == null)

         {

             //Resolve contentType using ExternalContext.getMimeType

             contentType = facesContext.getExternalContext().getMimeType(resourceName);

         }

         final String localePrefix = getLocalePrefixForLocateResource(facesContext);

         final List<String> contracts = facesContext.getResourceLibraryContracts(); 

         String contractPreferred = getContractNameForLocateResource(facesContext);

         ResourceValue resourceValue = null;

         // Check cache:

         //

         // Contracts are on top of everything, because it is a concept that defines

         // resources in a application scope concept. It means all resources in

         // /resources or /META-INF/resources can be overriden using a contract. Note

         // it also means resources under /META-INF/flows can also be overriden using

         // a contract.

         // Check first the preferred contract if any. If not found, try the remaining

         // contracts and finally if not found try to found a resource without a 

         // contract name.

         if (contractPreferred != null)

         {

             resourceValue = getResourceLoaderCache().getResource(

                     resourceName, libraryName, contentType, localePrefix, contractPreferred);

         }

         if (resourceValue == null && !contracts.isEmpty())

         {

             // Try to get resource but try with a contract name

             for (String contract : contracts)

             {

                 resourceValue = getResourceLoaderCache().getResource(

                     resourceName, libraryName, contentType, localePrefix, contract);

                 if (resourceValue != null)

                 {

                     break;

                 }

             }

         }

         // Only if no contract preferred try without it.

         if (resourceValue == null)

         {

             // Try to get resource without contract name

             resourceValue = getResourceLoaderCache().getResource(resourceName, libraryName, contentType, localePrefix);

         }

         if(resourceValue != null)

         {

             resource = new ResourceImpl(resourceValue.getResourceMeta(), resourceValue.getResourceLoader(),

                     getResourceHandlerSupport(), contentType, 

                     resourceValue.getCachedInfo() != null ? resourceValue.getCachedInfo().getURL() : null, 

                     resourceValue.getCachedInfo() != null ? resourceValue.getCachedInfo().getRequestPath() : null);

         }

         else

         {

             boolean resolved = false;

             // Try preferred contract first

             if (contractPreferred != null)

             {

                 for (ContractResourceLoader loader : getResourceHandlerSupport().getContractResourceLoaders())

                 {

                     ResourceMeta resourceMeta = deriveResourceMeta(loader, resourceName, libraryName, 

                         localePrefix, contractPreferred);

                     if (resourceMeta != null)

                     {

                         resource = new ResourceImpl(resourceMeta, loader, 

                             getResourceHandlerSupport(), contentType);

                         // cache it

                         getResourceLoaderCache().putResource(resourceName, libraryName, contentType,

                                 localePrefix, contractPreferred, resourceMeta, loader, 

                                 new ResourceCachedInfo(resource.getURL(), resource.getRequestPath()));

                         resolved = true;

                         break;

                     }

                 }

             }

             if (!resolved && !contracts.isEmpty())

             {

                 for (ContractResourceLoader loader : 

                     getResourceHandlerSupport().getContractResourceLoaders())

                 {

                     for (String contract : contracts)

                     {

                         ResourceMeta resourceMeta = deriveResourceMeta(

                             loader, resourceName, libraryName, 

                             localePrefix, contract);

                         if (resourceMeta != null)

                         {

                             resource = new ResourceImpl(resourceMeta, loader, 

                                 getResourceHandlerSupport(), contentType);

                             // cache it

                             getResourceLoaderCache().putResource(

                                     resourceName, libraryName, contentType,

                                     localePrefix, contract, resourceMeta, loader,

                                     new ResourceCachedInfo(resource.getURL(), resource.getRequestPath()));

                             resolved = true;

                             break;

                         }

                     }

                 }

             }

             if (!resolved)

             {

                 for (ResourceLoader loader : getResourceHandlerSupport().getResourceLoaders())

                 {

                     ResourceMeta resourceMeta = deriveResourceMeta(

                         loader, resourceName, libraryName, localePrefix);

                     if (resourceMeta != null)

                     {

                         resource = new ResourceImpl(

                             resourceMeta, loader, getResourceHandlerSupport(), contentType);

                         // cache it

                         getResourceLoaderCache().putResource(resourceName, libraryName, contentType,

                                 localePrefix, null, resourceMeta, loader, 

                                 new ResourceCachedInfo(resource.getURL(), resource.getRequestPath()));

                         break;

                     }

                 }

             }

         }

         return resource;

     }

     protected ResourceMeta deriveResourceMeta(ContractResourceLoader resourceLoader,

             String resourceName, String libraryName, String localePrefix, String contractName)

     {

         String resourceVersion = null;

         String libraryVersion = null;

         ResourceMeta resourceId = null;

         //1. Try to locate resource in a localized path

         if (localePrefix != null)

         {

             if (null != libraryName)

             {

                 String pathToLib = localePrefix + '/' + libraryName;

                 libraryVersion = resourceLoader.getLibraryVersion(pathToLib, contractName);

                 if (null != libraryVersion)

                 {

                     String pathToResource = localePrefix + '/'

                             + libraryName + '/' + libraryVersion + '/'

                             + resourceName;

                     resourceVersion = resourceLoader

                             .getResourceVersion(pathToResource, contractName);

                 }

                 else

                 {

                     String pathToResource = localePrefix + '/'

                             + libraryName + '/' + resourceName;

                     resourceVersion = resourceLoader

                             .getResourceVersion(pathToResource, contractName);

                 }

                 if (!(resourceVersion != null && ResourceLoader.VERSION_INVALID.equals(resourceVersion)))

                 {

                     resourceId = resourceLoader.createResourceMeta(localePrefix, libraryName,

                             libraryVersion, resourceName, resourceVersion, contractName);

                 }

             }

             else

             {

                 resourceVersion = resourceLoader

                         .getResourceVersion(localePrefix + '/'+ resourceName, contractName);

                 if (!(resourceVersion != null && ResourceLoader.VERSION_INVALID.equals(resourceVersion)))

                 {               

                     resourceId = resourceLoader.createResourceMeta(localePrefix, null, null,

                             resourceName, resourceVersion, contractName);

                 }

             }

             if (resourceId != null && !resourceLoader.resourceExists(resourceId))

             {

                 resourceId = null;

             }            

         }

         //2. Try to localize resource in a non localized path

         if (resourceId == null)

         {

             if (null != libraryName)

             {

                 libraryVersion = resourceLoader.getLibraryVersion(libraryName, contractName);

                 if (null != libraryVersion)

                 {

                     String pathToResource = (libraryName + '/' + libraryVersion

                             + '/' + resourceName);

                     resourceVersion = resourceLoader

                             .getResourceVersion(pathToResource, contractName);

                 }

                 else

                 {

                     String pathToResource = (libraryName + '/'

                             + resourceName);

                     resourceVersion = resourceLoader

                             .getResourceVersion(pathToResource, contractName);

                 }

                 if (!(resourceVersion != null && ResourceLoader.VERSION_INVALID.equals(resourceVersion)))

                 {               

                     resourceId = resourceLoader.createResourceMeta(null, libraryName,

                             libraryVersion, resourceName, resourceVersion, contractName);

                 }

             }

             else

             {

                 resourceVersion = resourceLoader

                         .getResourceVersion(resourceName, contractName);

                 if (!(resourceVersion != null && ResourceLoader.VERSION_INVALID.equals(resourceVersion)))

                 {               

                     resourceId = resourceLoader.createResourceMeta(null, null, null,

                             resourceName, resourceVersion, contractName);

                 }

             }

             if (resourceId != null && !resourceLoader.resourceExists(resourceId))

             {

                 resourceId = null;

             }            

         }

         return resourceId;

     }

     /**

      * This method try to create a ResourceMeta for a specific resource

      * loader. If no library, or resource is found, just return null,

      * so the algorithm in createResource can continue checking with the 

      * next registered ResourceLoader. 

      */

     protected ResourceMeta deriveResourceMeta(ResourceLoader resourceLoader,

             String resourceName, String libraryName, String localePrefix)

     {

         String resourceVersion = null;

         String libraryVersion = null;

         ResourceMeta resourceId = null;

         //1. Try to locate resource in a localized path

         if (localePrefix != null)

         {

             if (null != libraryName)

             {

                 String pathToLib = localePrefix + '/' + libraryName;

                 libraryVersion = resourceLoader.getLibraryVersion(pathToLib);

                 if (null != libraryVersion)

                 {

                     String pathToResource = localePrefix + '/'

                             + libraryName + '/' + libraryVersion + '/'

                             + resourceName;

                     resourceVersion = resourceLoader

                             .getResourceVersion(pathToResource);

                 }

                 else

                 {

                     String pathToResource = localePrefix + '/'

                             + libraryName + '/' + resourceName;

                     resourceVersion = resourceLoader

                             .getResourceVersion(pathToResource);

                 }

                 if (!(resourceVersion != null && ResourceLoader.VERSION_INVALID.equals(resourceVersion)))

                 {

                     resourceId = resourceLoader.createResourceMeta(localePrefix, libraryName,

                             libraryVersion, resourceName, resourceVersion);

                 }

             }

             else

             {

                 resourceVersion = resourceLoader

                         .getResourceVersion(localePrefix + '/'+ resourceName);

                 if (!(resourceVersion != null && ResourceLoader.VERSION_INVALID.equals(resourceVersion)))

                 {               

                     resourceId = resourceLoader.createResourceMeta(localePrefix, null, null,

                             resourceName, resourceVersion);

                 }

             }

             if (resourceId != null && !resourceLoader.resourceExists(resourceId))

             {

                 resourceId = null;

             }            

         }

         //2. Try to localize resource in a non localized path

         if (resourceId == null)

         {

             if (null != libraryName)

             {

                 libraryVersion = resourceLoader.getLibraryVersion(libraryName);

                 if (null != libraryVersion)

                 {

                     String pathToResource = (libraryName + '/' + libraryVersion

                             + '/' + resourceName);

                     resourceVersion = resourceLoader

                             .getResourceVersion(pathToResource);

                 }

                 else

                 {

                     String pathToResource = (libraryName + '/'

                             + resourceName);

                     resourceVersion = resourceLoader

                             .getResourceVersion(pathToResource);

                 }

                 if (!(resourceVersion != null && ResourceLoader.VERSION_INVALID.equals(resourceVersion)))

                 {               

                     resourceId = resourceLoader.createResourceMeta(null, libraryName,

                             libraryVersion, resourceName, resourceVersion);

                 }

             }

             else

             {

                 resourceVersion = resourceLoader

                         .getResourceVersion(resourceName);

                 if (!(resourceVersion != null && ResourceLoader.VERSION_INVALID.equals(resourceVersion)))

                 {               

                     resourceId = resourceLoader.createResourceMeta(null, null, null,

                             resourceName, resourceVersion);

                 }

             }

             if (resourceId != null && !resourceLoader.resourceExists(resourceId))

             {

                 resourceId = null;

             }            

         }

         return resourceId;

     }

     @Override

     public String getRendererTypeForResourceName(String resourceName)

     {

         if (resourceName.endsWith(".js"))

         {

             return "javax.faces.resource.Script";

         }

         else if (resourceName.endsWith(".css"))

         {

             return "javax.faces.resource.Stylesheet";

         }

         return null;

     }

     /**

      *  Handle the resource request, writing in the output. 

      *  

      *  This method implements an algorithm semantically identical to 

      *  the one described on the javadoc of ResourceHandler.handleResourceRequest 

      */

     @Override

     public void handleResourceRequest(FacesContext facesContext) throws IOException

     {

         //try

         //{

             String resourceBasePath = getResourceHandlerSupport()

                     .calculateResourceBasePath(facesContext);

             if (resourceBasePath == null)

             {

                 // No base name could be calculated, so no further

                 //advance could be done here. HttpServletResponse.SC_NOT_FOUND

                 //cannot be returned since we cannot extract the 

                 //resource base name

                 return;

             }

             // We neet to get an instance of HttpServletResponse, but sometimes

             // the response object is wrapped by several instances of 

             // ServletResponseWrapper (like ResponseSwitch).

             // Since we are handling a resource, we can expect to get an 

             // HttpServletResponse.

             ExternalContext extContext = facesContext.getExternalContext();

             Object response = extContext.getResponse();

             HttpServletResponse httpServletResponse = ExternalContextUtils.getHttpServletResponse(response);

             if (httpServletResponse == null)

             {

                 throw new IllegalStateException("Could not obtain an instance of HttpServletResponse.");

             }

             if (isResourceIdentifierExcluded(facesContext, resourceBasePath))

             {

                 httpServletResponse.setStatus(HttpServletResponse.SC_NOT_FOUND);

                 return;

             }

             String resourceName = null;

             if (resourceBasePath.startsWith(ResourceHandler.RESOURCE_IDENTIFIER))

             {

                 resourceName = resourceBasePath

                         .substring(ResourceHandler.RESOURCE_IDENTIFIER.length() + 1);

                 if (resourceBasePath != null && !ResourceValidationUtils.isValidResourceName(resourceName))

                 {

                     httpServletResponse.setStatus(HttpServletResponse.SC_NOT_FOUND);

                     return;

                 }

             }

             else

             {

                 //Does not have the conditions for be a resource call

                 httpServletResponse.setStatus(HttpServletResponse.SC_NOT_FOUND);

                 return;

             }

             String libraryName = facesContext.getExternalContext()

                     .getRequestParameterMap().get("ln");

             if (libraryName != null && !ResourceValidationUtils.isValidLibraryName(

                     libraryName, isAllowSlashesLibraryName()))

             {

                 httpServletResponse.setStatus(HttpServletResponse.SC_NOT_FOUND);

                 return;

             }

             Resource resource = null;

             if (libraryName != null)

             {

                 //log.info("libraryName=" + libraryName);

                 resource = facesContext.getApplication().getResourceHandler().createResource(resourceName, libraryName);

             }

             else

             {

                 resource = facesContext.getApplication().getResourceHandler().createResource(resourceName);

             }

             if (resource == null)

             {

                 httpServletResponse.setStatus(HttpServletResponse.SC_NOT_FOUND);

                 return;

             }

             if (!resource.userAgentNeedsUpdate(facesContext))

             {

                 httpServletResponse.setStatus(HttpServletResponse.SC_NOT_MODIFIED);

                 return;

             }

             httpServletResponse.setContentType(_getContentType(resource, facesContext.getExternalContext()));

             Map<String, String> headers = resource.getResponseHeaders();

             for (Map.Entry<String, String> entry : headers.entrySet())

             {

                 httpServletResponse.setHeader(entry.getKey(), entry.getValue());

             }

             // Sets the preferred buffer size for the body of the response

             extContext.setResponseBufferSize(this.getResourceBufferSize());

             //serve up the bytes (taken from trinidad ResourceServlet)

             try

             {

                 InputStream in = resource.getInputStream();

                 OutputStream out = httpServletResponse.getOutputStream();

                 //byte[] buffer = new byte[_BUFFER_SIZE];

                 byte[] buffer = new byte[this.getResourceBufferSize()];

                 try

                 {

                     int count = pipeBytes(in, out, buffer);

                     //set the content lenght

                     if (!httpServletResponse.isCommitted())

                     {

                         httpServletResponse.setContentLength(count);

                     }

                 }

                 finally

                 {

                     try

                     {

                         in.close();

                     }

                     finally

                     {

                         out.close();

                     }

                 }

             }

             catch (IOException e)

             {

                 //TODO: Log using a localized message (which one?)

                 if (isConnectionAbort(e))

                 {

                     log.log(Level.INFO,"Connection was aborted while loading resource " + resourceName

                             + " with library " + libraryName);

                 }

                 else

                 {

                     if (log.isLoggable(Level.WARNING))

                     {

                         log.log(Level.WARNING,"Error trying to load and send resource " + resourceName

                                 + " with library " + libraryName + " :"

                                 + e.getMessage(), e);

                     }

                     httpServletResponse.setStatus(HttpServletResponse.SC_NOT_FOUND);

                 }

             }

         //}

         //catch (Throwable ex)

         //{

             // handle the Throwable accordingly. Maybe generate an error page.

             // FIXME we are creating a html error page for a non html request here

             // shouln't we do something better? -=Jakob Korherr=-

             //ErrorPageWriter.handleThrowable(facesContext, ex);

         //}

     }

     private static boolean isConnectionAbort(IOException e)

     {

         return e.getClass().getCanonicalName().equals("org.apache.catalina.connector.ClientAbortException");

     }

     /**

      * Reads the specified input stream into the provided byte array storage and

      * writes it to the output stream.

      */

     private static int pipeBytes(InputStream in, OutputStream out, byte[] buffer)

             throws IOException

     {

         int count = 0;

         int length;

         while ((length = (in.read(buffer))) >= 0)

         {

             out.write(buffer, 0, length);

             count += length;

         }

         return count;

     }

     @Override

     public boolean isResourceRequest(FacesContext facesContext)

     {

         // Since this method could be called many times we save it

         // on request map so the first time is calculated it remains

         // alive until the end of the request

         Boolean value = (Boolean) facesContext.getAttributes().get(IS_RESOURCE_REQUEST);

         if (value == null)

         {

             String resourceBasePath = getResourceHandlerSupport()

                     .calculateResourceBasePath(facesContext);

             value = resourceBasePath != null

                     && resourceBasePath.startsWith(ResourceHandler.RESOURCE_IDENTIFIER);

             facesContext.getAttributes().put(IS_RESOURCE_REQUEST, value);

         }

         return value;

     }

     protected String getLocalePrefixForLocateResource()

     {

         return getLocalePrefixForLocateResource(FacesContext.getCurrentInstance());

     }

     protected String getLocalePrefixForLocateResource(FacesContext context)

     {

         String localePrefix = null;

         boolean isResourceRequest = context.getApplication().getResourceHandler().isResourceRequest(context);

         if (isResourceRequest)

         {

             localePrefix = context.getExternalContext().getRequestParameterMap().get("loc");

             if (localePrefix != null)

             {

                 if (!ResourceValidationUtils.isValidLocalePrefix(localePrefix))

                 {

                     return null;

                 }

                 return localePrefix;

             }

         }

         String bundleName = context.getApplication().getMessageBundle();

         if (null != bundleName)

         {

             Locale locale = null;

             if (isResourceRequest || context.getViewRoot() == null)

             {

                 locale = context.getApplication().getViewHandler()

                                 .calculateLocale(context);

             }

             else

             {

                 locale = context.getViewRoot().getLocale();

             }

             try

             {

                 ResourceBundle bundle = ResourceBundle

                         .getBundle(bundleName, locale, ClassUtils.getContextClassLoader());

                 if (bundle != null)

                 {

                     if (bundle.containsKey(ResourceHandler.LOCALE_PREFIX))

                     {

                         localePrefix = bundle.getString(ResourceHandler.LOCALE_PREFIX);

                     }

                 }

             }

             catch (MissingResourceException e)

             {

                 // Ignore it and return null

             }

         }

         return localePrefix;

     }

     protected String getContractNameForLocateResource(FacesContext context)

     {

         String contractName = null;

         boolean isResourceRequest = context.getApplication().getResourceHandler().isResourceRequest(context);

         if (isResourceRequest)

         {

             contractName = context.getExternalContext().getRequestParameterMap().get("con");

         }

         // Check if the contract has been injected.

         if (contractName == null)

         {

             contractName = (String) context.getAttributes().get(ContractResource.CONTRACT_SELECTED);

         }

         //Validate

         if (contractName != null &&

             !ResourceValidationUtils.isValidContractName(contractName))

         {

             return null;

         }

         return contractName;

     }

     protected boolean isResourceIdentifierExcluded(FacesContext context, String resourceIdentifier)

     {

         if (_excludedResourceExtensions == null)

         {

             String value = WebConfigParamUtils.getStringInitParameter(context.getExternalContext(),

                             RESOURCE_EXCLUDES_PARAM_NAME,

                             RESOURCE_EXCLUDES_DEFAULT_VALUE);

             _excludedResourceExtensions = StringUtils.splitShortString(value, ' ');

         }

         for (int i = 0; i < _excludedResourceExtensions.length; i++)

         {

             if (resourceIdentifier.endsWith(_excludedResourceExtensions[i]))

             {

                 return true;

             }

         }

         return false;

     }

     /**

      * Check if a library exists or not. This is done delegating

      * to each ResourceLoader used, because each one has a different

      * prefix and way to load resources.

      * 

      */

     @Override

     public boolean libraryExists(String libraryName)

     {

         FacesContext facesContext = FacesContext.getCurrentInstance();

         String localePrefix = getLocalePrefixForLocateResource(facesContext);

         final List<String> contracts = facesContext.getResourceLibraryContracts(); 

         String pathToLib = null;

         Boolean libraryFound = null;

         if (libraryName != null && !ResourceValidationUtils.isValidLibraryName(

                 libraryName, isAllowSlashesLibraryName()))

         {

             return false;

         }

         if (localePrefix != null)

         {

             //Check with locale

             pathToLib = localePrefix + '/' + libraryName;

             libraryFound = getResourceLoaderCache().libraryExists(pathToLib);

             if (libraryFound != null)

             {

                 return libraryFound.booleanValue();

             }

         }

         libraryFound = getResourceLoaderCache().libraryExists(libraryName);

         if (libraryFound != null)

         {

             return libraryFound.booleanValue();

         }

         if (localePrefix != null)

         {

             if (!contracts.isEmpty())

             {

                 for (String contract : contracts)

                 {

                     for (ContractResourceLoader loader : getResourceHandlerSupport()

                             .getContractResourceLoaders())

                     {

                         if (loader.libraryExists(pathToLib, contract))

                         {

                             getResourceLoaderCache().confirmLibraryExists(pathToLib);

                             return true;

                         }

                     }

                 }

             }

             for (ResourceLoader loader : getResourceHandlerSupport()

                     .getResourceLoaders())

             {

                 if (loader.libraryExists(pathToLib))

                 {

                     getResourceLoaderCache().confirmLibraryExists(pathToLib);

                     return true;

                 }

             }            

         }

         //Check without locale

         if (!contracts.isEmpty())

         {

             for (String contract : contracts)

             {

                 for (ContractResourceLoader loader : getResourceHandlerSupport()

                         .getContractResourceLoaders())

                 {

                     if (loader.libraryExists(libraryName, contract))

                     {

                         getResourceLoaderCache().confirmLibraryExists(libraryName);

                         return true;

                     }

                 }

             }

         }

         for (ResourceLoader loader : getResourceHandlerSupport()

                 .getResourceLoaders())

         {

             if (loader.libraryExists(libraryName))

             {

                 getResourceLoaderCache().confirmLibraryExists(libraryName);

                 return true;

             }

         }

         if (localePrefix != null)

         {

             //Check with locale

             getResourceLoaderCache().confirmLibraryNotExists(pathToLib);

         }

         else

         {

             getResourceLoaderCache().confirmLibraryNotExists(libraryName);

         }

         return false;

     }

     /**

      * @param resourceHandlerSupport

      *            the resourceHandlerSupport to set

      */

     public void setResourceHandlerSupport(

             ResourceHandlerSupport resourceHandlerSupport)

     {

         _resourceHandlerSupport = resourceHandlerSupport;

     }

     /**

      * @return the resourceHandlerSupport

      */

     protected ResourceHandlerSupport getResourceHandlerSupport()

     {

         if (_resourceHandlerSupport == null)

         {

             _resourceHandlerSupport = new DefaultResourceHandlerSupport();

         }

         return _resourceHandlerSupport;

     }

     private ResourceHandlerCache getResourceLoaderCache()

     {

         if (_resourceHandlerCache == null)

         {

             _resourceHandlerCache = new ResourceHandlerCache();

         }

         return _resourceHandlerCache;

     }

     private String _getContentType(Resource resource, ExternalContext externalContext)

     {

         String contentType = resource.getContentType();

         // the resource does not provide a content-type --> determine it via mime-type

         if (contentType == null || contentType.length() == 0)

         {

             String resourceName = getWrappedResourceName(resource);

             if (resourceName != null)

             {

                 contentType = externalContext.getMimeType(resourceName);

             }

         }

         return contentType;

     }

     /**

      * Recursively unwarp the resource until we find the real resourceName

      * This is needed because the JSF2 specced ResourceWrapper doesn't override

      * the getResourceName() method :(

      * @param resource

      * @return the first non-null resourceName or <code>null</code> if none set

      */

     private String getWrappedResourceName(Resource resource)

     {

         String resourceName = resource.getResourceName();

         if (resourceName != null)

         {

             return resourceName;

         }

         if (resource instanceof ResourceWrapper)

         {

             return getWrappedResourceName(((ResourceWrapper) resource).getWrapped());

         }

         return null;

     }

     protected boolean isAllowSlashesLibraryName()

     {

         if (_allowSlashLibraryName == null)

         {

             _allowSlashLibraryName = WebConfigParamUtils.getBooleanInitParameter(

                     FacesContext.getCurrentInstance().getExternalContext(), 

                     INIT_PARAM_STRICT_JSF_2_ALLOW_SLASH_LIBRARY_NAME,

                     INIT_PARAM_STRICT_JSF_2_ALLOW_SLASH_LIBRARY_NAME_DEFAULT);

         }

         return _allowSlashLibraryName;

     }

     protected int getResourceBufferSize()

     {

         if (_resourceBufferSize == -1)

         {

             _resourceBufferSize = WebConfigParamUtils.getIntegerInitParameter(

                 FacesContext.getCurrentInstance().getExternalContext(),

                 INIT_PARAM_RESOURCE_BUFFER_SIZE,

                 INIT_PARAM_RESOURCE_BUFFER_SIZE_DEFAULT);

         }

         return _resourceBufferSize;

     }

     @Override

     public Resource createResourceFromId(String resourceId)

     {

         Resource resource = null;

         if (resourceId == null)

         {

             throw new NullPointerException();

         }

         // Later in deriveResourceMeta the resourceId is decomposed and

         // its elements validated properly.

         if (!ResourceValidationUtils.isValidResourceId(resourceId))

         {

             return null;

         }

         FacesContext facesContext = FacesContext.getCurrentInstance();

         final List<String> contracts = facesContext.getResourceLibraryContracts(); 

         String contractPreferred = getContractNameForLocateResource(facesContext);

         ResourceValue resourceValue = null;

         // Check cache:

         //

         // Contracts are on top of everything, because it is a concept that defines

         // resources in a application scope concept. It means all resources in

         // /resources or /META-INF/resources can be overriden using a contract. Note

         // it also means resources under /META-INF/flows can also be overriden using

         // a contract.

         if (contractPreferred != null)

         {

             resourceValue = getResourceLoaderCache().getResource(

                     resourceId, contractPreferred);

         }

         if (resourceValue == null && !contracts.isEmpty())

         {

             // Try to get resource but try with a contract name

             for (String contract : contracts)

             {

                 resourceValue = getResourceLoaderCache().getResource(resourceId, contract);

                 if (resourceValue != null)

                 {

                     break;

                 }

             }

         }

         if (resourceValue == null)

         {

             // Try to get resource without contract name

             resourceValue = getResourceLoaderCache().getResource(resourceId);

         }

         if(resourceValue != null)

         {        

             //Resolve contentType using ExternalContext.getMimeType

             String contentType = facesContext.getExternalContext().getMimeType(

                 resourceValue.getResourceMeta().getResourceName());

             resource = new ResourceImpl(resourceValue.getResourceMeta(), resourceValue.getResourceLoader(),

                     getResourceHandlerSupport(), contentType,

                     resourceValue.getCachedInfo() != null ? resourceValue.getCachedInfo().getURL() : null, 

                     resourceValue.getCachedInfo() != null ? resourceValue.getCachedInfo().getRequestPath() : null);

         }

         else

         {

             boolean resolved = false;

             if (contractPreferred != null)

             {

                 for (ContractResourceLoader loader : getResourceHandlerSupport().getContractResourceLoaders())

                 {

                     ResourceMeta resourceMeta = deriveResourceMeta(

                         facesContext, loader, resourceId, contractPreferred);

                     if (resourceMeta != null)

                     {

                         String contentType = facesContext.getExternalContext().getMimeType(

                             resourceMeta.getResourceName());

                         resource = new ResourceImpl(resourceMeta, loader, 

                             getResourceHandlerSupport(), contentType);

                         // cache it

                         getResourceLoaderCache().putResource(resourceId, resourceMeta, loader, 

                             new ResourceCachedInfo(resource.getURL(), resource.getRequestPath()));

                         resolved = true;

                         break;

                     }

                 }

             }

             if (!resolved && !contracts.isEmpty())

             {

                 for (ContractResourceLoader loader : 

                         getResourceHandlerSupport().getContractResourceLoaders())

                 {

                     for (String contract : contracts)

                     {

                         ResourceMeta resourceMeta = deriveResourceMeta(

                             facesContext, loader, resourceId, contract);

                         if (resourceMeta != null)

                         {

                             String contentType = facesContext.getExternalContext().getMimeType(

                                 resourceMeta.getResourceName());

                             resource = new ResourceImpl(resourceMeta, loader, 

                                 getResourceHandlerSupport(), contentType);

                             // cache it

                             getResourceLoaderCache().putResource(resourceId, resourceMeta, loader, 

                                 new ResourceCachedInfo(resource.getURL(), resource.getRequestPath()));

                             resolved = true;

                             break;

                         }

                     }

                 }

             }

             if (!resolved)

             {

                 for (ResourceLoader loader : getResourceHandlerSupport().getResourceLoaders())

                 {

                     ResourceMeta resourceMeta = deriveResourceMeta(facesContext, loader, resourceId);

                     if (resourceMeta != null)

                     {

                         String contentType = facesContext.getExternalContext().getMimeType(

                             resourceMeta.getResourceName());

                         resource = new ResourceImpl(resourceMeta, loader, getResourceHandlerSupport(), contentType);

                         // cache it

                         getResourceLoaderCache().putResource(resourceId, resourceMeta, loader, 

                             new ResourceCachedInfo(resource.getURL(), resource.getRequestPath()));

                         break;

                     }

                 }

             }

         }

         return resource;

     }

     protected ResourceMeta deriveResourceMeta(FacesContext context, ResourceLoader resourceLoader,

             String resourceId)

     {

         ResourceMeta resourceMeta = null;

         String token = null;

         String localePrefix = null;

         String libraryName = null;

         String libraryVersion = null;

         String resourceName = null;

         String resourceVersion = null;

         // Check if resource exists. It avoids additional 

         // checks and it can be done very quickly because the 

         // loader always uses the resourceId structure to

         // organize resources. But decompose the resourceId is

         // even faster.

         //if (resourceLoader.resourceIdExists(resourceId))

         //{

         int lastSlash = resourceId.lastIndexOf('/');

         if (lastSlash < 0)

         {

             //no slashes, so it is just a plain resource.

             resourceName = resourceId;

         }

         else

         {

             token = resourceId.substring(lastSlash+1);

             if (RESOURCE_VERSION_CHECKER.matcher(token).matches())

             {

                 int secondLastSlash = resourceId.lastIndexOf('/', lastSlash-1);

                 if (secondLastSlash < 0)

                 {

                     secondLastSlash = 0;

                 }

                 String rnToken = resourceId.substring(secondLastSlash+1, lastSlash);

                 int lastPoint = rnToken.lastIndexOf('.');

                 // lastPoint < 0 means it does not match, the token is not a resource version

                 if (lastPoint >= 0)

                 {

                     String ext = rnToken.substring(lastPoint);

                     if (token.endsWith(ext))

                     {

                         //It match a versioned resource

                         resourceVersion = token.substring(0,token.length()-ext.length());

                     }

                 }

             }

             // 1. Extract the library path and locale prefix if necessary

             int start = 0;

             int firstSlash = resourceId.indexOf('/');

             // At least one slash, check if the start is locale prefix.

             String bundleName = context.getApplication().getMessageBundle();

             //If no bundle set, it can't be localePrefix

             if (null != bundleName)

             {

                 token = resourceId.substring(start, firstSlash);

                 //Try to derive a locale object

                 Locale locale = _LocaleUtils.deriveLocale(token);

                 // If the locale was derived and it is available, 

                 // assume that portion of the resourceId it as a locale prefix.

                 if (locale != null && _LocaleUtils.isAvailableLocale(locale))

                 {

                     localePrefix = token;

                     start = firstSlash+1;

                 }

             }

             //Check slash again from start

             firstSlash = resourceId.indexOf('/', start);

             if (firstSlash < 0)

             {

                 //no slashes.

                 resourceName = resourceId.substring(start);

             }

             else

             {

                 //check libraryName

                 token = resourceId.substring(start, firstSlash);

                 int minResourceNameSlash = (resourceVersion != null) ?

                     resourceId.lastIndexOf('/', lastSlash-1) : lastSlash;

                 //if (resourceLoader.libraryExists(token))

                 if (start < minResourceNameSlash)

                 {

                     libraryName = token;

                     start = firstSlash+1;

                     //Now that libraryName exists, check libraryVersion

                     firstSlash = resourceId.indexOf('/', start);

                     if (firstSlash >= 0)

                     {

                         token = resourceId.substring(start, firstSlash);

                         if (LIBRARY_VERSION_CHECKER.matcher(token).matches())

                         {

                             libraryVersion = token;

                             start = firstSlash+1;

                         }

                     }

                 }

                 firstSlash = resourceId.indexOf('/', start);

                 if (firstSlash < 0)

                 {

                     //no slashes.

                     resourceName = resourceId.substring(start);

                 }

                 else

                 {

                     // Check resource version. 

                     if (resourceVersion != null)

                     {

                         resourceName = resourceId.substring(start,lastSlash);

                     }

                     else

                     {

                         //no resource version, assume the remaining to be resource name

                         resourceName = resourceId.substring(start);

                     }

                 }

             }

         }

         //Check libraryName and resourceName

         if (resourceName == null)

         {

             return null;

         }

         if (!ResourceValidationUtils.isValidResourceName(resourceName))

         {

             return null;

         }

         if (libraryName != null && !ResourceValidationUtils.isValidLibraryName(

                 libraryName, isAllowSlashesLibraryName()))

         {

             return null;

         }

         // If some variable is "" set it as null.

         if (localePrefix != null && localePrefix.length() == 0)

         {

             localePrefix = null;

         }

         if (libraryName != null && libraryName.length() == 0)

         {

             libraryName = null;