/*
    * Copyright 2004-2005 Dan Washusen
    *
    * 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 org.reactive.beans.factory.config;
  
  import org.springframework.beans.factory.config.*;
  import org.springframework.beans.factory.BeanNameAware;
  import org.springframework.beans.factory.BeanFactoryAware;
  import org.springframework.beans.factory.BeanFactory;
  import org.springframework.beans.factory.BeanDefinitionStoreException;
  import org.springframework.beans.BeansException;
  import org.springframework.beans.MutablePropertyValues;
  import org.springframework.beans.PropertyValue;
  import org.springframework.core.Ordered;
  import org.springframework.util.ObjectUtils;
  
  import java.util.*;
  
  
  /***
   * Allows for configuration of individual bean property values from a configuration resource.
   *
   * <p>Note: This class is based heavily on the org.springframework.beans.factory.config.PropertyPlaceholderConfigurer by Juergen Hoeller</p>
   *
   * @author Dan Washusen
   * @version $Id: ConfigurationPlaceholderProcessor.java,v 1.1 2004/12/26 23:42:29 dan_washusen Exp $
   * @since 16.12.2004
   */
  public class ConfigurationPlaceholderProcessor
          implements BeanFactoryPostProcessor, Ordered, BeanNameAware, BeanFactoryAware {
      /*** The position in the set of BeanFactoryPostProcessor that this will be processed in */
      private int order = Integer.MAX_VALUE;  // default: same as non-Ordered
      /*** The beans name as defined in the bean factory */
      private String beanName;
      /*** The bean factory itself */
      private BeanFactory beanFactory;
      /*** Used to evaluate placeholders with their actual values */
      protected PlaceholderEvaluator placeholderEvaluator;
      /*** Used to determine if the value from the bean factory requires evaluation.  By default {@link DefaultPlaceholderMatcher} is used. */
      protected PlaceholderMatcher placeholderMatcher = new DefaultPlaceholderMatcher();
  
      public int getOrder() {
          return order;
      }
  
      public void setOrder(int order) {
          this.order = order;
      }
  
      public String getBeanName() {
          return beanName;
      }
  
      public void setBeanName(String beanName) {
          this.beanName = beanName;
      }
  
      public BeanFactory getBeanFactory() {
          return beanFactory;
      }
  
      public void setBeanFactory(BeanFactory beanFactory)
              throws BeansException {
          this.beanFactory = beanFactory;
      }
  
      /***
       * Returns the implementation of {@link PlaceholderEvaluator} used to evaluate placeholder values.
       * @return The place holder eveluator
       */
      public PlaceholderEvaluator getPlaceholderEvaluator() {
          return placeholderEvaluator;
      }
  
      /***
       * Sets the implementation of {@link PlaceholderEvaluator} used to evaluate placeholder values.
       * @param placeholderEvaluator The place holder eveluator
       */
      public void setPlaceholderEvaluator(PlaceholderEvaluator placeholderEvaluator) {
          this.placeholderEvaluator = placeholderEvaluator;
      }
  
      /***
       * Returns the implementation of {@link PlaceholderMatcher} used to determine if a value requires evalutation.
       * @return The place holder matcher
       */
     public PlaceholderMatcher getPlaceholderMatcher() {
         return placeholderMatcher;
     }
 
     /***
      * Sets the implementation of {@link PlaceholderMatcher} used to determine if a value requires evalutation.
      * @param placeholderEvaluator The place holder matcher
      */
     public void setPlaceholderMatcher(PlaceholderMatcher placeholderMatcher) {
         this.placeholderMatcher = placeholderMatcher;
     }
 
     /***
      * Processes the bean definitions available in the provided ConfigurableListableBeanFactory.
      * <p>This method ensures it does not process itself or other bean factories.</p>
      * @param configurableListableBeanFactory The bean factory to process.
      * @throws BeansException If an error occurrs while processing a bean definition
      */
     public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory)
             throws BeansException {
         // loop over all the bean definitions processing them as appropriate
         String[] beanNames = configurableListableBeanFactory.getBeanDefinitionNames();
 		for (int i = 0; i < beanNames.length; i++) {
 			// Check that we're not parsing our own bean definition,
 			// to avoid failing on unresolvable placeholders in properties file locations.
 			if (!(beanNames[i].equals(getBeanName()) && configurableListableBeanFactory.equals(getBeanFactory()))) {
 				BeanDefinition beanDefinition = configurableListableBeanFactory.getBeanDefinition(beanNames[i]);
 
 				try {
 					processBeanDefinition(beanDefinition);
 				}
 				catch (BeanDefinitionStoreException e) {
 					throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanNames[i], e.getMessage(), e);
 				}
 			}
 		}
     }
 
     /***
      * Process a single bean definition, processing the property values, indexed argument and generic argument contrsuctor values if there are any.
      * @param beanDefinition The bean definition to be processed
      */
     protected void processBeanDefinition(BeanDefinition beanDefinition) {
         // process the property values if there are any
         MutablePropertyValues mutablePropertyValues = beanDefinition.getPropertyValues();
         if (mutablePropertyValues != null) {
             processPropertyValues(beanDefinition.getPropertyValues());
         }
 
         // process the contructor values if there are any
 		ConstructorArgumentValues constructorArgumentValues = beanDefinition.getConstructorArgumentValues();
 		if (constructorArgumentValues != null) {
 			processConstructorArgumentValues(constructorArgumentValues.getIndexedArgumentValues().values());
 			processConstructorArgumentValues(constructorArgumentValues.getGenericArgumentValues());
 		}
     }
 
     /***
      * Process the property values.
      * @param mutablePropertyValues The mutable property values
      */
     protected void processPropertyValues(MutablePropertyValues mutablePropertyValues) {
 		PropertyValue[] propertyValues = mutablePropertyValues.getPropertyValues();
 
         // for each property parse the property value
 		for (int i = 0; i < propertyValues.length; i++) {
 			PropertyValue propertyValue = propertyValues[i];
 
 			Object parsedValue = processValue(propertyValue.getValue());
 
             // if the value isn't the same as the original set the new value
 			if (!ObjectUtils.nullSafeEquals(parsedValue, propertyValue.getValue())) {
 				mutablePropertyValues.addPropertyValue(propertyValue.getName(), parsedValue);
 			}
 		}
 	}
 
     /***
      * Process the constructor argument values.
      * @param genericArgumentValues the constructor argument values
      */
     protected void processConstructorArgumentValues(Collection genericArgumentValues) {
         // for each constructor property parse the value
         for (Iterator it = genericArgumentValues.iterator(); it.hasNext();) {
 			ConstructorArgumentValues.ValueHolder valueHolder =	(ConstructorArgumentValues.ValueHolder) it.next();
 
 			Object parsedValue = processValue(valueHolder.getValue());
 
             // if the value isn't the same as the original set the new value
 			if (!ObjectUtils.nullSafeEquals(parsedValue, valueHolder.getValue())) {
 				valueHolder.setValue(parsedValue);
 			}
 		}
     }
 
     /***
      * Parses the value by delegating to a more appropriate parse method.
      * @param value The value to be parsed
      * @return The parsed value
      */
     protected Object processValue(Object value) {
         if (value instanceof String) {
             return processString((String) value);
         }
         else if (value instanceof RuntimeBeanReference) {
             RuntimeBeanReference runtimeBeanReference = (RuntimeBeanReference) value;
 
             Object parsedBeanName = processString(runtimeBeanReference.getBeanName());
 
             // check that the parsed bean name is an instance of String and panic if it isn't
             if (!(parsedBeanName instanceof String))
                 throw new InvalidPlaceholderException("Runtime bean reference of name '" + runtimeBeanReference.getBeanName() + "' has been evaluated and it doesn't appear to be an instance of String.");
 
             if (!parsedBeanName.equals(runtimeBeanReference.getBeanName())) {
                 return new RuntimeBeanReference((String) parsedBeanName);
             }
         }
         else if (value instanceof List) {
             processList((List) value);
         }
         else if (value instanceof Set) {
             processSet((Set) value);
         }
         else if (value instanceof Map) {
             processMap((Map) value);
         }
         else if (value instanceof BeanDefinition) {
             processBeanDefinition((BeanDefinition) value);
         }
         else if (value instanceof BeanDefinitionHolder) {
             processBeanDefinition(((BeanDefinitionHolder) value).getBeanDefinition());
         }
 
         return value;
     }
 
     /***
      * This is the root of all parsing.  In the end everything (should) evaluate down to a String.  Here, if the
      * {@link #getPlaceholderMatcher() placeholder matcher} confirms that value needs evaluating, we look up the
      * value using the {@link #getPlaceholderEvaluator() evaluator} and return the matching object.
      * @param value The value to the evaluated
      * @return The object returned from the evaluator if the value was evaluated, otherwise the original value
      */
     protected Object processString(String value) {
         // init the placeholderMatcher with the new value
         PlaceholderMatcher placeholderMatcher = getPlaceholderMatcher();
         placeholderMatcher.init(value);
 
         // if no palceholders are present then return the original value
         if (!placeholderMatcher.isPlaceholderPresent())
             return value;
 
         // if the value contains multiple placeholders then we presume the result is a string
         // we need to iterate over all the placeholders and concatenate them together with the
         // surrounding text
         if (placeholderMatcher.isMultiplePlaceholdersPresent()) {
             StringBuffer evaluatedValueBuffer = new StringBuffer();
             while (placeholderMatcher.hasNext()) {
                 // append the proceeding text
                 String proceedingText = placeholderMatcher.getProceedingText();
                 if (proceedingText != null)
                     evaluatedValueBuffer.append(proceedingText);
 
                 // evaluate the current placeholder
                 Placeholder placeholder = placeholderMatcher.next();
 
                 // check to see if the placeholder is a string, if not it's all broken
                 if (placeholder.getType() != String.class)
                     throw new InvalidPlaceholderException("A value that contains more than one place holder must contain all strings.");
 
                 Object evaluatedValue = getPlaceholderEvaluator().evaluate(placeholder);
                 evaluatedValueBuffer.append(evaluatedValue);
             }
 
             // append any trailing text that was in the value
             String trailingText = placeholderMatcher.getTrailingText();
             if (trailingText != null)
                 evaluatedValueBuffer.append(trailingText);
 
             return evaluatedValueBuffer.toString();
         }
         // we have a single placeholder to evalutate so evaluate it
         else {
             // move to the first (and only) placeholder
             placeholderMatcher.hasNext();
             Placeholder placeholder = placeholderMatcher.next();
             return getPlaceholderEvaluator().evaluate(placeholder);
         }
     }
 
     /***
 	 * Parse the given List, resolving its values if necessary.
      * @param listValue The list to be evaluated
 	 */
 	protected void processList(List listValue) {
 		for (int i = 0; i < listValue.size(); i++) {
 			Object element = listValue.get(i);
 
 			Object parsedValue = processValue(element);
 
             // if the parsed value isn't the same the parsed value then replace the original value
 			if (!ObjectUtils.nullSafeEquals(parsedValue, element)) {
 				listValue.set(i, parsedValue);
 			}
 		}
 	}
 
     /***
      * Parse the given Set, resolving its values if necessary.
      * @param setValue The set to be evaluated
      */
 	protected void processSet(Set setValue) {
 		for (Iterator iterator = new HashSet(setValue).iterator(); iterator.hasNext();) {
 			Object element = iterator.next();
 
 			Object parsedValue = processValue(element);
 
             // if the parsed value isn't the same the parsed value then replace the original value
 			if (!ObjectUtils.nullSafeEquals(parsedValue, element)) {
 				setValue.remove(element);
 				setValue.add(parsedValue);
 			}
 		}
 	}
 
 	/***
 	 * Parse the given Map, resolving its values if necessary.
      * @param mapValue The map to be evaluated
 	 */
 	protected void processMap(Map mapValue) {
 		for (Iterator iterator = mapValue.entrySet().iterator(); iterator.hasNext();) {
             Map.Entry entry = (Map.Entry) iterator.next();
 
 			Object parsedKey = processValue(entry.getKey());
 
 			boolean isNewKey = !ObjectUtils.nullSafeEquals(entry.getKey(), parsedKey);
 
 			Object parsedValue = processValue(entry.getValue());
 
             // if the key changed then remove the old key
 			if (isNewKey) {
 				mapValue.remove(entry.getKey());
 			}
 
             // if the key changed or the value is new then replace it
 			if (isNewKey || !ObjectUtils.nullSafeEquals(parsedValue, entry.getValue())) {
 				mapValue.put(parsedKey, parsedValue);
 			}
 		}
 	}
 }