/*
    * 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.shared.resource;
  
  import java.io.InputStream;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.util.Iterator;
  import java.util.Set;
  import java.util.regex.Pattern;
  
  import javax.faces.context.FacesContext;
  
  /**
   * A resource loader implementation which loads resources from the webapp root. It uses the methods on ExternalContext
   * for handle resources.
   * 
   */
  public class ExternalContextResourceLoader extends ResourceLoader
  {
      /**
       * It checks version like this: /1/, /1_0/, /1_0_0/, /100_100/
       * 
       * Used on getLibraryVersion to filter resource directories
       **/
      protected static final Pattern VERSION_CHECKER = Pattern.compile("/\\p{Digit}+(_\\p{Digit}*)*/");
  
      /**
       * It checks version like this: /1.js, /1_0.js, /1_0_0.js, /100_100.js
       * 
       * Used on getResourceVersion to filter resources
       **/
      protected static final Pattern RESOURCE_VERSION_CHECKER = Pattern.compile("/\\p{Digit}+(_\\p{Digit}*)*\\..*");
  
      public ExternalContextResourceLoader(String prefix)
      {
          super(prefix);
      }
  
      protected Set<String> getResourcePaths(String path)
      {
          return FacesContext.getCurrentInstance().getExternalContext().getResourcePaths(getPrefix() + '/' + path);
      }
  
      @Override
      public String getResourceVersion(String path)
      {
          String resourceVersion = null;
          Set<String> resourcePaths = this.getResourcePaths(path);
          if (getPrefix() != null)
          {
              path = getPrefix() + '/' + path;
          }
  
          if (null != resourcePaths && !resourcePaths.isEmpty())
          {
              // resourceVersion = // execute the comment
              // Look in the resourcePaths for versioned resources.
              // If one or more versioned resources are found, take
              // the one with the "highest" version number as the value
              // of resourceVersion. If no versioned libraries
              // are found, let resourceVersion remain null.
              for (String resourcePath : resourcePaths)
              {
                  String version = "";
                  if (path.length() < resourcePath.length()) 
                  {
                      version = resourcePath.substring(path.length());
                  }
  
                  if (RESOURCE_VERSION_CHECKER.matcher(version).matches())
                  {
                      version = version.substring(1, version.lastIndexOf('.'));
                      if (resourceVersion == null)
                      {
                          resourceVersion = version;
                      }
                      else if (getVersionComparator().compare(resourceVersion, version) < 0)
                      {
                          resourceVersion = version;
                      }
                  }
              }
             //Since it is a directory and no version was found, set as invalid
             if (resourceVersion == null)
             {
                 resourceVersion = VERSION_INVALID;
             }
         }
         return resourceVersion;
     }
 
     @Override
     public String getLibraryVersion(String path)
     {
         String libraryVersion = null;
         Set<String> libraryPaths = this.getResourcePaths(path);
         path = getPrefix() + '/' + path;
         if (null != libraryPaths && !libraryPaths.isEmpty())
         {
             // Look in the libraryPaths for versioned libraries.
             // If one or more versioned libraries are found, take
             // the one with the "highest" version number as the value
             // of libraryVersion. If no versioned libraries
             // are found, let libraryVersion remain null.
 
             for (Iterator<String> it = libraryPaths.iterator(); it.hasNext();)
             {
                 String libraryPath = it.next();
                 String version = "";
                 if (path.length() < libraryPath.length())
                 {
                     version = libraryPath.substring(path.length());
                 }
 
                 if (VERSION_CHECKER.matcher(version).matches())
                 {
                     version = version.substring(1, version.length() - 1);
                     if (libraryVersion == null)
                     {
                         libraryVersion = version;
                     }
                     else if (getVersionComparator().compare(libraryVersion, version) < 0)
                     {
                         libraryVersion = version;
                     }
                 }
             }
         }
         return libraryVersion;
     }
 
     //@Override
     public URL getResourceURL(String resourceId)
     {
         try
         {
             return FacesContext.getCurrentInstance().getExternalContext().getResource(
                 getPrefix() + '/' + resourceId);
         }
         catch (MalformedURLException e)
         {
             return null;
         }
     }
     
     @Override
     public URL getResourceURL(ResourceMeta resourceMeta)
     {
         return getResourceURL(resourceMeta.getResourceIdentifier());
     }
 
     @Override
     public InputStream getResourceInputStream(ResourceMeta resourceMeta)
     {
         return FacesContext.getCurrentInstance().getExternalContext().getResourceAsStream(
             getPrefix() + '/' + resourceMeta.getResourceIdentifier());
     }
 
     @Override
     public ResourceMeta createResourceMeta(String prefix, String libraryName, String libraryVersion,
                                            String resourceName, String resourceVersion)
     {
         return new ResourceMetaImpl(prefix, libraryName, libraryVersion, resourceName, resourceVersion);
     }
 
     @Override
     public boolean libraryExists(String libraryName)
     {
         if (getPrefix() != null && !"".equals(getPrefix()))
         {
             try
             {
                 URL url =
                     FacesContext.getCurrentInstance().getExternalContext().getResource(
                         getPrefix() + '/' + libraryName);
                 if (url != null)
                 {
                     return true;
                 }
             }
             catch (MalformedURLException e)
             {
                 return false;
             }
         }
         else
         {
             try
             {
 
                 URL url = FacesContext.getCurrentInstance().getExternalContext().getResource(libraryName);
 
                 if (url != null)
                 {
                     return true;
                 }
             }
             catch (MalformedURLException e)
             {
                 return false;
             }
         }
         return false;
     }
 }