/*
 * Copyright (C) 2007-2012 Argeo 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 org.argeo.slc.core.execution;

import java.beans.PropertyDescriptor;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.argeo.slc.SlcException;
import org.argeo.slc.execution.ExecutionContext;
import org.argeo.slc.execution.ExecutionFlow;
import org.springframework.beans.BeansException;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.PropertyValue;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.BeanDefinitionStoreException;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;
import org.springframework.beans.factory.config.TypedStringValue;
import org.springframework.beans.factory.support.ManagedList;
import org.springframework.beans.factory.support.ManagedMap;
import org.springframework.beans.factory.support.ManagedSet;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

/**
 * Spring post processor which ensures that execution parameters are properly
 * set. It is used at two levels: first during instantiation for instantiation
 * parameters which allow to implement templates, then at runtime in order to
 * interpret @{} placeholders when object of scope execution are instantiated.
 */
public class ExecutionParameterPostProcessor extends
		InstantiationAwareBeanPostProcessorAdapter {

	private final static Log log = LogFactory
			.getLog(ExecutionParameterPostProcessor.class);

	private ExecutionContext executionContext;
	private InstantiationManager instantiationManager;

	private String placeholderPrefix = "@{";
	private String placeholderSuffix = "}";
	private String nullValue;

	@Override
	public PropertyValues postProcessPropertyValues(PropertyValues pvs,
			PropertyDescriptor[] pds, Object bean, String beanName)
			throws BeansException {

		// TODO: resolve at execution only if scope is execution
		// TODO: deal with placeholders in RuntimeBeanReference and
		// RuntimeBeanNameReference

		MutablePropertyValues newPvs = new MutablePropertyValues();

		boolean changesOccured = false;

		for (PropertyValue pv : pvs.getPropertyValues()) {
			Object convertedValue = resolveValue(beanName, bean, pv.getValue());
			newPvs.addPropertyValue(new PropertyValue(pv, convertedValue));
			if (convertedValue != pv.getValue()) {
				changesOccured = true;
			}
		}

		return changesOccured ? newPvs : pvs;
	}

	@Override
	public boolean postProcessAfterInstantiation(Object bean, String beanName)
			throws BeansException {
		if (bean instanceof ExecutionFlow)
			instantiationManager.flowInitializationStarted(
					(ExecutionFlow) bean, beanName);
		return true;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName)
			throws BeansException {
		if (bean instanceof ExecutionFlow)
			instantiationManager.flowInitializationFinished(
					(ExecutionFlow) bean, beanName);
		return bean;
	}

	protected String resolvePlaceholder(Object bean, String placeholder) {
		if (instantiationManager.isInFlowInitialization())
			return instantiationManager.getInitializingFlowParameter(
					placeholder).toString();

		else {// execution
				// next call fail if no execution context available
			Object obj = executionContext.getVariable(placeholder);
			if (obj != null) {
				return obj.toString();
			}
		}

		return null;
	}

	public Object resolveValue(String beanName, Object bean, Object value) {
		if (value instanceof TypedStringValue) {
			TypedStringValue tsv = (TypedStringValue) value;
			String originalValue = tsv.getValue();

			String convertedValue = resolveString(beanName, bean, originalValue);
			if (convertedValue == null)
				return null;
			return convertedValue.equals(originalValue) ? value
					: new TypedStringValue(convertedValue);
		} else if (value instanceof String) {
			String originalValue = value.toString();
			String convertedValue = resolveString(beanName, bean, originalValue);
			if (convertedValue == null)
				return null;
			return convertedValue.equals(originalValue) ? value
					: convertedValue;
		} else if (value instanceof ManagedMap) {
			Map<?, ?> mapVal = (Map<?, ?>) value;

			Map<Object, Object> newContent = new ManagedMap<Object, Object>();
			boolean entriesModified = false;
			for (Iterator<?> it = mapVal.entrySet().iterator(); it.hasNext();) {
				Map.Entry<?, ?> entry = (Map.Entry<?, ?>) it.next();
				Object key = entry.getKey();
				int keyHash = (key != null ? key.hashCode() : 0);
				Object newKey = resolveValue(beanName, bean, key);
				int newKeyHash = (newKey != null ? newKey.hashCode() : 0);
				Object val = entry.getValue();
				Object newVal = resolveValue(beanName, bean, val);
				newContent.put(newKey, newVal);
				entriesModified = entriesModified
						|| (newVal != val || newKey != key || newKeyHash != keyHash);
			}

			return entriesModified ? newContent : value;
		} else if (value instanceof ManagedList) {
			List<?> listVal = (List<?>) value;
			List<Object> newContent = new ManagedList<Object>();
			boolean valueModified = false;

			for (int i = 0; i < listVal.size(); i++) {
				Object elem = listVal.get(i);
				Object newVal = resolveValue(beanName, bean, elem);
				newContent.add(newVal);
				if (!ObjectUtils.nullSafeEquals(newVal, elem)) {
					valueModified = true;
				}
			}
			return valueModified ? newContent : value;
		} else if (value instanceof ManagedSet) {
			Set<?> setVal = (Set<?>) value;
			Set<Object> newContent = new ManagedSet<Object>();
			boolean entriesModified = false;
			for (Iterator<?> it = setVal.iterator(); it.hasNext();) {
				Object elem = it.next();
				int elemHash = (elem != null ? elem.hashCode() : 0);
				Object newVal = resolveValue(beanName, bean, elem);
				int newValHash = (newVal != null ? newVal.hashCode() : 0);
				newContent.add(newVal);
				entriesModified = entriesModified
						|| (newVal != elem || newValHash != elemHash);
			}
			return entriesModified ? newContent : value;
		} else {
			// log.debug(beanName + ": " + value.getClass() + " : " + value);
			return value;
		}

	}

	private String resolveString(String beanName, Object bean, String strVal) {
		// in case <null/> is passed
		if (strVal == null)
			return null;

		String value = parseStringValue(bean, strVal, new HashSet<String>());

		if (value == null)
			throw new SlcException("Could not resolve placeholder '" + strVal
					+ "' in bean '" + beanName + "'");

		return (value.equals(nullValue) ? null : value);
	}

	public void setPlaceholderPrefix(String placeholderPrefix) {
		this.placeholderPrefix = placeholderPrefix;
	}

	public void setPlaceholderSuffix(String placeholderSuffix) {
		this.placeholderSuffix = placeholderSuffix;
	}

	public void setNullValue(String nullValue) {
		this.nullValue = nullValue;
	}

	public void setInstantiationManager(
			InstantiationManager instantiationManager) {
		this.instantiationManager = instantiationManager;
	}

	public void setExecutionContext(ExecutionContext executionContext) {
		this.executionContext = executionContext;
	}

	//
	// Following methods hacked from the internals of
	// PropertyPlaceholderConfigurer
	//

	protected String parseStringValue(Object bean, String strVal,
			Set<String> visitedPlaceholders)
			throws BeanDefinitionStoreException {

		// in case <null/> is passed
		if (strVal == null)
			return null;

		StringBuffer buf = new StringBuffer(strVal);

		int startIndex = strVal.indexOf(placeholderPrefix);
		while (startIndex != -1) {
			int endIndex = findPlaceholderEndIndex(buf, startIndex);
			if (endIndex != -1) {
				String placeholder = buf.substring(startIndex
						+ placeholderPrefix.length(), endIndex);
				if (!visitedPlaceholders.add(placeholder)) {
					throw new BeanDefinitionStoreException(
							"Circular placeholder reference '" + placeholder
									+ "' in property definitions");
				}
				// Recursive invocation, parsing placeholders contained in
				// the placeholder key.
				placeholder = parseStringValue(bean, placeholder,
						visitedPlaceholders);
				// Now obtain the value for the fully resolved key...
				String propVal = resolvePlaceholder(bean, placeholder);
				if (propVal != null) {
					// Recursive invocation, parsing placeholders contained
					// in the
					// previously resolved placeholder value.
					propVal = parseStringValue(bean, propVal,
							visitedPlaceholders);
					buf.replace(startIndex,
							endIndex + placeholderSuffix.length(), propVal);
					if (log.isTraceEnabled()) {
						log.trace("Resolved placeholder '" + placeholder + "'");
					}
					startIndex = buf.indexOf(placeholderPrefix, startIndex
							+ propVal.length());
				} else {
					throw new BeanDefinitionStoreException(
							"Could not resolve placeholder '" + placeholder
									+ "'");
				}
				visitedPlaceholders.remove(placeholder);
			} else {
				startIndex = -1;
			}
		}

		return buf.toString();
	}

	private int findPlaceholderEndIndex(CharSequence buf, int startIndex) {
		int index = startIndex + placeholderPrefix.length();
		int withinNestedPlaceholder = 0;
		while (index < buf.length()) {
			if (StringUtils.substringMatch(buf, index, placeholderSuffix)) {
				if (withinNestedPlaceholder > 0) {
					withinNestedPlaceholder--;
					index = index + placeholderSuffix.length();
				} else {
					return index;
				}
			} else if (StringUtils
					.substringMatch(buf, index, placeholderPrefix)) {
				withinNestedPlaceholder++;
				index = index + placeholderPrefix.length();
			} else {
				index++;
			}
		}
		return -1;
	}

}