PropertyUtils

package org.kuali.ole.utility;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 *
 */
public class PropertyUtils {
	private static final Logger LOG = LoggerFactory.getLogger(PropertyUtils.class);
	public static final String ENVIRONMENT_PROPERTY_PREFIX = "env";
	public static final String CR = "\r";
	public static final String LF = "\n";
	private static final ResourceUtil resourceUtil = new ResourceUtil();
	private static final PropertyPlaceholderHelper helper = new PropertyPlaceholderHelper("${", "}");

	protected PropertyUtils() {
		super();
	}

	/**
	 * Return a list containing a pointer to the location of common properties + the explicit location they specified + the value of the system property (if the system property is
	 * set to a valid location)
	 */
	public static final List<String> getLocations(String location, String systemProperty, String externalConfigFile) {
		List<String> list = new ArrayList<String>();
		list.add(Constants.COMMON_PROPERTIES_LOCATION);
		list.add(location);
		if (resourceUtil.exists(externalConfigFile)) {
			list.add(externalConfigFile);
		} else {
			LOG.info("Skipping [" + externalConfigFile + "].  File does not exist");
		}
		if (validate(systemProperty)) {
			list.add(System.getProperty(systemProperty));
			LOG.info("System property " + systemProperty + "=" + System.getProperty(systemProperty));
		} else {
			LOG.info("System property [" + systemProperty + "] is not set");
		}
		return list;
	}

	/**
	 * Return false if the system property is not set. Return true if the system property is set AND it points to a resource Spring resource loading can understand. Throw an
	 * <code>IllegalArgumentException</code> if the system property is set, but the location it points to does not exist.
	 */
	public static final boolean validate(String systemProperty) {
		String location = System.getProperty(systemProperty);
		if (StringUtils.isBlank(location)) {
			return false;
		}
		if (resourceUtil.exists(location)) {
			return true;
		} else {
			// Throw an exception here because they explicitly set a system property that points to an invalid location
			throw new IllegalArgumentException(location + " does not exist");
		}
	}

	/**
	 * Load and resolve properties for an environment. Properties are loaded from the list of locations. If there are environment specific properties, the default values are
	 * overridden with environment specific values. In the properties object returned by this method, any placeholders present in the property values will be fully resolved.
	 */
	public static final Properties getAppEnvironmentProperties(List<String> locations) throws IOException {
		// Default values loaded from the locations provided
		Properties props = resourceUtil.getProperties(locations);
		// Override with environment variables
		props.putAll(getEnvironmentProperties());
		// Override with system properties
		props.putAll(System.getProperties());
		// Extract the environment we are running in
		String environment = props.getProperty(Constants.ENVIRONMENT_PROPERTY, Constants.DEFAULT_ENVIRONMENT);
		LOG.info(Constants.ENVIRONMENT_PROPERTY + "=" + environment);
		// Override default values with values that are specific to the environment we are running in
		overrideProperties(props, environment);
		// Resolve placeholders in the property values
		resolveProperties(props);

		// Log information about the properties we've loaded
		if (LOG.isInfoEnabled()) {
			List<String> keys = new ArrayList<String>(props.stringPropertyNames());
			Collections.sort(keys);
			LOG.info("Displaying " + props.size() + " properties for environment '" + environment + "'");
			LOG.info("--------------------------------------------------------------------");
			for (String key : keys) {
				String value = props.getProperty(key);
				LOG.info(key + "=" + flatten(value));
			}
			LOG.info("--------------------------------------------------------------------");
		}

		// Return what we've found
		return props;
	}

	/**
	 * Return a properties object that aggregates the properties passed in with environment variables and system properties. Environment variables are included as properties
	 * prefixed with <code>env</code>. If there are duplicate property values, the system property value will always "win".
	 */
	public static final Properties getAllProperties(Properties properties) {
		Properties all = new Properties();
		all.putAll(properties);
		all.putAll(getEnvironmentProperties());
		all.putAll(System.getProperties());
		return all;
	}

	/**
	 * Return the keys from the properties as a sorted list.
	 */
	public static final List<String> getSortedKeys(Properties properties) {
		List<String> keys = new ArrayList<String>(properties.stringPropertyNames());
		Collections.sort(keys);
		return keys;
	}

	/**
	 * Resolve placeholders in the properties. Properties are always resolved using the properties passed in plus environment variables and system properties.
	 */
	public static final void resolveProperties(Properties props) {
		Properties resolverProperties = getAllProperties(props);
		List<String> keys = getSortedKeys(props);
		Properties resolvedProperties = new Properties();
		for (String key : keys) {
			String oldValue = props.getProperty(key);
			String newValue = helper.replacePlaceholders(oldValue, resolverProperties);
			addIfDifferent(key, oldValue, newValue, resolvedProperties);
		}
		if (resolvedProperties.size() > 0) {
			LOG.info("Resolved " + resolvedProperties.size() + " property values");
		}
		props.putAll(resolvedProperties);
	}

	/**
	 * Override property values for a given environment. For example, if <code>batch.size=5</code> and <code>dev.batch.size=10</code> are both provided and environment is
	 * <code>dev</code>, <code>batch.size</code> will be updated to 10
	 */
	public static final void overrideProperties(Properties props, String environment) {
		if (StringUtils.isBlank(environment)) {
			return;
		}
		Properties all = getAllProperties(props);
		List<String> keys = getSortedKeys(all);
		Properties overridenProperties = new Properties();
		String prefix = environment + ".";
		for (String key : keys) {
			if (!key.startsWith(prefix)) {
				continue;
			}
			String existingKey = key.substring(prefix.length());
			String oldValue = all.getProperty(existingKey);
			String newValue = all.getProperty(key);
			addIfDifferent(existingKey, oldValue, newValue, overridenProperties);
		}
		if (overridenProperties.size() > 0) {
			LOG.info("Overrode " + overridenProperties.size() + " values for environment [" + environment + "]");
		}
		props.putAll(overridenProperties);
	}

	/**
	 * If <code>newValue</code> is different than <code>oldValue</code>, add <code>key</code> to the properties using <code>newValue</code>
	 */
	protected static final void addIfDifferent(String key, String oldValue, String newValue, Properties props) {
		if (!newValue.equals(oldValue)) {
			props.setProperty(key, newValue);
			LOG.info("Updating " + key + " [" + flatten(oldValue) + "] -> [" + flatten(newValue) + "]");
		}
	}

	/**
	 * Replace carriage returns with <code>CR</code>. Replace linefeeds with <code>LF</code>.
	 */
	public static final String flatten(String s) {
		if (s == null) {
			return s;
		} else {
			return s.replace(CR, "CR").replace(LF, "LF");
		}
	}

	/**
	 * Return environment variables as properties where each property is prefixed with "env"
	 */
	public static final Properties getEnvironmentProperties() {
		Map<String, String> env = System.getenv();
		Properties props = new Properties();
		for (String key : env.keySet()) {
			String newKey = ENVIRONMENT_PROPERTY_PREFIX + "." + key;
			String value = env.get(key);
			props.setProperty(newKey, value);
		}
		return props;
	}

}