/**
    * Copyright (C) 2005-2009 Alfresco Software Limited.
    *
    * This file is part of the Spring Surf Extension project.
    *
    * Licensed 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.springframework.extensions.webscripts;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.Reader;
  import java.io.UnsupportedEncodingException;
  import java.net.JarURLConnection;
  import java.net.URL;
  import java.net.URLConnection;
  import java.util.ArrayList;
  import java.util.Enumeration;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Set;
  import java.util.jar.JarEntry;
  import java.util.jar.JarFile;
  
  import javax.servlet.ServletContext;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.ApplicationContextAware;
  import org.springframework.core.io.Resource;
  import org.springframework.extensions.surf.exception.WebScriptsPlatformException;
  import org.springframework.util.AntPathMatcher;
  import org.springframework.util.PathMatcher;
  import org.springframework.web.context.ServletContextAware;
  
  import freemarker.cache.TemplateLoader;
  
  
  /**
   * Read only store implementation that can be mounted against a
   * JAR file.  Works against the contents of the JAR file beginning
   * at a specified path.
   * 
   * This is used to prepackage assets into JAR files for ease of
   * build and distribution into external web applications
   * (via Maven).
   * 
   * As with any Store, the interface methods deal principally with
   * document paths.  Document paths are assumed to be relative to
   * the root path.
   * 
   * In this case, all of the JAR file entries under the root path 
   * are considered to be Store contents.  The paths to these jar 
   * entries are determined by combining the root path with the 
   * document path.
   * 
   * An example of a relative path:
   * 
   *    org/alfresco/web/example/template.ftl
   *    
   * An example of an absolute path:
   * 
   *    META-INF/org/alfresco/web/example/template.ftl
   *    
   * Where the root path is "META-INF/"
   *
   * @author muzquiano
   */
  public class JarStore extends AbstractStore implements Store, ServletContextAware, ApplicationContextAware
  {
      public static final String JAR_PROTOCOL = "jar";
  
      private static final Log logger = LogFactory.getLog(JarStore.class);
  
      protected boolean mustExist = false;
      protected boolean exists = false;
      
      protected String rootPath = null;    
      protected String jarPath = null;
      protected String jarAutoDiscoveryClassPath = null;
      protected List<String> documents = null;
      
      protected ServletContext servletContext = null;
      
      protected ApplicationContext applicationContext = null;
     
     private Set<String> allowedResourcePaths = null;
     
     /**
      * Sets the allowed resource paths.
      * 
      * @param allowedResourcePaths the new allowed resource paths
      */
     public void setAllowedResourcePaths(List<String> allowedResourcePaths)
     {
         this.allowedResourcePaths = new HashSet<String>(allowedResourcePaths);
     }
     
     /* (non-Javadoc)
      * @see org.springframework.web.context.ServletContextAware#setServletContext(javax.servlet.ServletContext)
      */
     public void setServletContext(ServletContext servletContext)
     {
         this.servletContext = servletContext;
     }
     
     /**
      * Sets the application context.
      * 
      * @param applicationContext the new application context
      */
     public void setApplicationContext(ApplicationContext applicationContext)
     {
         this.applicationContext = applicationContext;
     }
     
     /**
      * Gets the application context.
      * 
      * @return the application context
      */
     public ApplicationContext getApplicationContext()
     {
         return applicationContext;
     }
     
     /**
      * Sets the jar auto discovery path.
      * 
      * @param jarAutoDiscoveryPath the new jar auto discovery path
      */
     public void setJarAutoDiscoveryClassPath(String jarAutoDiscoveryClassPath)
     {
         this.jarAutoDiscoveryClassPath = jarAutoDiscoveryClassPath;
     }
     
     /**
      * Gets the jar auto discovery class path.
      * 
      * @return the jar auto discovery class path
      */
     public String getJarAutoDiscoveryClassPath()
     {
         return this.jarAutoDiscoveryClassPath;
     }
     
     /**
      * Sets the jar path.
      * 
      * @param jarPath the new jar path
      */
     public void setJarPath(String jarPath)
     {
         this.jarPath = jarPath;
     }
     
     /**
      * Gets the jar path.
      * 
      * @return the jar path
      */
     public String getJarPath()
     {
         return this.jarPath;
     }
     
     /**
      * Sets the root path
      * 
      * @param rootPath the new root path
      */
     public void setRootPath(String rootPath) 
     {
         this.rootPath = rootPath;
     }
     
     /**
      * Gets the root path.
      * 
      * @return the root path
      */
     public String getRootPath()
     {
         return this.rootPath;
     }
     
     /**
      * To relative path.
      * 
      * @param fullPath the full path
      * 
      * @return the string
      */
     protected String toRelativePath(String fullPath)
     {
         String relativePath = fullPath;
         
         if (getRootPath() != null)
         {
             relativePath = relativePath.substring(getRootPath().length());
         }
         
         if (relativePath.startsWith("/"))
         {
             relativePath = relativePath.substring(1);
         }
         
         return relativePath;
     }
     
     /**
      * To absolute path.
      * 
      * @param relativePath the relative path
      * 
      * @return the string
      */
     protected String toAbsolutePath(String relativePath)
     {
         String fullPath = relativePath;
         
         if (getRootPath() != null)
         {
             fullPath = getRootPath() + "/" + fullPath;            
             fullPath = fullPath.replace("//", "/");
         }
         
         return fullPath;
     }
     
     /**
      * Checks if the given relative path is allowed.
      * Validates against the allowedResourcePaths.
      * 
      * @param relativePath the relative path to the file
      * 
      * @return true, if is allowed
      */
     private boolean isRelativePathAllowed(String relativePath) 
     {
         PathMatcher pathMatcher = new AntPathMatcher();
         
         Iterator allowedResourcePathsIt = allowedResourcePaths.iterator();
         while (allowedResourcePathsIt.hasNext()) 
         {
             String pattern = (String) allowedResourcePathsIt.next();
             if (pathMatcher.match(pattern, relativePath)) 
             {
                 return true;
             }
         }
         
         return false;
     }
     
 
     /**
      * Sets whether the class path must exist
      *
      * If it must exist, but it doesn't exist, an exception is thrown
      * on initialisation of the store
      *
      * @param mustExist
      */
     public void setMustExist(boolean mustExist)
     {
         this.mustExist = mustExist;
     }
         
     /**
      * Gets the jar file.
      * 
      * @return the jar file
      */
     protected JarFile getJarFile()
     {
         JarFile jar = null;
 
         String sourceString = getJarPath();
         
         try
         {
             // make sure the source string is valid
             if (sourceString.startsWith(JAR_PROTOCOL) == false)
             {
                throw new IllegalArgumentException("sourceString must start with \"" + JAR_PROTOCOL + ":\"");
             }
             
             URL url = new URL(sourceString);
             URLConnection conn = url.openConnection();
             if (conn instanceof JarURLConnection)
             {
                // open the jar file, if it does not contain the entry requested a FileNotFound exception
                // is thrown and reported below
                jar = ((JarURLConnection)conn).getJarFile();
             }
         }
         catch(Throwable t)
         {
             logger.error("Unable to read jar file: " + sourceString, t); 
         }
         
         return jar;
     }
     
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#init()
      */
     public void init()
     {
         // set up root path
         if (getRootPath() == null)
         {
             setRootPath("");
         }
         if ("/".equals(getRootPath()))
         {
             setRootPath("");
         }
         
         // location of the jar file (with variable substitution)
         String sourceString = getJarPath();
         if (sourceString == null)
         {
             // support for auto-resolution of a jar file
             if (getJarAutoDiscoveryClassPath() != null)
             {
                 Resource[] resources = null;
                 try
                 {
                     resources = getApplicationContext().getResources("classpath*:" + getJarAutoDiscoveryClassPath() + "*");
                     if (resources != null && resources.length > 0)
                     {
                         String autoDiscovered = resources[0].getURL().toExternalForm();
                         if (autoDiscovered != null && autoDiscovered.startsWith(JAR_PROTOCOL))
                         {
                             int i = autoDiscovered.indexOf("!/");
                             if (i > -1)
                             {
                                 autoDiscovered = autoDiscovered.substring(0, i+2);
                             }
                             sourceString = autoDiscovered;
                         }
                     }
                 }
                 catch (IOException ioe)
                 {
                     logger.error("Unable to find JAR file for auto discovery for classpath: " + getJarAutoDiscoveryClassPath());
                 }
             }
         }
         sourceString = sourceString.replace("${servletContext}", this.servletContext.getRealPath("/"));
         sourceString = sourceString.replace("\\\\", "\\");
         setJarPath(sourceString);
         
         // defaults for allowed resource paths
         if (allowedResourcePaths == null)
         {
             allowedResourcePaths = new HashSet<String>();
 
             // allow all resources by default
             allowedResourcePaths.add("**/*.*");
         };        
         
         // make sure we have a valid jar file
         JarFile jarFile = getJarFile();        
         if (jarFile != null)
         {
             exists = true;
         }
         
         // set up documents container
         this.documents = new ArrayList<String>();
         
         // pull back all of the entries in the jar file
         if (exists)
         {
             try
             {
                 URL url = new URL(sourceString);
                 URLConnection conn = url.openConnection();
                 if (conn instanceof JarURLConnection)
                 {
                    // open the jar file, if it does not contain the entry requested a FileNotFound exception
                    // is thrown and reported below
                    JarFile jar = ((JarURLConnection)conn).getJarFile();
                    Enumeration<JarEntry> e = jar.entries();
                    while (e.hasMoreElements())
                    {
                        JarEntry entry = (JarEntry) e.nextElement();
                        String jarName = entry.getName();
                        
                        // check if this is a file and if it is under the root path
                        if (!entry.isDirectory() && jarName.startsWith(getRootPath()))
                        {
                            // make sure the relative path is allowed
                            String relativePath = toRelativePath(jarName);
                            
                            if (isRelativePathAllowed(relativePath))
                            {
                                documents.add(relativePath);
                            }
                        }
                    }
                 }
             }
             catch (Throwable t)
             {
                 logger.error("Error while reading contents of jar file: " + sourceString, t);
                 exists = false;
             }
         }
         
         // ensure the store exists if it supposed to exist
         if (mustExist && !exists)
         {
             throw new WebScriptsPlatformException("Jar Store must exist but could not be created: " + getBasePath());
         }
         
         if (logger.isDebugEnabled())
             logger.debug("JarStore initialized - loaded " + this.documents.size() + " documents");
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#exists()
      */
     public boolean exists()
     {
         return exists;
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#getBasePath()
      */
     public String getBasePath()
     {
         return jarPath;
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#isSecure()
      */
     public boolean isSecure()
     {
         return true;
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#getAllDocumentPaths()
      */
     public String[] getAllDocumentPaths()
     {
         return documents.toArray(new String[documents.size()]);
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#getDescriptionDocumentPaths()
      */
     public String[] getDescriptionDocumentPaths()
     {
         return getDocumentPaths("/", true, "*.desc.xml");
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#getScriptDocumentPaths(org.alfresco.web.scripts.WebScript)
      */
     public String[] getScriptDocumentPaths(WebScript script)
     {
         String scriptPaths = script.getDescription().getId() + ".*";
         return getDocumentPaths("/", false, scriptPaths);
     }
     
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#getDocumentPaths(java.lang.String, boolean, java.lang.String)
      */
     public String[] getDocumentPaths(String path, boolean includeSubPaths, String documentPattern)
     {
         String[] paths;
         
         if ((path == null) || (path.length() == 0))
         {
             path = "/";
         }
 
         if (! path.startsWith("/"))
         {
             path = "/" + path;
         }
 
         if (! path.endsWith("/"))
         {
             path = path + "/";
         }
 
         if ((documentPattern == null) || (documentPattern.length() == 0))
         {
             documentPattern = "*";
         }
 
         final StringBuilder pattern = new StringBuilder(128);
         pattern.append(path)
                .append((includeSubPaths ? "**/" : ""))
                .append(documentPattern);
 
         try
         {
             List<String> documentPaths = getMatchingDocuments(pattern.toString());
             paths = documentPaths.toArray(new String[documentPaths.size()]);
         }
         catch (IOException e)
         {
             // Note: Ignore: no documents found
             paths = new String[0];
         }
 
         return paths;
     }
 
     /**
      * Helper to return a list of resource document paths
      * based on a search pattern.
      * 
      * @param pattern the pattern
      * 
      * @return the matching documents (relative to root path)
      * 
      * @throws IOException Signals that an I/O exception has occurred.
      */    
     private List<String> getMatchingDocuments(String pattern)
         throws IOException
     {
         String[] validPaths = getDocumentPaths("/", pattern);
         
         List<String> list = new ArrayList<String>();
         for (int i = 0; i < validPaths.length; i++)
         {
             String validPath = validPaths[i];
             
             // adjust path to make sure it is relative to base path
             if (this.getRootPath() != null)
             {
                 if (validPath.startsWith(this.getRootPath()))
                 {
                     validPath = validPath.substring(this.getRootPath().length());
                 }
             }
             
             if (validPath.startsWith("/"))
             {
                 validPath = validPath.substring(1);
             }
             
             list.add(validPath);
         }
         
         return list;
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#lastModified(java.lang.String)
      */
     public long lastModified(String documentPath)
         throws IOException
     {
         long lastModified = -1;
         
         String jarName = toAbsolutePath(getRootPath());
         
         JarFile jarFile = getJarFile();
         if (jarFile != null)
         {
             JarEntry jarEntry = jarFile.getJarEntry(jarName);
             if (jarEntry != null)
             {
                 lastModified = jarEntry.getTime();
             }
         }
         
         return lastModified;
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#hasDocument(java.lang.String)
      */
     public boolean hasDocument(String documentPath)
     {
         return documents.contains(documentPath);
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#getDescriptionDocument(java.lang.String)
      */
     public InputStream getDocument(String documentPath)
         throws IOException
     {
         InputStream is = null;
         
         String jarName = toAbsolutePath(documentPath);
         
         JarFile jarFile = getJarFile();
         if (jarFile != null)
         {
             JarEntry jarEntry = jarFile.getJarEntry(jarName);
             if (jarEntry != null)
             {
                 is = jarFile.getInputStream(jarEntry);
             }
             
         }
         
         return is;
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#createDocument(java.lang.String, java.lang.String)
      */
     public void createDocument(String documentPath, String content) throws IOException
     {
         throw new WebScriptsPlatformException("Method createDocument not supported against Jar Store");
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#updateDocument(java.lang.String, java.lang.String)
      */
     public void updateDocument(String documentPath, String content) throws IOException
     {
         throw new WebScriptsPlatformException("Method updateDocument not supported against Jar Store");
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#removeDocument(java.lang.String)
      */
     public boolean removeDocument(String documentPath)
         throws IOException
     {
         throw new WebScriptsPlatformException("Method removeDocument not supported against Jar Store");
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#getTemplateLoader()
      */
     public TemplateLoader getTemplateLoader()
     {
         JarFile jarFile = getJarFile();
         return new JarStoreTemplateLoader(jarFile);
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.scripts.Store#getScriptLoader()
      */
     public ScriptLoader getScriptLoader()
     {
         JarFile jarFile = getJarFile();
         return new JarScriptLoader(jarFile);
     }
     
     /* (non-Javadoc)
      * @see java.lang.Object#toString()
      */
     @Override
     public String toString()
     {
         return getBasePath() + this.getRootPath();
     }
 
 
     /**
      * Jar based script loader
      *
      * @author davidc
      */
     private class JarScriptLoader implements ScriptLoader
     {
         protected JarFile jarFile = null;
         
         public JarScriptLoader(JarFile jarFile)
         {
             this.jarFile = jarFile;
         }
 
         /* (non-Javadoc)
          * @see org.alfresco.web.scripts.ScriptLoader#getScriptLocation(java.lang.String)
          */
         public ScriptContent getScript(String documentPath)
         {
             ScriptContent scriptContent = null;
             
             String jarName = toAbsolutePath(documentPath);
 
             JarEntry jarEntry = jarFile.getJarEntry(jarName);
             if (jarEntry != null)
             {
                 scriptContent = new ClassPathScriptContent(jarFile, documentPath);
             }
             
             return scriptContent;
         }
     }
 
     /**
      * Jar file script content
      *
      * @author muzquiano
      */
     private class ClassPathScriptContent implements ScriptContent
     {
         protected String documentPath;
         protected JarFile jarFile;
         
         public ClassPathScriptContent(JarFile jarFile, String documentPath)
         {
             this.jarFile = jarFile;
             this.documentPath = documentPath;
         }
 
         /* (non-Javadoc)
          * @see org.alfresco.service.cmr.repository.ScriptLocation#getInputStream()
          */
         public InputStream getInputStream()
         {
             InputStream is = null;
             
             String jarName = toAbsolutePath(documentPath);
             
             JarEntry jarEntry = jarFile.getJarEntry(jarName);
             if (jarEntry != null)
             {
                 try
                 {
                     is = jarFile.getInputStream(jarEntry);
                 }
                 catch(IOException ioe)
                 {
                     logger.error("Error while getting input stream for path: " + documentPath + " in jar file: " + jarFile.getName());
                 }
             }
 
             return is;
         }
 
         /* (non-Javadoc)
          * @see org.alfresco.service.cmr.repository.ScriptLocation#getReader()
          */
         public Reader getReader()
         {
             try
             {
                 return new InputStreamReader(getInputStream(), "UTF-8");
             }
             catch (UnsupportedEncodingException e)
             {
                 throw new WebScriptsPlatformException("Unsupported Encoding", e);
             }
         }
 
         /* (non-Javadoc)
          * @see org.alfresco.web.scripts.ScriptContent#getPath()
          */
         public String getPath()
         {
             return documentPath;
         }
 
         /* (non-Javadoc)
          * @see org.alfresco.web.scripts.ScriptContent#getPathDescription()
          */
         public String getPathDescription()
         {
             return "/" + documentPath + " (in jar store " + jarFile.getName() + ")";
         }
 
         /* (non-Javadoc)
          * @see org.alfresco.web.scripts.ScriptContent#isCachable()
          */
         public boolean isCachable()
         {
             return true;
         }
 
         /* (non-Javadoc)
          * @see org.alfresco.web.scripts.ScriptContent#isSecure()
          */
         public boolean isSecure()
         {
             return true;
         }
 
         @Override
         public String toString()
         {
             return getPathDescription();
         }
     }
     
     /**
      * Jar store implementation of a Template Loader
      */
     private class JarStoreTemplateLoader implements TemplateLoader
     {
         private JarFile jarFile = null;
         
         public JarStoreTemplateLoader(JarFile jarFile)
         {
             this.jarFile = jarFile;
         }
         /**
          * @see freemarker.cache.TemplateLoader#closeTemplateSource(java.lang.Object)
          */
         public void closeTemplateSource(Object templateSource)
                 throws IOException
         {
             // nothing to do - we return a reader to fully retrieved in-memory
             // data
         }
 
         /**
          * @see freemarker.cache.TemplateLoader#findTemplateSource(java.lang.String)
          */
         public Object findTemplateSource(String name) throws IOException
         {
             JarStoreTemplateSource source = null;
             if (hasDocument(name))
             {
                 source = new JarStoreTemplateSource(jarFile, name);
             }
             return source;
         }
 
         /**
          * @see freemarker.cache.TemplateLoader#getLastModified(java.lang.Object)
          */
         public long getLastModified(Object templateSource)
         {
             return ((JarStoreTemplateSource) templateSource).lastModified();
         }
 
         /**
          * @see freemarker.cache.TemplateLoader#getReader(java.lang.Object,
          *      java.lang.String)
          */
         public Reader getReader(Object templateSource, String encoding)
                 throws IOException
         {
             return ((JarStoreTemplateSource) templateSource).getReader(encoding);
         }
     }
 
     /**
      * Template Source - loads from a Jar Store.
      */
     private class JarStoreTemplateSource
     {
         private String templatePath;
         private JarFile jarFile;
 
         private JarStoreTemplateSource(JarFile jarFile, String templatePath)
         {
             this.jarFile = jarFile;
             this.templatePath = templatePath;
         }
 
         private long lastModified()
         {
             long lastModified = -1;
             
             String jarName = toAbsolutePath(templatePath);
             
             JarEntry jarEntry = jarFile.getJarEntry(jarName);
             if (jarEntry != null)
             {
                 lastModified = jarEntry.getTime();
             }
             
             return lastModified;
         }
 
         private Reader getReader(String encoding) throws IOException
         {
             Reader reader = null;
             
             String jarName = toAbsolutePath(templatePath);
             
             JarEntry jarEntry = jarFile.getJarEntry(jarName);
             if (jarEntry != null)
             {
                 InputStream is = jarFile.getInputStream(jarEntry);
                 reader = new InputStreamReader(is);
             }
             
             return reader;
         }
     }
     
 }