/*

  * $Id: OptionsRenderer.java 1486577 2013-05-27 11:16:52Z 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.renderer;

 import java.io.IOException;

 import java.util.List;

 import java.util.concurrent.ConcurrentMap;

 import java.util.concurrent.TimeUnit;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 import com.google.common.cache.CacheBuilder;

 import com.google.common.cache.CacheLoader;

 import com.google.common.cache.LoadingCache;

 import org.apache.tiles.Attribute;

 import org.apache.tiles.ListAttribute;

 import org.apache.tiles.access.TilesAccess;

 import org.apache.tiles.request.ApplicationContext;

 import org.apache.tiles.request.Request;

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

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 /**

  * Provides a custom "options" syntax for attributes.

  * The first option that can be rendered is.

  * Comes from <a href="http://tech.finn.no/the-ultimate-view/">The Ultimate View</a> article.<p/>

  *

  * Actual rendering is delegated to the TypeDetectingRenderer that's supplied in the constructor.<p/>

  *

  * For example:

  * "/WEB-INF/tiles/fragments/${options[myoptions]}/content.jsp"

  * given the myptions list-attribute is defined like:

  * <pre>

         <put-list-attribute name="myoptions">

             <add-list-attribute>

                 <add-attribute value="car"/>

                 <add-attribute value="vechile"/>

                 <add-attribute value="advert"/>

             </add-list-attribute>

         </put-list-attribute>

    </pre>

  * will look for content.jsp <br/>

  * first in "/WEB-INF/tiles/fragments/car/" then <br/>

  * second in "/WEB-INF/tiles/fragments/vechile/" and <br/>

  * last in "/WEB-INF/tiles/fragments/advert".

  * <p/>

  * <p/>

  * Currently only supports one occurrance of such an "option" pattern in the attribute's value.

  * <p/>

  * Limitation: "looking" for templates is implemented using applicationContext.getResource(..)

  * therefore the option values in the options list need to be visible as applicationResources.

  * <p/>

  * The attribute found and rendered is cached so to improve performance on subsequent lookups.

  * The default cache time-to-live is {@value #DEFAULT_CACHE_LIFE}, specified by {@link #DEFAULT_CACHE_LIFE}.

  * It can be customised by setting the system property {@value #CACHE_LIFE_PROPERTY}, see {@link #CACHE_LIFE_PROPERTY}.

  * Setting it to zero will disable the cache.

  */

 public final class OptionsRenderer implements Renderer {

     public static final String CACHE_LIFE_PROPERTY = OptionsRenderer.class.getName() + ".cache_ttl_ms";

     public static final long DEFAULT_CACHE_LIFE = 1000 * 60 * 5;

     public static final Pattern OPTIONS_PATTERN

             = Pattern.compile(Pattern.quote("{options[") + "(.+)" + Pattern.quote("]}"));

     private static final Logger LOG = LoggerFactory.getLogger(OptionsRenderer.class);

     private final ApplicationContext applicationContext;

     private final Renderer renderer;

     public OptionsRenderer(final ApplicationContext applicationContext, final Renderer renderer) {

         this.applicationContext = applicationContext;

         this.renderer = renderer;

     }

     @Override

     public boolean isRenderable(final String path, final Request request) {

         return renderer.isRenderable(path, request);

     }

     @Override

     public void render(final String path, final Request request) throws IOException {

         Matcher matcher =  OPTIONS_PATTERN.matcher((String) path);

         if (null != matcher && matcher.find()) {

             boolean done = false;

             String match = matcher.group(1);

             ListAttribute fallbacks = (ListAttribute) TilesAccess

                     .getCurrentContainer(request)

                     .getAttributeContext(request)

                     .getAttribute(match);

             if (null == fallbacks) {

                 throw new IllegalStateException("A matching list-attribute name=\"" + match + "\" must be defined.");

             } else if (fallbacks.getValue().isEmpty()) {

                 throw new IllegalStateException(

                         "list-attribute name=\"" + match + "\" must have minimum one attribute");

             }

             for (Attribute option : (List<Attribute>) fallbacks.getValue()) {

                 String template = path.replaceFirst(Pattern.quote(matcher.group()), (String) option.getValue());

                 done = renderAttempt(template, request);

                 if (done) { break; }

             }

             if (!done) {

                 throw new IOException("None of the options existed for " + path);

             }

         } else {

             renderer.render(path, request);

         }

     }

     private boolean renderAttempt(final String template, final Request request) throws IOException {

         boolean result = false;

         if (Cache.attemptTemplate(template)) {

             try {

                 if (null != applicationContext.getResource(template)) {

                     renderer.render(template, request);

                     result = true;

                 }

             } catch (IOException ex) {

                 if (ex.getMessage().contains(template)) {

                     // expected outcome. continue loop.

                     LOG.trace(ex.getMessage());

                 } else {

                     // comes from an inner templateAttribute.render(..) so throw on

                     throw ex;

                 }

             } catch (RuntimeException ex) {

                 if (ex.getMessage().contains(template)) {

                     // expected outcome. continue loop.

                     LOG.trace(ex.getMessage());

                 } else {

                     // comes from an inner templateAttribute.render(..) so throw on

                     throw ex;

                 }

             }

             Cache.update(template, result);

         }

         return result;

     }

     private static final class Cache {

         private static final long CACHE_LIFE = Long.getLong(CACHE_LIFE_PROPERTY, DEFAULT_CACHE_LIFE);

         /** It takes CACHE_LIFE milliseconds for any hot deployments to register.

          */

         private static final ConcurrentMap<String,Boolean> TEMPLATE_EXISTS;

         static {

             LOG.info("cache_ttl_ms=" + CACHE_LIFE);

             LoadingCache<String,Boolean> builder = CacheBuilder

                     .newBuilder()

                     .expireAfterWrite(CACHE_LIFE, TimeUnit.MILLISECONDS)

                     .build(

                         new CacheLoader<String, Boolean>() {

                             @Override

                             public Boolean load(String key) {

                                 throw new UnsupportedOperationException(

                                         "illegal TEMPLATE_EXISTS.get(\"" + key

                                         + "\") before TEMPLATE_EXISTS.containsKey(\"" + key + "\")");

                             }

                         });

             TEMPLATE_EXISTS = builder.asMap();

         }

         static boolean attemptTemplate(final String template) {

             return !TEMPLATE_EXISTS.containsKey(template) || TEMPLATE_EXISTS.get(template);

         }

         static void update(final String template, final boolean found) {

             TEMPLATE_EXISTS.putIfAbsent(template, found);

         }

         private Cache() {}

     }

 }