/**

  * Copyright 2005-2011 The Kuali Foundation

  *

  * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php

  *

  * 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.kuali.rice.krad.uif.util;

 import org.apache.commons.lang.StringUtils;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import org.kuali.rice.krad.datadictionary.DataDictionary;

 import org.kuali.rice.krad.uif.UifConstants;

 import org.kuali.rice.krad.uif.UifPropertyPaths;

 import org.kuali.rice.krad.uif.component.Configurable;

 import org.springframework.beans.BeansException;

 import org.springframework.beans.MutablePropertyValues;

 import org.springframework.beans.PropertyValue;

 import org.springframework.beans.factory.config.BeanDefinition;

 import org.springframework.beans.factory.config.BeanDefinitionHolder;

 import org.springframework.beans.factory.config.BeanFactoryPostProcessor;

 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

 import org.springframework.beans.factory.config.TypedStringValue;

 import org.springframework.beans.factory.support.GenericBeanDefinition;

 import org.springframework.beans.factory.support.ManagedList;

 import org.springframework.beans.factory.support.ManagedMap;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.LinkedHashMap;

 import java.util.LinkedHashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 /**

  * Post processes the bean factory to handle UIF property expressions

  *

  * <p>

  * Conditional logic can be implemented with the UIF dictionary by means of property expressions. These are

  * expressions that follow SPEL and can be given as the value for a property using the @{} placeholder. Since such

  * a value would cause an exception when creating the object if the property is a non-string type (value cannot be

  * converted), we need to move those expressions to a Map for processing, and then remove the original property

  * configuration containing the expression. The expressions are then evaluated during the view apply model phase and

  * the result is set as the value for the corresponding property.

  * </p>

  *

  * @author Kuali Rice Team (rice.collab@kuali.org)

  */

 public class UifBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

     private static final Log LOG = LogFactory.getLog(UifBeanFactoryPostProcessor.class);

     /**

      * Iterates through all beans in the factory and invokes processing for expressions

      *

      * @param beanFactory - bean factory instance to process

      * @throws BeansException

      */

     @Override

     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

         Set<String> processedBeanNames = new HashSet<String>();

         LOG.info("Beginning post processing of bean factory for UIF expressions");

         String[] beanNames = beanFactory.getBeanDefinitionNames();

         for (int i = 0; i < beanNames.length; i++) {

             String beanName = beanNames[i];

             BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);

             processBeanDefinition(beanName, beanDefinition, beanFactory, processedBeanNames);

         }

         LOG.info("Finished post processing of bean factory for UIF expressions");

     }

     /**

      * If the bean class is type Component, LayoutManager, or BindingInfo, iterate through configured property values

      * and check for expressions

      *

      * <p>

      * If a expression is found for a property, it is added to the 'propertyExpressions' map and then the original

      * property value is removed to prevent binding errors (when converting to a non string type)

      * </p>

      *

      * @param beanName - name of the bean in the factory (only set for top level beans, not nested)

      * @param beanDefinition - bean definition to process for expressions

      * @param beanFactory - bean factory being processed

      */

     protected void processBeanDefinition(String beanName, BeanDefinition beanDefinition,

             ConfigurableListableBeanFactory beanFactory, Set<String> processedBeanNames) {

         Class<?> beanClass = getBeanClass(beanDefinition, beanFactory);

         if ((beanClass == null) || !Configurable.class.isAssignableFrom(beanClass)) {

             return;

         }

         if (processedBeanNames.contains(beanName)) {

             return;

         }

         LOG.debug("Processing bean name '" + beanName + "'");

         MutablePropertyValues pvs = beanDefinition.getPropertyValues();

         if (pvs.getPropertyValue(UifPropertyPaths.PROPERTY_EXPRESSIONS) != null) {

             // already processed so skip (could be reloading dictionary)

             return;

         }

         Map<String, String> propertyExpressions = new ManagedMap<String, String>();

         Map<String, String> parentPropertyExpressions = getPropertyExpressionsFromParent(beanDefinition.getParentName(),

                 beanFactory, processedBeanNames);

         boolean parentExpressionsExist = !parentPropertyExpressions.isEmpty();

         PropertyValue[] pvArray = pvs.getPropertyValues();

         for (PropertyValue pv : pvArray) {

             if (hasExpression(pv.getValue())) {

                 // process expression

                 String strValue = getStringValue(pv.getValue());

                 propertyExpressions.put(pv.getName(), strValue);

                 // remove property value so expression will not cause binding exception

                 pvs.removePropertyValue(pv.getName());

             } else {

                 // process nested objects

                 Object newValue = processPropertyValue(pv.getName(), pv.getValue(), parentPropertyExpressions,

                         propertyExpressions, beanFactory, processedBeanNames);

                 pvs.removePropertyValue(pv.getName());

                 pvs.addPropertyValue(pv.getName(), newValue);

             }

             // removed expression (if exists) from parent map since the property was set on child

             if (parentPropertyExpressions.containsKey(pv.getName())) {

                 parentPropertyExpressions.remove(pv.getName());

             }

             // if property is nested, need to override any parent expressions set on nested beans

             if (StringUtils.contains(pv.getName(), ".")) {

                 //removeParentExpressionsOnNested(pv.getName(), pvs, beanDefinition.getParentName(), beanFactory);

             }

         }

         if (!propertyExpressions.isEmpty() || parentExpressionsExist) {

             // merge two maps

             ManagedMap<String, String> mergedPropertyExpressions = new ManagedMap<String, String>();

             mergedPropertyExpressions.setMergeEnabled(false);

             mergedPropertyExpressions.putAll(parentPropertyExpressions);

             mergedPropertyExpressions.putAll(propertyExpressions);

             pvs.addPropertyValue(UifPropertyPaths.PROPERTY_EXPRESSIONS, mergedPropertyExpressions);

         }

         if (StringUtils.isNotBlank(beanName)) {

             processedBeanNames.add(beanName);

         }

     }

     protected void removeParentExpressionsOnNested(String propertyName, MutablePropertyValues pvs,

             String parentBeanName, ConfigurableListableBeanFactory beanFactory) {

         BeanDefinition parentBeanDefinition = beanFactory.getMergedBeanDefinition(parentBeanName);

         // TODO: this only handles one level of nesting

         MutablePropertyValues parentPvs = parentBeanDefinition.getPropertyValues();

         PropertyValue[] pvArray = parentPvs.getPropertyValues();

         for (PropertyValue pv : pvArray) {

             boolean isNameMatch = false;

             String nestedPropertyName = "";

             if (propertyName.startsWith(pv.getName())) {

                 nestedPropertyName = StringUtils.removeStart(propertyName, pv.getName());

                 if (nestedPropertyName.startsWith(".")) {

                     nestedPropertyName = StringUtils.removeStart(nestedPropertyName, ".");

                     isNameMatch = true;

                 }

             }

             // if property name from parent matches and is a bean definition, check for property expressions map

             if (isNameMatch && ((pv.getValue() instanceof BeanDefinition) || (pv

                     .getValue() instanceof BeanDefinitionHolder))) {

                 BeanDefinition propertyBeanDefinition;

                 if (pv.getValue() instanceof BeanDefinition) {

                     propertyBeanDefinition = (BeanDefinition) pv.getValue();

                 } else {

                     propertyBeanDefinition = ((BeanDefinitionHolder) pv.getValue()).getBeanDefinition();

                 }

                 MutablePropertyValues nestedPvs = propertyBeanDefinition.getPropertyValues();

                 if (nestedPvs.contains(UifPropertyPaths.PROPERTY_EXPRESSIONS)) {

                     PropertyValue propertyExpressionsPV = nestedPvs.getPropertyValue(

                             UifPropertyPaths.PROPERTY_EXPRESSIONS);

                     if (propertyExpressionsPV != null) {

                         Object value = propertyExpressionsPV.getValue();

                         if ((value != null) && (value instanceof ManagedMap)) {

                             Map<String, String> nestedPropertyExpressions = (ManagedMap) value;

                             if (nestedPropertyExpressions.containsKey(nestedPropertyName)) {

                                 // need to make copy of property value with expression removed from map

                                 ManagedMap<String, String> copiedPropertyExpressions = new ManagedMap<String, String>();

                                 copiedPropertyExpressions.setMergeEnabled(false);

                                 copiedPropertyExpressions.putAll(nestedPropertyExpressions);

                                 copiedPropertyExpressions.remove(nestedPropertyName);

                                 BeanDefinition copiedBeanDefinition = new GenericBeanDefinition(propertyBeanDefinition);

                                 copiedBeanDefinition.getPropertyValues().add(UifPropertyPaths.PROPERTY_EXPRESSIONS,

                                         copiedPropertyExpressions);

                                 pvs.add(pv.getName(), copiedBeanDefinition);

                             }

                         }

                     }

                 }

             }

         }

     }

     /**

      * Retrieves the class for the object that will be created from the bean definition. Since the class might not

      * be configured on the bean definition, but by a parent, each parent bean definition is recursively checked for

      * a class until one is found

      *

      * @param beanDefinition - bean definition to get class for

      * @param beanFactory - bean factory that contains the bean definition

      * @return Class<?> class configured for the bean definition, or null

      */

     protected Class<?> getBeanClass(BeanDefinition beanDefinition, ConfigurableListableBeanFactory beanFactory) {

         if (StringUtils.isNotBlank(beanDefinition.getBeanClassName())) {

             try {

                 return Class.forName(beanDefinition.getBeanClassName());

             } catch (ClassNotFoundException e) {

                 // swallow exception and return null so bean is not processed

                 return null;

             }

         } else if (StringUtils.isNotBlank(beanDefinition.getParentName())) {

             BeanDefinition parentBeanDefinition = beanFactory.getBeanDefinition(beanDefinition.getParentName());

             if (parentBeanDefinition != null) {

                 return getBeanClass(parentBeanDefinition, beanFactory);

             }

         }

         return null;

     }

     /**

      * Retrieves the property expressions map set on the bean with given name. If the bean has not been processed

      * by the bean factory post processor, that is done before retrieving the map

      *

      * @param parentBeanName - name of the parent bean to retrieve map for (if empty a new map will be returned)

      * @param beanFactory - bean factory to retrieve bean definition from

      * @param processedBeanNames - set of bean names that have been processed so far

      * @return Map<String, String> property expressions map from parent or new instance

      */

     protected Map<String, String> getPropertyExpressionsFromParent(String parentBeanName,

             ConfigurableListableBeanFactory beanFactory, Set<String> processedBeanNames) {

         Map<String, String> propertyExpressions = new HashMap<String, String>();

         if (StringUtils.isBlank(parentBeanName) || !beanFactory.containsBeanDefinition(parentBeanName)) {

             return propertyExpressions;

         }

         if (!processedBeanNames.contains(parentBeanName)) {

             processBeanDefinition(parentBeanName, beanFactory.getBeanDefinition(parentBeanName), beanFactory,

                     processedBeanNames);

         }

         BeanDefinition beanDefinition = beanFactory.getBeanDefinition(parentBeanName);

         MutablePropertyValues pvs = beanDefinition.getPropertyValues();

         PropertyValue propertyExpressionsPV = pvs.getPropertyValue(UifPropertyPaths.PROPERTY_EXPRESSIONS);

         if (propertyExpressionsPV != null) {

             Object value = propertyExpressionsPV.getValue();

             if ((value != null) && (value instanceof ManagedMap)) {

                 propertyExpressions.putAll((ManagedMap) value);

             }

         }

         return propertyExpressions;

     }

     /**

      * Checks whether the given property value is of String type, and if so whether it contains the expression

      * placholder(s)

      *

      * @param propertyValue - value to check for expressions

      * @return boolean true if the property value contains expression(s), false if it does not

      */

     protected boolean hasExpression(Object propertyValue) {

         if (propertyValue != null) {

             // if value is string, check for el expression

             String strValue = getStringValue(propertyValue);

             if (strValue != null) {

                 String elPlaceholder = StringUtils.substringBetween(strValue, UifConstants.EL_PLACEHOLDER_PREFIX,

                         UifConstants.EL_PLACEHOLDER_SUFFIX);

                 if (StringUtils.isNotBlank(elPlaceholder)) {

                     return true;

                 }

             }

         }

         return false;

     }

     /**

      * Processes the given property name/value pair for complex objects, such as bean definitions or collections,

      * which if found will be processed for contained property expression values

      *

      * @param propertyName - name of the property whose value is being processed

      * @param propertyValue - value to check

      * @param parentPropertyExpressions - map that holds property expressions for the parent bean definition, used for

      * merging

      * @param propertyExpressions - map that holds property expressions for the bean definition being processed

      * @param beanFactory - bean factory that contains the bean definition being processed

      * @param processedBeanNames - set of bean names that have been processed so far

      * @return Object new value to set for property

      */

     protected Object processPropertyValue(String propertyName, Object propertyValue,

             Map<String, String> parentPropertyExpressions, Map<String, String> propertyExpressions,

             ConfigurableListableBeanFactory beanFactory, Set<String> processedBeanNames) {

         if (propertyValue == null) {

             return null;

         }

         // process nested bean definitions

         if ((propertyValue instanceof BeanDefinition) || (propertyValue instanceof BeanDefinitionHolder)) {

             BeanDefinition beanDefinition;

             if (propertyValue instanceof BeanDefinition) {

                 beanDefinition = (BeanDefinition) propertyValue;

             } else {

                 beanDefinition = ((BeanDefinitionHolder) propertyValue).getBeanDefinition();

             }

             // since overriding the entire bean, clear any expressions from parent that start with the bean property

             removeExpressionsByPrefix(propertyName, parentPropertyExpressions);

             processBeanDefinition(null, beanDefinition, beanFactory, processedBeanNames);

             return propertyValue;

         }

         // recurse into collections

         if (propertyValue instanceof Object[]) {

             visitArray(propertyName, parentPropertyExpressions, propertyExpressions, (Object[]) propertyValue,

                     beanFactory, processedBeanNames);

         } else if (propertyValue instanceof List) {

             visitList(propertyName, parentPropertyExpressions, propertyExpressions, (List) propertyValue, beanFactory,

                     processedBeanNames);

         } else if (propertyValue instanceof Set) {

             visitSet(propertyName, parentPropertyExpressions, propertyExpressions, (Set) propertyValue, beanFactory,

                     processedBeanNames);

         } else if (propertyValue instanceof Map) {

             visitMap(propertyName, parentPropertyExpressions, propertyExpressions, (Map) propertyValue, beanFactory,

                     processedBeanNames);

         }

         // others (primitive) just return value as is

         return propertyValue;

     }

     /**

      * Removes entries from the given expressions map whose key starts with the given prefix

      *

      * @param propertyNamePrefix - prefix to search for and remove

      * @param propertyExpressions - map of property expressions to filter

      */

     protected void removeExpressionsByPrefix(String propertyNamePrefix, Map<String, String> propertyExpressions) {

         Map<String, String> adjustedPropertyExpressions = new HashMap<String, String>();

         for (String propertyName : propertyExpressions.keySet()) {

             if (!propertyName.startsWith(propertyNamePrefix)) {

                 adjustedPropertyExpressions.put(propertyName, propertyExpressions.get(propertyName));

             }

         }

         propertyExpressions.clear();

         propertyExpressions.putAll(adjustedPropertyExpressions);

     }

     /**

      * Determines whether the given value is of String type and if so returns the string value

      *

      * @param value - object value to check

      * @return String string value for object or null if object is not a string type

      */

     protected String getStringValue(Object value) {

         if (value instanceof TypedStringValue) {

             TypedStringValue typedStringValue = (TypedStringValue) value;

             return typedStringValue.getValue();

         } else if (value instanceof String) {

             return (String) value;

         }

         return null;

     }

     @SuppressWarnings("unchecked")

     protected void visitArray(String propertyName, Map<String, String> parentPropertyExpressions,

             Map<String, String> propertyExpressions, Object[] arrayVal, ConfigurableListableBeanFactory beanFactory,

             Set<String> processedBeanNames) {

         for (int i = 0; i < arrayVal.length; i++) {

             Object elem = arrayVal[i];

             String elemPropertyName = propertyName + "[" + i + "]";

             if (hasExpression(elem)) {

                 String strValue = getStringValue(elem);

                 propertyExpressions.put(elemPropertyName, strValue);

                 arrayVal[i] = null;

             } else {

                 Object newElem = processPropertyValue(elemPropertyName, elem, parentPropertyExpressions,

                         propertyExpressions, beanFactory, processedBeanNames);

                 arrayVal[i] = newElem;

             }

             if (parentPropertyExpressions.containsKey(elemPropertyName)) {

                 parentPropertyExpressions.remove(elemPropertyName);

             }

         }

     }

     @SuppressWarnings("unchecked")

     protected void visitList(String propertyName, Map<String, String> parentPropertyExpressions,

             Map<String, String> propertyExpressions, List listVal, ConfigurableListableBeanFactory beanFactory,

             Set<String> processedBeanNames) {

         List newList = new ArrayList();

         for (int i = 0; i < listVal.size(); i++) {

             Object elem = listVal.get(i);

             String elemPropertyName = propertyName + "[" + i + "]";

             if (hasExpression(elem)) {

                 String strValue = getStringValue(elem);

                 propertyExpressions.put(elemPropertyName, strValue);

                 newList.add(i, null);

             } else {

                 Object newElem = processPropertyValue(elemPropertyName, elem, parentPropertyExpressions,

                         propertyExpressions, beanFactory, processedBeanNames);

                 newList.add(i, newElem);

             }

             if (parentPropertyExpressions.containsKey(elemPropertyName)) {

                 parentPropertyExpressions.remove(elemPropertyName);

             }

         }

         // determine if we need to clear any parent expressions for this list

         if (listVal instanceof ManagedList) {

             boolean isMergeEnabled = ((ManagedList) listVal).isMergeEnabled();

             if (!isMergeEnabled) {

                 // clear any expressions that match the property name minus index

                 Map<String, String> adjustedParentExpressions = new HashMap<String, String>();

                 for (Map.Entry<String, String> parentExpression : parentPropertyExpressions.entrySet()) {

                     if (!parentExpression.getKey().startsWith(propertyName + "[")) {

                         adjustedParentExpressions.put(parentExpression.getKey(), parentExpression.getValue());

                     }

                 }

                 parentPropertyExpressions.clear();

                 parentPropertyExpressions.putAll(adjustedParentExpressions);

             }

         }

         listVal.clear();

         listVal.addAll(newList);

     }

     @SuppressWarnings("unchecked")

     protected void visitSet(String propertyName, Map<String, String> parentPropertyExpressions,

             Map<String, String> propertyExpressions, Set setVal, ConfigurableListableBeanFactory beanFactory,

             Set<String> processedBeanNames) {

         Set newContent = new LinkedHashSet();

         // TODO: this is not handled correctly

         for (Object elem : setVal) {

             Object newElem = processPropertyValue(propertyName, elem, parentPropertyExpressions, propertyExpressions,

                     beanFactory, processedBeanNames);

             newContent.add(newElem);

         }

         setVal.clear();

         setVal.addAll(newContent);

     }

     @SuppressWarnings("unchecked")

     protected void visitMap(String propertyName, Map<String, String> parentPropertyExpressions,

             Map<String, String> propertyExpressions, Map<?, ?> mapVal, ConfigurableListableBeanFactory beanFactory,

             Set<String> processedBeanNames) {

         Map newContent = new LinkedHashMap();

         boolean isMergeEnabled = false;

         if (mapVal instanceof ManagedMap) {

             isMergeEnabled = ((ManagedMap) mapVal).isMergeEnabled();

         }

         for (Map.Entry entry : mapVal.entrySet()) {

             Object key = entry.getKey();

             Object val = entry.getValue();

             String keyStr = getStringValue(key);

             String elemPropertyName = propertyName + "['" + keyStr + "']";

             if (hasExpression(val)) {

                 String strValue = getStringValue(val);

                 propertyExpressions.put(elemPropertyName, strValue);

                 newContent.put(key, null);

             } else {

                 Object newElem = processPropertyValue(elemPropertyName, val, parentPropertyExpressions,

                         propertyExpressions, beanFactory, processedBeanNames);

                 newContent.put(key, newElem);

             }

             if (isMergeEnabled && parentPropertyExpressions.containsKey(elemPropertyName)) {

                 parentPropertyExpressions.remove(elemPropertyName);

             }

         }

         if (!isMergeEnabled) {

             // clear any expressions that match the property minus key

             Map<String, String> adjustedParentExpressions = new HashMap<String, String>();

             for (Map.Entry<String, String> parentExpression : parentPropertyExpressions.entrySet()) {

                 if (!parentExpression.getKey().startsWith(propertyName + "[")) {

                     adjustedParentExpressions.put(parentExpression.getKey(), parentExpression.getValue());

                 }

             }

             parentPropertyExpressions.clear();

             parentPropertyExpressions.putAll(adjustedParentExpressions);

         }

         mapVal.clear();

         mapVal.putAll(newContent);

     }

 }