/*
    * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH
    *
    * Licensed 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 de.smartics.properties.spi.config.resolve;
  
  import java.util.ArrayList;
  import java.util.LinkedHashSet;
  import java.util.Set;
  
  import org.apache.commons.lang.StringUtils;
  
  import de.smartics.properties.api.config.domain.UnknownPropertyException;
  import de.smartics.properties.api.core.domain.PropertyValidationException;
  
  /**
   * Replaces place holders by their values.
   */
  class Resolver
  {
  
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The context that provides access to properties.
     */
    private final ResolveContext context;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    Resolver(final ResolveContext context)
    {
      this.context = context;
    }
  
    // ****************************** Inner Classes *****************************
  
    /**
     * Helper to detect recursion.
     */
    private static final class RecursionDetection
    {
      // ******************************** Fields ********************************
  
      // --- constants ----------------------------------------------------------
  
      // --- members ------------------------------------------------------------
  
      /**
       * The already encountered path.
       */
      private final Set<String> path;
  
      // ***************************** Initializer ******************************
  
      // ***************************** Constructors *****************************
  
      private RecursionDetection()
      {
        this.path = new LinkedHashSet<String>();
      }
  
      private RecursionDetection(final RecursionDetection parent)
      {
        this.path = new LinkedHashSet<String>(parent.path);
      }
  
      // ***************************** Inner Classes ****************************
  
      // ******************************** Methods *******************************
  
      // --- init ---------------------------------------------------------------
  
      // --- get&set ------------------------------------------------------------
  
      // --- business -----------------------------------------------------------
  
      private void checkRecursion(final String key)
        throws RecursivePropertyException
      {
        if (path.contains(key))
        {
         throw new RecursivePropertyException(key, new ArrayList<String>(path));
       }
       path.add(key);
     }
 
     // --- object basics ------------------------------------------------------
 
     @Override
     public String toString()
     {
       return path.toString();
     }
   }
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * Resolves the expression.
    *
    * @param expression the expression to resolve.
    * @return the requested value or <code>null</code> if there is no value for
    *         that key.
    * @throws UnresolvablePropertyException if the property cannot be resolved.
    * @throws UnknownPropertyException if a referenced property found in the
    *           expression is not known.
    * @throws PropertySecurityException if a referenced property found in the
    *           expression is invalid according to its constraints.
    */
   String resolve(final String expression) throws UnresolvablePropertyException,
     UnknownPropertyException, PropertyValidationException
   {
     return resolve(new RecursionDetection(), expression);
   }
 
   private String resolve(final RecursionDetection recursionDetection,
       final String expression) throws RecursivePropertyException
   {
     if (StringUtils.isBlank(expression))
     {
       return expression;
     }
 
     final int length = expression.length();
     final StringBuilder buffer = new StringBuilder(length * 2);
     int i = 0;
     while (i < length)
     {
       final char c = expression.charAt(i++);
       if (c == '$' && i < length - 1 && expression.charAt(i) == '{')
       {
         final RecursionDetection recursionDetection2 =
             new RecursionDetection(recursionDetection);
         i = parsePlaceHolder(recursionDetection2, expression, buffer, i);
       }
       else
       {
         buffer.append(c);
       }
     }
 
     return buffer.toString();
   }
 
   private int parsePlaceHolder(final RecursionDetection recursionDetection,
       final String expression, final StringBuilder buffer, final int index)
     throws RecursivePropertyException
   {
     final int length = expression.length() - 1;
     int i = index;
 
     final StringBuilder keyBuffer = new StringBuilder(64);
     i = readKey(expression, length, i, keyBuffer);
     final String key = keyBuffer.toString();
     recursionDetection.checkRecursion(key);
     final String replacement = context.get(key);
     if (replacement == null)
     {
       throw new NullValuePropertyException(key, new ArrayList<String>(
           recursionDetection.path));
     }
     final String resolved = resolve(recursionDetection, replacement);
     buffer.append(resolved);
     return i + 1;
   }
 
   private int readKey(final String expression, final int length,
       final int index, final StringBuilder keyBuffer)
   {
     int i = index;
     char n = expression.charAt(++i);
     while (n != '}' && i < length)
     {
       keyBuffer.append(n);
       n = expression.charAt(++i);
     }
     return i;
   }
 
   // --- object basics --------------------------------------------------------
 
 }