/*

  * 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 --------------------------------------------------------

 }