package org.kuali.spring.util;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.List;

 import java.util.Properties;

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 import org.springframework.util.ObjectUtils;

 public class PropertiesResolver extends PlaceholderStringResolver {

         private static final Logger logger = LoggerFactory.getLogger(PropertiesResolver.class);

         public static final boolean DEFAULT_IS_SORT = true;

         boolean sort = DEFAULT_IS_SORT;

         protected class ResolvePropertyContext {

                 public ResolvePropertyContext(List<String> keys, String key, Properties properties,

                                 Properties resolvedProperties, ValueRetriever retriever) {

                         super();

                         this.keys = keys;

                         this.key = key;

                         this.properties = properties;

                         this.resolvedProperties = resolvedProperties;

                         this.retriever = retriever;

                 }

                 List<String> keys;

                 String key;

                 Properties properties;

                 Properties resolvedProperties;

                 ValueRetriever retriever;

                 public List<String> getKeys() {

                         return keys;

                 }

                 public void setKeys(List<String> keys) {

                         this.keys = keys;

                 }

                 public String getKey() {

                         return key;

                 }

                 public void setKey(String key) {

                         this.key = key;

                 }

                 public Properties getProperties() {

                         return properties;

                 }

                 public void setProperties(Properties properties) {

                         this.properties = properties;

                 }

                 public Properties getResolvedProperties() {

                         return resolvedProperties;

                 }

                 public void setResolvedProperties(Properties resolvedProperties) {

                         this.resolvedProperties = resolvedProperties;

                 }

                 public ValueRetriever getRetriever() {

                         return retriever;

                 }

                 public void setRetriever(ValueRetriever retriever) {

                         this.retriever = retriever;

                 }

         }

         /**

          * Resolve any placeholders in the Properties object passed in

          */

         public Properties resolve(Properties properties) {

                 return resolve(properties, new PropertiesRetriever(properties));

         }

         /**

          * Resolve any placeholders in the Properties object passed in, using the ValueRetriever passed in to locate

          * replacement values for placeholder text

          */

         public Properties resolve(Properties properties, ValueRetriever retriever) {

                 // Storage for resolved properties

                 Properties resolvedProperties = new Properties();

                 // Store the keys in a list so we can sort them if needed

                 List<String> keys = new ArrayList<String>(properties.stringPropertyNames());

                 if (isSort()) {

                         // Resolve them in sorted order

                         Collections.sort(keys);

                 }

                 // Iterate through the keys, resolving both keys and values as we go

                 for (String key : keys) {

                         resolveProperty(new ResolvePropertyContext(keys, key, properties, resolvedProperties, retriever));

                 }

                 return resolvedProperties;

         }

         protected void resolveProperty(ResolvePropertyContext ctx) {

                 String key = ctx.getKey();

                 Properties properties = ctx.getProperties();

                 // First resolve the key

                 String resolvedKey = resolve(key, ctx.getRetriever());

                 // Emit an info level message when a key is resolved to a new value

                 if (!key.equals(resolvedKey)) {

                         logger.info("Resolved key [{}]->[{}]", key, resolvedKey);

                 }

                 // Obtain a value for the key

                 String value = properties.getProperty(key);

                 // Resolve any placeholders in the value

                 String resolvedValue = resolve(value, ctx.getRetriever());

                 // Check for duplicates

                 duplicatePropertyCheck(ctx, resolvedKey, resolvedValue);

                 // Emit an info level message when a value gets resolved to something new

                 if (!value.equals(resolvedValue)) {

                         logger.info("Resolved value for '" + resolvedKey + "'  [{}]->[{}]",

                                         plogger.getLogValue(resolvedKey, value), plogger.getLogValue(resolvedKey, resolvedValue));

                 }

                 logger.debug("Adding resolved property {}=[{}]", resolvedKey, plogger.getLogValue(resolvedKey, resolvedValue));

                 // Store the resolved key/value pair

                 ctx.getResolvedProperties().setProperty(resolvedKey, resolvedValue);

         }

         /**

          * A duplicate property can occur when resolving placeholders inside a key.

          * 

          * For example, given a properties file with the following entries:<br>

          * <code>

          * cat=lion

          * lion.speed=fast

          * ${cat}.speed=slow

          * </code>

          * 

          * The key ${cat}.speed will resolve to 'lion.speed' which duplicates the original entry in the properties file

          */

         protected void duplicatePropertyCheck(ResolvePropertyContext ctx, String resolvedKey, String resolvedValue) {

                 String rawKey = ctx.getKey();

                 Properties properties = ctx.getProperties();

                 // The keys are the same, can't be a duplicate property, nothing to do

                 if (rawKey.equals(resolvedKey)) {

                         return;

                 }

                 // The keys are not the same, but resolvedKey is a new key, nothing to do

                 if (!ctx.getKeys().contains(resolvedKey)) {

                         return;

                 }

                 // If we get this far, the keys are not the same, and resolved key points to a property that already exists

                 // Extract the existing value

                 String existingValue = properties.getProperty(resolvedKey);

                 // Check the values

                 if (ObjectUtils.nullSafeEquals(existingValue, resolvedValue)) {

                         // The values are the same, just emit a warning and proceed

                         logger.warn("Duplicate property detected for '" + resolvedKey + "'.  '" + rawKey + "' resolved to '"

                                         + resolvedKey + "' which already has a value. Both values are the same: [{}]",

                                         plogger.getLogValue(resolvedKey, existingValue));

                         return;

                 } else {

                         // Otherwise we have an issue

                         StringBuilder sb = new StringBuilder();

                         sb.append("Duplicate property value detected for '" + resolvedKey + "'.");

                         sb.append("  The key '" + rawKey + "' resolved to '" + resolvedKey

                                         + "' and there is a value for that key already present.");

                         sb.append("  Existing value:[" + existingValue + "]  New Value:[" + resolvedValue + "]");

                         throw new IllegalArgumentException(sb.toString());

                 }

         }

         public boolean isSort() {

                 return sort;

         }

         public void setSort(boolean sort) {

                 this.sort = sort;

         }

 }