/*
    * $Id: PatternUtil.java 1594481 2014-05-14 06:52:35Z 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.definition.pattern;
  
  import java.text.MessageFormat;
  import java.util.ArrayList;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Set;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import org.apache.tiles.Attribute;
  import org.apache.tiles.Definition;
  import org.apache.tiles.Expression;
  import org.apache.tiles.ListAttribute;
  
  /**
   * Utilities for pattern matching and substitution.
   *
   * @version $Rev: 1594481 $ $Date: 2014-05-14 16:52:35 +1000 (Wed, 14 May 2014) $
   * @since 2.2.0
   */
  public final class PatternUtil {
  
      /**
       * The root locale. Notice that this is a replacement for Locale.ROOT for
       * Java 1.6.
       */
      private static final Locale ROOT_LOCALE = new Locale("", "");
  
      /** Pattern to find {.*} occurrences that do not match {[0-9]+} so to prevent MessageFormat from crashing.
       */
      private static final Pattern INVALID_FORMAT_ELEMENT = Pattern.compile("\\{[^}0-9]+\\}");
  
      /**
       * Private constructor to avoid instantiation.
       */
      private PatternUtil() {
      }
  
      /**
       * Creates a definition given its representation with wildcards and
       * attribute values with placeholders, replacing real values into
       * placeholders.
       *
       * @param d The definition to replace.
       * @param name The name of the definition to be created.
       * @param varsOrig The variables to be substituted.
       * @return The definition that can be rendered.
       * @since 2.2.0
       */
      public static Definition replacePlaceholders(Definition d, String name,
              Object... varsOrig) {
  
          Object[] vars = replaceNullsWithBlank(varsOrig);
  
          Definition nudef = new Definition();
  
          nudef.setExtends(replace(d.getExtends(), vars));
          nudef.setName(name);
          nudef.setPreparer(replace(d.getPreparer(), vars));
          Attribute templateAttribute = d.getTemplateAttribute();
          if (templateAttribute != null) {
              nudef.setTemplateAttribute(replaceVarsInAttribute(
                      templateAttribute, vars));
          }
  
          Set<String> attributeNames = d.getLocalAttributeNames();
          if (attributeNames != null && !attributeNames.isEmpty()) {
              for (String attributeName : attributeNames) {
                  Attribute attr = d.getLocalAttribute(attributeName);
                  Attribute nuattr = replaceVarsInAttribute(attr, vars);
  
                  nudef.putAttribute(replace(attributeName, vars), nuattr);
              }
          }
  
         attributeNames = d.getCascadedAttributeNames();
         if (attributeNames != null && !attributeNames.isEmpty()) {
             for (String attributeName : attributeNames) {
                 Attribute attr = d.getCascadedAttribute(attributeName);
                 Attribute nuattr = replaceVarsInAttribute(attr, vars);
 
                 nudef.putAttribute(replace(attributeName, vars), nuattr, true);
             }
         }
 
         return nudef;
     }
 
     /**
      * Creates a new map that contains all the entries of the
      * <code>defsMap</code> whose keys are contained in <code>keys</code>.
      *
      * @param map The map to read.
      * @param keys The keys to extract.
      * @param <K> The key of the map.
      * @param <V> The value of the map.
      * @return The extracted map.
      * @since 2.2.1
      */
     public static <K, V> Map<K, V> createExtractedMap(Map<K, V> map, Set<K> keys) {
         Map<K, V> retValue = new LinkedHashMap<K, V>();
         for (K key : keys) {
             retValue.put(key, map.get(key));
         }
         return retValue;
     }
 
     /**
      * Replaces variables into an attribute.
      *
      * @param attr The attribute to be used as a basis, containing placeholders
      * for variables.
      * @param vars The variables to replace.
      * @return A new instance of an attribute, whose properties have been
      * replaced with variables' values.
      */
     private static Attribute replaceVarsInAttribute(Attribute attr,
             Object... vars) {
         Attribute nuattr;
         if (attr instanceof ListAttribute) {
             nuattr = replaceVarsInListAttribute((ListAttribute) attr, vars);
         } else {
             nuattr = replaceVarsInSimpleAttribute(attr, vars);
         }
         return nuattr;
     }
 
     /**
      * Replaces variables into a simple (not list) attribute.
      *
      * @param attr The attribute to be used as a basis, containing placeholders
      * for variables.
      * @param vars The variables to replace.
      * @return A new instance of an attribute, whose properties have been
      * replaced with variables' values.
      */
     private static Attribute replaceVarsInSimpleAttribute(Attribute attr,
             Object... vars) {
         Attribute nuattr;
         nuattr = new Attribute();
 
         nuattr.setRole(replace(attr.getRole(), vars));
         nuattr.setRenderer(attr.getRenderer());
         Expression expressionObject = attr.getExpressionObject();
         if (expressionObject != null) {
             Expression newExpressionObject = Expression
                     .createExpression(replace(expressionObject.getExpression(), vars), expressionObject.getLanguage());
             nuattr.setExpressionObject(newExpressionObject);
         }
 
         Object value = attr.getValue();
         if (value instanceof String) {
             value = replace((String) value, vars);
         }
         nuattr.setValue(value);
         return nuattr;
     }
 
     /**
      * Replaces variables into a list attribute.
      *
      * @param listAttr The attribute to be used as a basis, containing attributes
      * that may contain placeholders for variables.
      * @param vars The variables to replace.
      * @return A new instance of an attribute, whose properties have been
      * replaced with variables' values.
      */
     private static Attribute replaceVarsInListAttribute(ListAttribute listAttr,
             Object... vars) {
         Attribute nuattr;
         ListAttribute nuListAttr = new ListAttribute();
         nuListAttr.setInherit(listAttr.isInherit());
         List<Attribute> nuItems = nuListAttr.getValue();
         for (Object item : listAttr.getValue()) {
             Attribute child = (Attribute) item;
             child = replaceVarsInAttribute(child, vars);
             nuItems.add(child);
         }
         nuattr = nuListAttr;
         return nuattr;
     }
 
     /**
      * Replaces a string with placeholders using values of a variable map.
      *
      * @param st The string to replace.
      * @param vars The variables.
      * @return The replaced string.
      */
     private static String replace(String st, Object... vars) {
         if (st != null && st.indexOf('{') >= 0) {
 
             // replace them with markers
             List<String> originals = new ArrayList<String>();
             for(Matcher m = INVALID_FORMAT_ELEMENT.matcher(st); m.find() ; m = INVALID_FORMAT_ELEMENT.matcher(st)) {
                 originals.add(m.group());
                 st = m.replaceFirst("INVALID_FORMAT_ELEMENT");
             }
 
             // do the MessageFormat replacement (escaping quote characters)
             st = new MessageFormat(st.replaceAll("'", "'''"), ROOT_LOCALE)
                     .format(vars, new StringBuffer(), null).toString();
 
             // return the markers to their original invalid occurrences
             for (String original : originals) {
                 st = st.replaceFirst("INVALID_FORMAT_ELEMENT", original);
             }
         }
         return st;
     }
 
     private static Object[] replaceNullsWithBlank(Object[] varsOrig) {
         Object[] vars = new Object[varsOrig.length];
         for(int i = 0; i < varsOrig.length; ++i) {
             vars[i] = null != varsOrig[i] ? varsOrig[i] : "";
         }
         return vars;
     }
 }