/*

  * $Id: BasicTilesContainer.java 1330672 2012-04-26 06:58:16Z nlebas $

  *

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

 import java.io.IOException;

 import java.util.Deque;

 import java.util.LinkedList;

 import java.util.Map;

 import org.apache.tiles.Attribute;

 import org.apache.tiles.AttributeContext;

 import org.apache.tiles.BasicAttributeContext;

 import org.apache.tiles.Definition;

 import org.apache.tiles.TilesContainer;

 import org.apache.tiles.definition.DefinitionsFactory;

 import org.apache.tiles.definition.NoSuchDefinitionException;

 import org.apache.tiles.evaluator.AttributeEvaluator;

 import org.apache.tiles.evaluator.AttributeEvaluatorFactory;

 import org.apache.tiles.evaluator.AttributeEvaluatorFactoryAware;

 import org.apache.tiles.preparer.ViewPreparer;

 import org.apache.tiles.preparer.factory.NoSuchPreparerException;

 import org.apache.tiles.preparer.factory.PreparerFactory;

 import org.apache.tiles.request.ApplicationContext;

 import org.apache.tiles.request.Request;

 import org.apache.tiles.request.render.CannotRenderException;

 import org.apache.tiles.request.render.Renderer;

 import org.apache.tiles.request.render.RendererFactory;

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 /**

  * Basic implementation of the tiles container interface.

  * In most cases, this container will be customized by

  * injecting customized services, not necessarily by

  * override the container

  *

  * @since 2.0

  * @version $Rev: 1330672 $ $Date: 2012-04-26 16:58:16 +1000 (Thu, 26 Apr 2012) $

  */

 public class BasicTilesContainer implements TilesContainer,

         AttributeEvaluatorFactoryAware {

     /**

      * Name used to store attribute context stack.

      */

     private static final String ATTRIBUTE_CONTEXT_STACK =

         "org.apache.tiles.AttributeContext.STACK";

     /**

      * Log instance for all BasicTilesContainer

      * instances.

      */

     private final Logger log = LoggerFactory

             .getLogger(BasicTilesContainer.class);

     /**

      * The Tiles application context object.

      */

     private ApplicationContext context;

     /**

      * The definitions factory.

      */

     private DefinitionsFactory definitionsFactory;

     /**

      * The preparer factory.

      */

     private PreparerFactory preparerFactory;

     /**

      * The renderer factory.

      */

     private RendererFactory rendererFactory;

     /**

      * The attribute evaluator.

      */

     private AttributeEvaluatorFactory attributeEvaluatorFactory;

     /** {@inheritDoc} */

     public AttributeContext startContext(Request request) {

         AttributeContext context = new BasicAttributeContext();

         Deque<AttributeContext>  stack = getContextStack(request);

         if (!stack.isEmpty()) {

             AttributeContext parent = stack.peek();

             context.inheritCascadedAttributes(parent);

         }

         stack.push(context);

         return context;

     }

     /** {@inheritDoc} */

     public void endContext(Request request) {

         popContext(request);

     }

     /** {@inheritDoc} */

     public void renderContext(Request request) {

         AttributeContext attributeContext = getAttributeContext(request);

         render(request, attributeContext);

     }

     /**

      * Returns the Tiles application context used by this container.

      *

      * @return the application context for this container.

      */

     public ApplicationContext getApplicationContext() {

         return context;

     }

     /**

      * Sets the Tiles application context to use.

      *

      * @param context The Tiles application context.

      */

     public void setApplicationContext(ApplicationContext context) {

         this.context = context;

     }

     /** {@inheritDoc} */

     public AttributeContext getAttributeContext(Request request) {

         AttributeContext context = getContext(request);

         if (context == null) {

             context = new BasicAttributeContext();

             pushContext(context, request);

         }

         return context;

     }

     /**

      * Returns the definitions factory.

      *

      * @return The definitions factory used by this container.

      */

     public DefinitionsFactory getDefinitionsFactory() {

         return definitionsFactory;

     }

     /**

      * Set the definitions factory. This method first ensures

      * that the container has not yet been initialized.

      *

      * @param definitionsFactory the definitions factory for this instance.

      */

     public void setDefinitionsFactory(DefinitionsFactory definitionsFactory) {

         this.definitionsFactory = definitionsFactory;

     }

     /**

      * Returns the preparer factory used by this container.

      *

      * @return return the preparerInstance factory used by this container.

      */

     public PreparerFactory getPreparerFactory() {

         return preparerFactory;

     }

     /**

      * Set the preparerInstance factory.  This method first ensures

      * that the container has not yet been initialized.

      *

      * @param preparerFactory the preparerInstance factory for this conainer.

      */

     public void setPreparerFactory(PreparerFactory preparerFactory) {

         this.preparerFactory = preparerFactory;

     }

     /**

      * Sets the renderer instance factory.

      *

      * @param rendererFactory the renderer instance factory for this container.

      * @since 2.1.0

      */

     public void setRendererFactory(RendererFactory rendererFactory) {

         this.rendererFactory = rendererFactory;

     }

     /** {@inheritDoc} */

     public void setAttributeEvaluatorFactory(

             AttributeEvaluatorFactory attributeEvaluatorFactory) {

         this.attributeEvaluatorFactory = attributeEvaluatorFactory;

     }

     /** {@inheritDoc} */

     public void prepare(String preparer, Request request) {

         prepare(request, preparer, false);

     }

     /** {@inheritDoc} */

     public void render(String definitionName, Request request) {

         log.debug("Render request received for definition '{}'", definitionName);

         Definition definition = getDefinition(definitionName, request);

         if (definition == null) {

             throw new NoSuchDefinitionException("Unable to find the definition '" + definitionName + "'");

         }

         render(definition, request);

     }

     /**

      * Renders the specified definition.

      * @param definition The definition to render.

      * @param request The request context.

      * @since 2.1.3

      */

     public void render(Definition definition, Request request) {

         AttributeContext originalContext = getAttributeContext(request);

         BasicAttributeContext subContext = new BasicAttributeContext(originalContext);

         subContext.inherit(definition);

         pushContext(subContext, request);

         try {

             render(request, subContext);

         } finally {

             popContext(request);

         }

     }

     /** {@inheritDoc} */

     public void render(Attribute attr, Request request)

         throws IOException {

         if (attr == null) {

             throw new CannotRenderException("Cannot render a null attribute");

         }

         if (attr.isPermitted(request)) {

             Renderer renderer = rendererFactory.getRenderer(attr.getRenderer());

             Object value = evaluate(attr, request);

             if (!(value instanceof String)) {

                 throw new CannotRenderException(

                         "Cannot render an attribute that is not a string, toString returns: "

                                 + value);

             }

             renderer.render((String) value, request);

         }

     }

     /** {@inheritDoc} */

     public Object evaluate(Attribute attribute, Request request) {

         AttributeEvaluator evaluator = attributeEvaluatorFactory

                 .getAttributeEvaluator(attribute);

         return evaluator.evaluate(attribute, request);

     }

     /** {@inheritDoc} */

     public boolean isValidDefinition(String definitionName, Request request) {

         try {

             Definition definition = getDefinition(definitionName, request);

             return definition != null;

         } catch (NoSuchDefinitionException nsde) {

             log.debug("Cannot find definition '{}'", definitionName);

             log.debug("Exception related to the not found definition", nsde);

             return false;

         }

     }

     /** {@inheritDoc} */

     @Override

     public Definition getDefinition(String definitionName,

             Request request) {

         Definition definition =

             definitionsFactory.getDefinition(definitionName, request);

         return definition;

     }

     /**

      * Returns the context stack.

      *

      * @param tilesContext The Tiles context object to use.

      * @return The needed stack of contexts.

      * @since 2.0.6

      */

     @SuppressWarnings("unchecked")

     protected Deque<AttributeContext> getContextStack(Request tilesContext) {

         Map<String, Object> requestScope = tilesContext.getContext("request");

         Deque<AttributeContext> contextStack = (Deque<AttributeContext>) requestScope

                 .get(ATTRIBUTE_CONTEXT_STACK);

         if (contextStack == null) {

             contextStack = new LinkedList<AttributeContext>();

             requestScope.put(ATTRIBUTE_CONTEXT_STACK, contextStack);

         }

         return contextStack;

     }

     /**

      * Pushes a context object in the stack.

      *

      * @param context The context to push.

      * @param tilesContext The Tiles context object to use.

      * @since 2.0.6

      */

     protected void pushContext(AttributeContext context,

             Request tilesContext) {

         Deque<AttributeContext> contextStack = getContextStack(tilesContext);

         contextStack.push(context);

     }

     /**

      * Pops a context object out of the stack.

      *

      * @param tilesContext The Tiles context object to use.

      * @return The popped context object.

      * @since 2.0.6

      */

     protected AttributeContext popContext(Request tilesContext) {

         Deque<AttributeContext> contextStack = getContextStack(tilesContext);

         return contextStack.pop();

     }

     /**

      * Get attribute context from request.

      *

      * @param tilesContext current Tiles application context.

      * @return BasicAttributeContext or null if context is not found.

      * @since 2.0.6

      */

     protected AttributeContext getContext(Request tilesContext) {

         Deque<AttributeContext> contextStack = getContextStack(tilesContext);

         if (!contextStack.isEmpty()) {

             return contextStack.peek();

         }

         return null;

     }

     /**

      * Execute a preparer.

      *

      * @param context The request context.

      * @param preparerName The name of the preparer.

      * @param ignoreMissing If <code>true</code> if the preparer is not found,

      * it ignores the problem.

      * @throws NoSuchPreparerException If the preparer is not found (and

      * <code>ignoreMissing</code> is not set) or if the preparer itself threw an

      * exception.

      */

     private void prepare(Request context, String preparerName, boolean ignoreMissing) {

         log.debug("Prepare request received for '{}'", preparerName);

         ViewPreparer preparer = preparerFactory.getPreparer(preparerName, context);

         if (preparer == null && ignoreMissing) {

             return;

         }

         if (preparer == null) {

             throw new NoSuchPreparerException("Preparer '" + preparerName + " not found");

         }

         AttributeContext attributeContext = getContext(context);

         preparer.execute(context, attributeContext);

     }

     /**

      * Renders the specified attribute context.

      *

      * @param request The request context.

      * @param attributeContext The context to render.

      * @throws InvalidTemplateException If the template is not valid.

      * @throws CannotRenderException If something goes wrong during rendering.

      * @since 2.1.3

      */

     protected void render(Request request,

             AttributeContext attributeContext) {

         try {

             if (attributeContext.getPreparer() != null) {

                 prepare(request, attributeContext.getPreparer(), true);

             }

             render(attributeContext.getTemplateAttribute(), request);

         } catch (IOException e) {

             throw new CannotRenderException(e.getMessage(), e);

         }

     }

 }