/*

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

 import java.io.FileNotFoundException;

 import java.io.IOException;

 import java.lang.reflect.Method;

 import java.net.URL;

 import java.net.URLConnection;

 import java.util.HashMap;

 import java.util.Map;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import java.util.regex.Pattern;

 import javax.el.ELException;

 import javax.faces.FacesException;

 import javax.faces.FactoryFinder;

 import javax.faces.application.ViewResource;

 import javax.faces.context.FacesContext;

 import javax.faces.view.facelets.Facelet;

 import javax.faces.view.facelets.FaceletCache;

 import javax.faces.view.facelets.FaceletCacheFactory;

 import javax.faces.view.facelets.FaceletContext;

 import javax.faces.view.facelets.FaceletException;

 import javax.faces.view.facelets.FaceletHandler;

 import javax.faces.view.facelets.ResourceResolver;

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

 import org.apache.myfaces.view.facelets.AbstractFaceletCache;

 import org.apache.myfaces.view.facelets.FaceletFactory;

 import org.apache.myfaces.view.facelets.compiler.Compiler;

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

 /**

  * Default FaceletFactory implementation.

  * 

  * @author Jacob Hookom

  * @version $Id$

  */

 public final class DefaultFaceletFactory extends FaceletFactory

 {

     private static final long INFINITE_DELAY = -1;

     private static final long NO_CACHE_DELAY = 0;

     //protected final Log log = LogFactory.getLog(DefaultFaceletFactory.class);

     protected final Logger log = Logger.getLogger(DefaultFaceletFactory.class.getName());

     private URL _baseUrl;

     private Compiler _compiler;

     //private Map<String, DefaultFacelet> _facelets;

     //private Map<String, DefaultFacelet> _viewMetadataFacelets;

     private Map<String, DefaultFacelet> _compositeComponentMetadataFacelets;

     private long _refreshPeriod;

     private Map<String, URL> _relativeLocations;

     private javax.faces.view.facelets.ResourceResolver _resolver;

     private DefaultResourceResolver _defaultResolver;

     private FaceletCache<Facelet> _faceletCache;

     private AbstractFaceletCache<Facelet> _abstractFaceletCache;

     public DefaultFaceletFactory(Compiler compiler, ResourceResolver resolver) throws IOException

     {

         this(compiler, resolver, -1);

     }

     public DefaultFaceletFactory(Compiler compiler, ResourceResolver resolver, long refreshPeriod)

     {

         ParameterCheck.notNull("compiler", compiler);

         ParameterCheck.notNull("resolver", resolver);

         _compiler = compiler;

         //_facelets = new HashMap<String, DefaultFacelet>();

         //_viewMetadataFacelets = new HashMap<String, DefaultFacelet>();

         _compositeComponentMetadataFacelets = new HashMap<String, DefaultFacelet>();

         _relativeLocations = new HashMap<String, URL>();

         _resolver = resolver;

         if (_resolver instanceof DefaultResourceResolver)

         {

             _defaultResolver = (DefaultResourceResolver) _resolver;

         }

         //_baseUrl = resolver.resolveUrl("/");

         _refreshPeriod = refreshPeriod < 0 ? INFINITE_DELAY : refreshPeriod * 1000;

         // facelet cache. Lookup here, because after all this is a "part" of the facelet factory implementation.

         FaceletCacheFactory cacheFactory

                 = (FaceletCacheFactory) FactoryFinder.getFactory(FactoryFinder.FACELET_CACHE_FACTORY);

         _faceletCache = (FaceletCache<Facelet>) cacheFactory.getFaceletCache();

         FaceletCache.MemberFactory<Facelet> faceletFactory = new FaceletCache.MemberFactory<Facelet>()

         {

             public Facelet newInstance(URL url) throws IOException

             {

                 return _createFacelet(url);

             }

         };

         FaceletCache.MemberFactory<Facelet> viewMetadataFaceletFactory = new FaceletCache.MemberFactory<Facelet>()

         {

             public Facelet newInstance(URL url) throws IOException

             {

                 return _createViewMetadataFacelet(url);

             }

         };

         if (_faceletCache instanceof AbstractFaceletCache)

         {

             _abstractFaceletCache = (AbstractFaceletCache<Facelet>) _faceletCache;

             FaceletCache.MemberFactory<Facelet> compositeComponentMetadataFaceletFactory = 

                 new FaceletCache.MemberFactory<Facelet>()

             {

                 public Facelet newInstance(URL url) throws IOException

                 {

                     return _createCompositeComponentMetadataFacelet(url);

                 }

             };

             try

             {

                 Method setMemberFactoriesMethod = AbstractFaceletCache.class.getDeclaredMethod("setMemberFactories",

                         new Class[]{FaceletCache.MemberFactory.class, FaceletCache.MemberFactory.class, 

                                     FaceletCache.MemberFactory.class});

                 setMemberFactoriesMethod.setAccessible(true);

                 setMemberFactoriesMethod.invoke(_faceletCache, faceletFactory, viewMetadataFaceletFactory, 

                     compositeComponentMetadataFaceletFactory);

             } 

             catch (Exception e)

             {

                 throw new FacesException(

                     "Cannot call setMemberFactories method, Initialization of FaceletCache failed.",

                                          e);

             }   

         }

         else

         {

             // Note that FaceletCache.setMemberFactories method is protected, and this is the place where call

             // this method has sense, because DefaultFaceletFactory is the responsible to create Facelet instances.

             // The only way to do it is using reflection, and it has sense, because in this way it is possible to

             // setup a java SecurityManager that prevents call this method (because it is protected, and to do that

             // the code first check for "suppressAccessChecks" permission).

             try

             {

                 Method setMemberFactoriesMethod = FaceletCache.class.getDeclaredMethod("setMemberFactories",

                         new Class[]{FaceletCache.MemberFactory.class, FaceletCache.MemberFactory.class});

                 setMemberFactoriesMethod.setAccessible(true);

                 setMemberFactoriesMethod.invoke(_faceletCache, faceletFactory, viewMetadataFaceletFactory);

             } 

             catch (Exception e)

             {

                 throw new FacesException(

                     "Cannot call setMemberFactories method, Initialization of FaceletCache failed.",

                                          e);

             }            

         }

         if (log.isLoggable(Level.FINE))

         {

             log.fine("Using ResourceResolver: " + _resolver);

             log.fine("Using Refresh Period: " + _refreshPeriod);

         }

     }

     /**

      * Compiler this factory uses

      * 

      * @return final Compiler instance

      */

     public Compiler getCompiler()

     {

         return _compiler;

     }

     private URL getBaseUrl()

     {

         if (_baseUrl == null)

         {

             _baseUrl = _resolver.resolveUrl("/");

         }

         return _baseUrl;

     }

     /*

      * (non-Javadoc)

      * 

      * @see org.apache.myfaces.view.facelets.FaceletFactory#getFacelet(java.lang.String)

      */

     @Override

     public Facelet getFacelet(FacesContext facesContext, String uri) 

         throws IOException, FaceletException, FacesException, ELException

     {

         URL url = (URL) _relativeLocations.get(uri);

         if (url == null)

         {

             url = resolveURL(facesContext, getBaseUrl(), uri);

             if (url != null)

             {

                 ViewResource viewResource = (ViewResource) facesContext.getAttributes().get(

                     FaceletFactory.LAST_RESOURCE_RESOLVED);

                 if (viewResource != null)

                 {

                     // If a view resource has been used to resolve a resource, the cache is in

                     // the ResourceHandler implementation. No need to cache in _relativeLocations.

                 }

                 else

                 {

                     Map<String, URL> newLoc = new HashMap<String, URL>(_relativeLocations);

                     newLoc.put(uri, url);

                     _relativeLocations = newLoc;

                 }

             }

             else

             {

                 throw new IOException("'" + uri + "' not found.");

             }

         }

         return this.getFacelet(url);

     }

     /**

      * Create a Facelet from the passed URL. This method checks if the cached Facelet needs to be refreshed before

      * returning. If so, uses the passed URL to build a new instance;

      * 

      * @param url

      *            source url

      * @return Facelet instance

      * @throws IOException

      * @throws FaceletException

      * @throws FacesException

      * @throws ELException

      */

     @Override

     public Facelet getFacelet(URL url) throws IOException, FaceletException, FacesException, ELException

     {

         return _faceletCache.getFacelet(url);

     }

     @Override

     public Facelet getFacelet(FaceletContext ctx, URL url) 

             throws IOException, FaceletException, FacesException, ELException

     {

         if (_abstractFaceletCache != null)

         {

             return _abstractFaceletCache.getFacelet(ctx, url);

         }

         else

         {

             return _faceletCache.getFacelet(url);

         }

     }

     public long getRefreshPeriod()

     {

         return _refreshPeriod;

     }

     /**

      * Resolves a path based on the passed URL. If the path starts with '/', then resolve the path against

      * {@link javax.faces.context.ExternalContext#getResource(java.lang.String)

      * javax.faces.context.ExternalContext#getResource(java.lang.String)}. Otherwise create a new URL via

      * {@link URL#URL(java.net.URL, java.lang.String) URL(URL, String)}.

      * 

      * @param source

      *            base to resolve from

      * @param path

      *            relative path to the source

      * @return resolved URL

      * @throws IOException

      */

     public URL resolveURL(FacesContext context, URL source, String path) throws IOException

     {

         if (path.startsWith("/"))

         {

             context.getAttributes().put(LAST_RESOURCE_RESOLVED, null);

             URL url = resolveURL(context, path);

             if (url == null)

             {

                 throw new FileNotFoundException(path + " Not Found in ExternalContext as a Resource");

             }

             return url;

         }

         else

         {

             return new URL(source, path);

         }

     }

     /**

      * Template method for determining if the Facelet needs to be refreshed.

      * 

      * @param facelet

      *            Facelet that could have expired

      * @return true if it needs to be refreshed

      */

     protected boolean needsToBeRefreshed(DefaultFacelet facelet)

     {

         // if set to 0, constantly reload-- nocache

         if (_refreshPeriod == NO_CACHE_DELAY)

         {

             return true;

         }

         // if set to -1, never reload

         if (_refreshPeriod == INFINITE_DELAY)

         {

             return false;

         }

         long target = facelet.getCreateTime() + _refreshPeriod;

         if (System.currentTimeMillis() > target)

         {

             // Should check for file modification

             URLConnection conn = null;

             try

             {

                 conn = facelet.getSource().openConnection();

                 long lastModified = ResourceLoaderUtils.getResourceLastModified(conn);

                 return lastModified == 0 || lastModified > target;

             }

             catch (IOException e)

             {

                 throw new FaceletException("Error Checking Last Modified for " + facelet.getAlias(), e);

             }

             finally

             {

                 if (conn != null)

                 {

                     try

                     {

                         conn.getInputStream().close();

                     }

                     catch (Exception e)

                     {

                         // Ignored

                     }

                 }

             }

         }

         return false;

     }

     /**

      * Uses the internal Compiler reference to build a Facelet given the passed URL.

      * 

      * @param url

      *            source

      * @return a Facelet instance

      * @throws IOException

      * @throws FaceletException

      * @throws FacesException

      * @throws ELException

      */

     private DefaultFacelet _createFacelet(URL url) throws IOException, FaceletException, FacesException, ELException

     {

         if (log.isLoggable(Level.FINE))

         {

             log.fine("Creating Facelet for: " + url);

         }

         String alias = "/" + _removeFirst(url.getFile(), getBaseUrl().getFile());

         try

         {

             FaceletHandler h = _compiler.compile(url, alias);

             DefaultFacelet f = new DefaultFacelet(this, _compiler.createExpressionFactory(), url, alias, alias, h);

             return f;

         }

         catch (FileNotFoundException fnfe)

         {

             throw new FileNotFoundException("Facelet " + alias + " not found at: " + url.toExternalForm());

         }

     }

     /**

      * @since 2.0

      * @param url

      * @return

      * @throws IOException

      * @throws FaceletException

      * @throws FacesException

      * @throws ELException

      */

     private DefaultFacelet _createViewMetadataFacelet(URL url)

             throws IOException, FaceletException, FacesException, ELException

     {

         if (log.isLoggable(Level.FINE))

         {

             log.fine("Creating Facelet used to create View Metadata for: " + url);

         }

         // The alias is used later for informative purposes, so we append 

         // some prefix to identify later where the errors comes from.

         String faceletId = "/"+ _removeFirst(url.getFile(), getBaseUrl().getFile());

         String alias = "/viewMetadata" + faceletId;

         try

         {

             FaceletHandler h = _compiler.compileViewMetadata(url, alias);

             DefaultFacelet f = new DefaultFacelet(this, _compiler.createExpressionFactory(), url, alias, 

                     faceletId, h);

             return f;

         }

         catch (FileNotFoundException fnfe)

         {

             throw new FileNotFoundException("Facelet " + alias + " not found at: " + url.toExternalForm());

         }

     }

     /**

      * @since 2.0.1

      * @param url

      * @return

      * @throws IOException

      * @throws FaceletException

      * @throws FacesException

      * @throws ELException

      */

     private DefaultFacelet _createCompositeComponentMetadataFacelet(URL url)

             throws IOException, FaceletException, FacesException, ELException

     {

         if (log.isLoggable(Level.FINE))

         {

             log.fine("Creating Facelet used to create Composite Component Metadata for: " + url);

         }

         // The alias is used later for informative purposes, so we append 

         // some prefix to identify later where the errors comes from.

         String alias = "/compositeComponentMetadata/" + _removeFirst(url.getFile(), getBaseUrl().getFile());

         try

         {

             FaceletHandler h = _compiler.compileCompositeComponentMetadata(url, alias);

             DefaultFacelet f = new DefaultFacelet(this, _compiler.createExpressionFactory(), url, alias,

                     alias, h, true);

             return f;

         }

         catch (FileNotFoundException fnfe)

         {

             throw new FileNotFoundException("Facelet " + alias + " not found at: " + url.toExternalForm());

         }

     }

     /**

      * Works in the same way as getFacelet(String uri), but redirect

      * to getViewMetadataFacelet(URL url)

      * @since 2.0

      */

     @Override

     public Facelet getViewMetadataFacelet(FacesContext facesContext, String uri) 

         throws IOException

     {

         URL url = (URL) _relativeLocations.get(uri);

         if (url == null)

         {

             url = resolveURL(facesContext, getBaseUrl(), uri);

             ViewResource viewResource = (ViewResource) facesContext.getAttributes().get(

                 FaceletFactory.LAST_RESOURCE_RESOLVED);

             if (url != null)

             {

                 if (viewResource != null)

                 {

                     // If a view resource has been used to resolve a resource, the cache is in

                     // the ResourceHandler implementation. No need to cache in _relativeLocations.

                 }

                 else

                 {

                     Map<String, URL> newLoc = new HashMap<String, URL>(_relativeLocations);

                     newLoc.put(uri, url);

                     _relativeLocations = newLoc;

                 }

             }

             else

             {

                 throw new IOException("'" + uri + "' not found.");

             }

         }

         return this.getViewMetadataFacelet(url);

     }

     /**

      * @since 2.0

      */

     @Override

     public Facelet getViewMetadataFacelet(URL url) throws IOException,

             FaceletException, FacesException, ELException

     {

         if (_abstractFaceletCache != null)

         {

             return _abstractFaceletCache.getViewMetadataFacelet(url);

         }

         else

         {

             return _faceletCache.getViewMetadataFacelet(url);

         }

     }

     /**

      * Works in the same way as getFacelet(String uri), but redirect

      * to getViewMetadataFacelet(URL url)

      * @since 2.0.1

      */

     @Override

     public Facelet getCompositeComponentMetadataFacelet(FacesContext facesContext, String uri)

         throws IOException

     {

         URL url = (URL) _relativeLocations.get(uri);

         if (url == null)

         {

             url = resolveURL(facesContext, getBaseUrl(), uri);

             ViewResource viewResource = (ViewResource) facesContext.getAttributes().get(

                 FaceletFactory.LAST_RESOURCE_RESOLVED);            

             if (url != null)

             {

                 if (viewResource != null)

                 {

                     // If a view resource has been used to resolve a resource, the cache is in

                     // the ResourceHandler implementation. No need to cache in _relativeLocations.

                 }

                 else

                 {

                     Map<String, URL> newLoc = new HashMap<String, URL>(_relativeLocations);

                     newLoc.put(uri, url);

                     _relativeLocations = newLoc;

                 }

             }

             else

             {

                 throw new IOException("'" + uri + "' not found.");

             }

         }

         return this.getCompositeComponentMetadataFacelet(url);

     }

     /**

      * @since 2.0.1

      */

     @Override

     public Facelet getCompositeComponentMetadataFacelet(URL url) throws IOException,

             FaceletException, FacesException, ELException

     {

         if (_abstractFaceletCache != null)

         {

             return _abstractFaceletCache.getCompositeComponentMetadataFacelet(url);

         }

         else

         {

             ParameterCheck.notNull("url", url);

             String key = url.toString();

             DefaultFacelet f = _compositeComponentMetadataFacelets.get(key);

             if (f == null || this.needsToBeRefreshed(f))

             {

                 f = this._createCompositeComponentMetadataFacelet(url);

                 if (_refreshPeriod != NO_CACHE_DELAY)

                 {

                     Map<String, DefaultFacelet> newLoc

                             = new HashMap<String, DefaultFacelet>(_compositeComponentMetadataFacelets);

                     newLoc.put(key, f);

                     _compositeComponentMetadataFacelets = newLoc;

                 }

             }

             return f;

         }

     }

     private URL resolveURL(FacesContext context, String path)

     {

         if (_defaultResolver != null)

         {

             return _defaultResolver.resolveUrl(context, path);

         }

         else

         {

             return _resolver.resolveUrl(path);

         }

     }

     public Facelet compileComponentFacelet(String taglibURI, String tagName, Map<String,Object> attributes)

     {

         FaceletHandler handler = _compiler.compileComponent(taglibURI, tagName, attributes);

         String alias = "/component/oamf:"+tagName;

         return new DefaultFacelet(this, _compiler.createExpressionFactory(), getBaseUrl(), alias, alias, handler);

     }

     /**

      * Removes the first appearance of toRemove in string.

      *

      * Works just like string.replaceFirst(toRemove, ""), except that toRemove

      * is not treated as a regex (which could cause problems with filenames).

      *

      * @param string

      * @param toRemove

      * @return

      */

     private String _removeFirst(String string, String toRemove)

     {

         // do exactly what String.replaceFirst(toRemove, "") internally does,

         // except treating the search as literal text and not as regex

         return Pattern.compile(toRemove, Pattern.LITERAL).matcher(string).replaceFirst("");

     }

 }