/*
    * $Id: CompleteAutoloadTilesContainerFactory.java 1332136 2012-04-30 09:34:09Z mck $
    *
    * 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.tiles.extras.complete;
  
  import java.io.InputStream;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.List;
  import java.util.Locale;
  import java.util.regex.Pattern;
  
  import javax.el.ArrayELResolver;
  import javax.el.BeanELResolver;
  import javax.el.CompositeELResolver;
  import javax.el.ELResolver;
  import javax.el.ListELResolver;
  import javax.el.MapELResolver;
  import javax.el.ResourceBundleELResolver;
  
  import ognl.OgnlException;
  import ognl.OgnlRuntime;
  import ognl.PropertyAccessor;
  
  import org.apache.tiles.TilesContainer;
  import org.apache.tiles.compat.definition.digester.CompatibilityDigesterDefinitionsReader;
  import org.apache.tiles.context.TilesRequestContextHolder;
  import org.apache.tiles.definition.DefinitionsReader;
  import org.apache.tiles.definition.pattern.DefinitionPatternMatcherFactory;
  import org.apache.tiles.definition.pattern.PatternDefinitionResolver;
  import org.apache.tiles.definition.pattern.PrefixedPatternDefinitionResolver;
  import org.apache.tiles.definition.pattern.regexp.RegexpDefinitionPatternMatcherFactory;
  import org.apache.tiles.definition.pattern.wildcard.WildcardDefinitionPatternMatcherFactory;
  import org.apache.tiles.el.ELAttributeEvaluator;
  import org.apache.tiles.el.JspExpressionFactoryFactory;
  import org.apache.tiles.el.ScopeELResolver;
  import org.apache.tiles.el.TilesContextBeanELResolver;
  import org.apache.tiles.el.TilesContextELResolver;
  import org.apache.tiles.evaluator.AttributeEvaluatorFactory;
  import org.apache.tiles.evaluator.BasicAttributeEvaluatorFactory;
  import org.apache.tiles.factory.BasicTilesContainerFactory;
  import org.apache.tiles.factory.TilesContainerFactoryException;
  import org.apache.tiles.freemarker.TilesSharedVariableFactory;
  import org.apache.tiles.impl.mgmt.CachingTilesContainer;
  import org.apache.tiles.locale.LocaleResolver;
  import org.apache.tiles.mvel.MVELAttributeEvaluator;
  import org.apache.tiles.mvel.ScopeVariableResolverFactory;
  import org.apache.tiles.mvel.TilesContextBeanVariableResolverFactory;
  import org.apache.tiles.mvel.TilesContextVariableResolverFactory;
  import org.apache.tiles.ognl.AnyScopePropertyAccessor;
  import org.apache.tiles.ognl.DelegatePropertyAccessor;
  import org.apache.tiles.ognl.NestedObjectDelegatePropertyAccessor;
  import org.apache.tiles.ognl.OGNLAttributeEvaluator;
  import org.apache.tiles.ognl.PropertyAccessorDelegateFactory;
  import org.apache.tiles.ognl.ScopePropertyAccessor;
  import org.apache.tiles.ognl.TilesApplicationContextNestedObjectExtractor;
  import org.apache.tiles.ognl.TilesContextPropertyAccessorDelegateFactory;
  import org.apache.tiles.request.ApplicationContext;
  import org.apache.tiles.request.ApplicationResource;
  import org.apache.tiles.request.Request;
  import org.apache.tiles.request.freemarker.render.FreemarkerRenderer;
  import org.apache.tiles.request.freemarker.render.FreemarkerRendererBuilder;
  import org.apache.tiles.request.freemarker.servlet.SharedVariableLoaderFreemarkerServlet;
  import org.apache.tiles.request.mustache.MustacheRenderer;
  import org.apache.tiles.request.render.BasicRendererFactory;
  import org.apache.tiles.request.render.ChainedDelegateRenderer;
  import org.apache.tiles.request.render.Renderer;
  import org.apache.tiles.request.servlet.ServletUtil;
  import org.apache.tiles.request.velocity.render.VelocityRenderer;
  import org.apache.tiles.request.velocity.render.VelocityRendererBuilder;
  import org.mvel2.integration.VariableResolverFactory;
  
  /**
   * Tiles container factory that:
   * <ul>
   * <li>create supporting objects for Velocity and FreeMarker;</li>
   * <li>create renderers for Velocity, FreeMarker, and Mustache templates;</li>
   * <li>allows using EL, MVEL and OGNL as attribute expressions;</li>
   * <li>allows using Wildcards and Regular Expressions in definition names;</li>
   * <li>loads Tiles 1.x definition files;</li>
   * <li>loads all the definition files that have the "tiles*.xml" pattern under
  * <code>/WEB-INF</code> directory (and subdirectories) and under
  * <code>META-INF</code> directories (and subdirectories) in every jar.</li>
  * </ul>
  *
  * @version $Rev: 1332136 $ $Date: 2012-04-30 19:34:09 +1000 (Mon, 30 Apr 2012) $
  * @since 2.2.0
  */
 public class CompleteAutoloadTilesContainerFactory extends BasicTilesContainerFactory {
 
     /**
      * The freemarker renderer name.
      */
     private static final String FREEMARKER_RENDERER_NAME = "freemarker";
 
     /**
      * The velocity renderer name.
      */
     private static final String VELOCITY_RENDERER_NAME = "velocity";
 
     /**
      * The mustache renderer name.
      */
     private static final String MUSTACHE_RENDERER_NAME = "mustache";
 
     /** {@inheritDoc} */
     @Override
     public TilesContainer createDecoratedContainer(TilesContainer originalContainer,
             ApplicationContext applicationContext) {
         return new CachingTilesContainer(originalContainer);
     }
 
     /** {@inheritDoc} */
     @Override
     protected void registerAttributeRenderers(
             final BasicRendererFactory rendererFactory,
             final ApplicationContext applicationContext,
             final TilesContainer container,
             final AttributeEvaluatorFactory attributeEvaluatorFactory) {
         super.registerAttributeRenderers(rendererFactory, applicationContext, container, attributeEvaluatorFactory);
 
         FreemarkerRenderer freemarkerRenderer = FreemarkerRendererBuilder
                 .createInstance()
                 .setApplicationContext(applicationContext)
                 .setParameter("TemplatePath", "/")
                 .setParameter("NoCache", "true")
                 .setParameter("ContentType", "text/html")
                 .setParameter("template_update_delay", "0")
                 .setParameter("default_encoding", "ISO-8859-1")
                 .setParameter("number_format", "0.##########")
                 .setParameter(SharedVariableLoaderFreemarkerServlet.CUSTOM_SHARED_VARIABLE_FACTORIES_INIT_PARAM,
                         "tiles," + TilesSharedVariableFactory.class.getName()).build();
         rendererFactory.registerRenderer(FREEMARKER_RENDERER_NAME, freemarkerRenderer);
 
         VelocityRenderer velocityRenderer = VelocityRendererBuilder.createInstance()
                 .setApplicationContext(applicationContext).build();
         rendererFactory.registerRenderer(VELOCITY_RENDERER_NAME, velocityRenderer);
 
         MustacheRenderer mustacheRenderer = new MustacheRenderer();
         mustacheRenderer.setAcceptPattern(Pattern.compile(".+\\.mustache"));
         rendererFactory.registerRenderer(MUSTACHE_RENDERER_NAME, mustacheRenderer);
     }
 
     /** {@inheritDoc} */
     @Override
     protected Renderer createDefaultAttributeRenderer(BasicRendererFactory rendererFactory,
             ApplicationContext applicationContext, TilesContainer container,
             AttributeEvaluatorFactory attributeEvaluatorFactory) {
 
         ChainedDelegateRenderer retValue = new ChainedDelegateRenderer();
         retValue.addAttributeRenderer(rendererFactory.getRenderer(DEFINITION_RENDERER_NAME));
         retValue.addAttributeRenderer(rendererFactory.getRenderer(VELOCITY_RENDERER_NAME));
         retValue.addAttributeRenderer(rendererFactory.getRenderer(FREEMARKER_RENDERER_NAME));
         retValue.addAttributeRenderer(rendererFactory.getRenderer(MUSTACHE_RENDERER_NAME));
         retValue.addAttributeRenderer(rendererFactory.getRenderer(TEMPLATE_RENDERER_NAME));
         retValue.addAttributeRenderer(rendererFactory.getRenderer(STRING_RENDERER_NAME));
         return retValue;
     }
 
     /** {@inheritDoc} */
     @Override
     protected AttributeEvaluatorFactory createAttributeEvaluatorFactory(ApplicationContext applicationContext,
             LocaleResolver resolver) {
         BasicAttributeEvaluatorFactory attributeEvaluatorFactory = new BasicAttributeEvaluatorFactory(
                 createELEvaluator(applicationContext));
         attributeEvaluatorFactory.registerAttributeEvaluator("MVEL", createMVELEvaluator());
         attributeEvaluatorFactory.registerAttributeEvaluator("OGNL", createOGNLEvaluator());
 
         return attributeEvaluatorFactory;
     }
 
     /** {@inheritDoc} */
     @Override
     protected <T> PatternDefinitionResolver<T> createPatternDefinitionResolver(Class<T> customizationKeyClass) {
         DefinitionPatternMatcherFactory wildcardFactory = new WildcardDefinitionPatternMatcherFactory();
         DefinitionPatternMatcherFactory regexpFactory = new RegexpDefinitionPatternMatcherFactory();
         PrefixedPatternDefinitionResolver<T> resolver = new PrefixedPatternDefinitionResolver<T>();
         resolver.registerDefinitionPatternMatcherFactory("WILDCARD", wildcardFactory);
         resolver.registerDefinitionPatternMatcherFactory("REGEXP", regexpFactory);
         return resolver;
     }
 
     /** {@inheritDoc} */
     @Override
     protected List<ApplicationResource> getSources(ApplicationContext applicationContext) {
         Collection<ApplicationResource> webINFSet = applicationContext.getResources("/WEB-INF/**/tiles*.xml");
         Collection<ApplicationResource> metaINFSet = applicationContext
                 .getResources("classpath*:META-INF/**/tiles*.xml");
 
         List<ApplicationResource> filteredResources = new ArrayList<ApplicationResource>();
         if (webINFSet != null) {
             for (ApplicationResource resource : webINFSet) {
                 if (Locale.ROOT.equals(resource.getLocale())) {
                     filteredResources.add(resource);
                 }
             }
         }
         if (metaINFSet != null) {
             for (ApplicationResource resource : metaINFSet) {
                 if (Locale.ROOT.equals(resource.getLocale())) {
                     filteredResources.add(resource);
                 }
             }
         }
         return filteredResources;
     }
 
     /** {@inheritDoc} */
     @Override
     protected DefinitionsReader createDefinitionsReader(ApplicationContext applicationContext) {
         return new CompatibilityDigesterDefinitionsReader();
     }
 
     /**
      * Creates the EL evaluator.
      *
      * @param applicationContext The Tiles application context.
      * @return The EL evaluator.
      */
     private ELAttributeEvaluator createELEvaluator(ApplicationContext applicationContext) {
         ELAttributeEvaluator evaluator = new ELAttributeEvaluator();
         JspExpressionFactoryFactory efFactory = new JspExpressionFactoryFactory();
         efFactory.setApplicationContext(applicationContext);
         evaluator.setExpressionFactory(efFactory.getExpressionFactory());
         ELResolver elResolver = new CompositeELResolver() {
             {
                 BeanELResolver beanElResolver = new BeanELResolver(false);
                 add(new ScopeELResolver());
                 add(new TilesContextELResolver(beanElResolver));
                 add(new TilesContextBeanELResolver());
                 add(new ArrayELResolver(false));
                 add(new ListELResolver(false));
                 add(new MapELResolver(false));
                 add(new ResourceBundleELResolver());
                 add(beanElResolver);
             }
         };
         evaluator.setResolver(elResolver);
         return evaluator;
     }
 
     /**
      * Creates the MVEL evaluator.
      *
      * @return The MVEL evaluator.
      */
     private MVELAttributeEvaluator createMVELEvaluator() {
         TilesRequestContextHolder requestHolder = new TilesRequestContextHolder();
         VariableResolverFactory variableResolverFactory = new ScopeVariableResolverFactory(requestHolder);
         variableResolverFactory.setNextFactory(new TilesContextVariableResolverFactory(requestHolder));
         variableResolverFactory.setNextFactory(new TilesContextBeanVariableResolverFactory(requestHolder));
         MVELAttributeEvaluator mvelEvaluator = new MVELAttributeEvaluator(requestHolder, variableResolverFactory);
         return mvelEvaluator;
     }
 
     /**
      * Creates the OGNL evaluator.
      *
      * @return The OGNL evaluator.
      */
     private OGNLAttributeEvaluator createOGNLEvaluator() {
         try {
             PropertyAccessor objectPropertyAccessor = OgnlRuntime.getPropertyAccessor(Object.class);
             PropertyAccessor applicationContextPropertyAccessor = new NestedObjectDelegatePropertyAccessor<Request>(
                     new TilesApplicationContextNestedObjectExtractor(), objectPropertyAccessor);
             PropertyAccessor anyScopePropertyAccessor = new AnyScopePropertyAccessor();
             PropertyAccessor scopePropertyAccessor = new ScopePropertyAccessor();
             PropertyAccessorDelegateFactory<Request> factory = new TilesContextPropertyAccessorDelegateFactory(
                     objectPropertyAccessor, applicationContextPropertyAccessor, anyScopePropertyAccessor,
                     scopePropertyAccessor);
             PropertyAccessor tilesRequestAccessor = new DelegatePropertyAccessor<Request>(factory);
             OgnlRuntime.setPropertyAccessor(Request.class, tilesRequestAccessor);
             return new OGNLAttributeEvaluator();
         } catch (OgnlException e) {
             throw new TilesContainerFactoryException("Cannot initialize OGNL evaluator", e);
         }
     }
 }