package org.kuali.spring.util;
   
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.InputStreamReader;
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.List;
   import java.util.Map;
  import java.util.Properties;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.core.io.Resource;
  import org.springframework.core.io.support.PropertiesLoaderSupport;
  import org.springframework.util.CollectionUtils;
  import org.springframework.util.DefaultPropertiesPersister;
  import org.springframework.util.ObjectUtils;
  import org.springframework.util.PropertiesPersister;
  
  public class PropertiesLoader {
  	private static final Logger logger = LoggerFactory.getLogger(PropertiesLoader.class);
  
  	public static final String DEFAULT_ENVIRONMENT_PROPERTY_PREFIX = "env.";
  	public static final boolean DEFAULT_IS_USE_ENVIRONMENT_PROPERTY_PREFIX = false;
  	public static final boolean DEFAULT_IS_LOCAL_OVERRIDE = false;
  	public static final boolean DEFAULT_IS_IGNORE_RESOURCE_NOT_FOUND = false;
  	public static final boolean DEFAULT_IS_SEARCH_SYSTEM_ENVIRONMENT = true;
  	public static final SystemPropertiesMode DEFAULT_SYSTEM_PROPERTIES_MODE = SystemPropertiesMode.SYSTEM_PROPERTIES_MODE_OVERRIDE;
  
  	// Properties with defaults
  	String environmentPropertyPrefix = DEFAULT_ENVIRONMENT_PROPERTY_PREFIX;
  	boolean useEnvironmentPropertyPrefix = DEFAULT_IS_USE_ENVIRONMENT_PROPERTY_PREFIX;
  	SystemPropertiesMode systemPropertiesMode = DEFAULT_SYSTEM_PROPERTIES_MODE;
  	boolean localOverride = DEFAULT_IS_LOCAL_OVERRIDE;
  	boolean ignoreResourceNotFound = DEFAULT_IS_IGNORE_RESOURCE_NOT_FOUND;
  	boolean searchSystemEnvironment = DEFAULT_IS_SEARCH_SYSTEM_ENVIRONMENT;
  
  	// Properties without defaults
  	String fileEncoding;
  	Properties[] localProperties;
  	Resource[] locations;
  
  	// Default component beans
  	PropertiesPersister propertiesPersister = new DefaultPropertiesPersister();
  	PropertyLogger plogger = new PropertyLogger();
  
  	// Instance variables filled in during loading
  	Properties systemProperties;
  	Properties environmentProperties;
  	Properties resourceProperties;
  	Properties mergedLocalProperties;
  	Properties properties;
  
  	/**
  	 * Get a handle to our environment properties. Prefix is optional
  	 */
  	protected Properties getEnvironmentProperties(String prefix) {
  		Map<String, String> environmentMap = SystemUtils.getEnvironmentIgnoreExceptions();
  		Properties envProps = new Properties();
  		for (Map.Entry<String, String> entry : environmentMap.entrySet()) {
  			String key = (prefix == null) ? entry.getKey() : prefix + entry.getKey();
  			envProps.setProperty(key, entry.getValue());
  		}
  		return envProps;
  	}
  
  	/**
  	 * Given a resource and an InputStream, load and return a Properties object. Supports regular as well as XML style
  	 * properties files
  	 * 
  	 * @param location
  	 * @param is
  	 * @return
  	 * @throws IOException
  	 */
  	protected Properties getProperties(Resource location, InputStream is) throws IOException {
  		Properties properties = new Properties();
  		// Use XML style loading if it is an XML file
  		if (isXMLFile(location)) {
  			getPropertiesPersister().loadFromXml(properties, is);
  			return properties;
  		}
  
  		if (getFileEncoding() != null) {
  			// Use a Reader if they've specified a fileEncoding
  			getPropertiesPersister().load(properties, new InputStreamReader(is, getFileEncoding()));
  		} else {
  			// Otherwise use an InputStream
  			getPropertiesPersister().load(properties, is);
  		}
  		return properties;
  	}
  
  	/**
  	 * Load properties from a Resource object. Returns an empty Properties object if ignoreResourceNotFound is true and
  	 * the resource could not be located
  	 * 
  	 * @param location
 	 * @return
 	 * @throws IOException
 	 */
 	protected Properties loadProperties(Resource location) throws IOException {
 		// Handle locations that don't exist
 		if (!location.exists()) {
 			return handleResourceNotFound(location);
 		}
 
 		// Proceed with loading
 		logger.info("Loading properties from {}", location);
 		InputStream is = null;
 		try {
 			is = location.getInputStream();
 			return getProperties(location, is);
 		} catch (IOException e) {
 			throw e;
 		} finally {
 			nullSafeClose(is);
 		}
 	}
 
 	/**
 	 * True if this location represents an XML file, false otherwise
 	 * 
 	 * @param location
 	 * @return
 	 */
 	protected boolean isXMLFile(Resource location) {
 		String filename = null;
 		try {
 			filename = location.getFilename();
 		} catch (IllegalStateException ex) {
 			// resource is not file-based. See SPR-7552.
 			return false;
 		}
 		// May not have thrown an exception, but might still be null
 		if (filename == null) {
 			return false;
 		}
 		// It's an XML file
 		if (filename.endsWith(PropertiesLoaderSupport.XML_FILE_EXTENSION)) {
 			return true;
 		} else {
 			return false;
 		}
 	}
 
 	/**
 	 * Throw an exception unless ignoreResourceNotFound is true
 	 * 
 	 * @param location
 	 * @return
 	 */
 	protected Properties handleResourceNotFound(Resource location) {
 		if (isIgnoreResourceNotFound()) {
 			logger.info("Ignoring properties from {}.  Resource not found", location);
 			return new Properties();
 		} else {
 			throw new PropertiesLoadException("Resource not found: " + location);
 		}
 	}
 
 	/**
 	 * Close the InputStream
 	 * 
 	 * @param is
 	 * @throws IOException
 	 */
 	protected void nullSafeClose(InputStream is) throws IOException {
 		if (is == null) {
 			return;
 		}
 		is.close();
 	}
 
 	/**
 	 * Merge the Properties[] into a single Properties object
 	 */
 	protected Properties mergeLocalProperties() {
 		if (getLocalProperties() == null || getLocalProperties().length == 0) {
 			// Nothing to do, return an empty Properties object
 			return new Properties();
 		}
 		// Merge the Properties[] into a single Properties object
 		Properties result = new Properties();
 		for (Properties localProp : getLocalProperties()) {
 			CollectionUtils.mergePropertiesIntoMap(localProp, result);
 		}
 		return result;
 	}
 
 	/**
 	 * Get properties from the environment
 	 */
 	protected Properties loadEnvironmentProperties() {
 		if (isUseEnvironmentPropertyPrefix()) {
 			return getEnvironmentProperties(getEnvironmentPropertyPrefix());
 		} else {
 			return getEnvironmentProperties(null);
 		}
 	}
 
 	/**
 	 * Get system properties
 	 */
 	protected Properties loadSystemProperties() {
 		return SystemUtils.getSystemPropertiesIgnoreExceptions();
 	}
 
 	/**
 	 * Merge local, resource, system, and environment properties into a single Properties object. User supplied settings
 	 * control which property "wins" if a property is defined in multiple areas
 	 */
 	public Properties mergeProperties(Properties local, Properties resource, Properties sys, Properties env) {
 		// Storage for our merged properties
 		Properties result = new Properties();
 
 		// Merge in local properties (nothing to actually merge here, but this also logs them when DEBUG is on)
 		PropertiesMergeContext context = new PropertiesMergeContext(result, local, PropertySource.LOCAL);
 		mergeProperties(context);
 
 		// Merge in resource properties. localOverride controls what property "wins" if the same
 		// property is declared both locally and in a resource
 		boolean resourcePropertyWins = !isLocalOverride();
 		context = new PropertiesMergeContext(result, resource, resourcePropertyWins, PropertySource.RESOURCE);
 		mergeProperties(context);
 
 		// Merge in system properties according to the SystemPropertiesMode being used
 		if (!getSystemPropertiesMode().equals(SystemPropertiesMode.SYSTEM_PROPERTIES_MODE_NEVER)) {
 			boolean override = getSystemPropertiesMode().equals(SystemPropertiesMode.SYSTEM_PROPERTIES_MODE_OVERRIDE);
 			context = new PropertiesMergeContext(result, sys, override, PropertySource.SYSTEM);
 			mergeProperties(context);
 		}
 
 		// Merge in environment properties. Environment properties never override properties from another source
 		if (isSearchSystemEnvironment()) {
 			context = new PropertiesMergeContext(result, env, false, PropertySource.ENVIRONMENT);
 			mergeProperties(context);
 		}
 
 		// Return the merged properties
 		return result;
 	}
 
 	/**
 	 * Fill in a Properties object
 	 */
 	public Properties loadProperties() {
 		try {
 			// Populate properties from the default set of locations
 			Properties local = mergeLocalProperties();
 			Properties resource = loadResourceProperties();
 			Properties sys = loadSystemProperties();
 			Properties env = loadEnvironmentProperties();
 
 			// Store the properties locally
 			setMergedLocalProperties(local);
 			setResourceProperties(resource);
 			setSystemProperties(sys);
 			setEnvironmentProperties(env);
 
 			// Merge them into a single properties object
 			return mergeProperties(local, resource, sys, env);
 		} catch (IOException e) {
 			throw new PropertiesLoadException("Unexpected error loading properties", e);
 		}
 	}
 
 	/**
 	 * Merge a property under 'key' from newProps into currentProps using the settings from PropertiesMergeContext
 	 * 
 	 * @param context
 	 * @param key
 	 */
 	public PropertyMergeResult mergeProperty(PropertiesMergeContext context, String key) {
 		Properties newProps = context.getNewProperties();
 		Properties currentProps = context.getCurrentProperties();
 		boolean override = context.isOverride();
 
 		// Extract the new value
 		String newValue = newProps.getProperty(key);
 
 		// Extract the existing value
 		String currentValue = currentProps.getProperty(key);
 
 		// If the new value is null, there is nothing further to do
 		if (newValue == null) {
 			PropertyMergeType type = PropertyMergeType.NULL_NEW_VALUE;
 			return new PropertyMergeResult(context, key, currentValue, newValue, type);
 		}
 
 		// The newValue is not null, and there is no existing value for this key
 		if (currentValue == null) {
 			currentProps.setProperty(key, newValue);
 			PropertyMergeType type = PropertyMergeType.ADD;
 			return new PropertyMergeResult(context, key, currentValue, newValue, type);
 		}
 
 		// Neither value is null and the values are the same, nothing further to do
 		if (ObjectUtils.nullSafeEquals(newValue, currentValue)) {
 			PropertyMergeType type = PropertyMergeType.IDENTICAL_VALUES;
 			return new PropertyMergeResult(context, key, currentValue, newValue, type);
 		}
 
 		if (override) {
 			// There is an existing property, but the new property wins
 			currentProps.setProperty(key, newValue);
 			PropertyMergeType type = PropertyMergeType.OVERRIDE;
 			return new PropertyMergeResult(context, key, currentValue, newValue, type);
 		} else {
 			// There is already an existing property, and the existing property wins
 			PropertyMergeType type = PropertyMergeType.EXISTING_PROPERTY_WINS;
 			return new PropertyMergeResult(context, key, currentValue, newValue, type);
 		}
 	}
 
 	public void mergeProperties(PropertiesMergeContext context) {
 		List<String> keys = new ArrayList<String>(context.getNewProperties().stringPropertyNames());
 		if (context.isSort()) {
 			Collections.sort(keys);
 		}
 		for (String key : keys) {
 			logResult(mergeProperty(context, key));
 		}
 	}
 
 	protected void logResult(PropertyMergeResult result) {
 		PropertySource source = result.getContext().getSource();
 		String key = result.getKey();
 		String newValue = result.getNewValue();
 		String currentValue = result.getOldValue();
 
 		switch (result.getType()) {
 		case ADD:
 			logger.debug("Add " + source + " property {}=[{}]", key, plogger.getLogValue(key, newValue));
 			return;
 		case OVERRIDE:
 			logger.info(source + " property override for '" + key + "' [{}]->[{}]",
 					plogger.getLogValue(key, currentValue), plogger.getLogValue(key, newValue));
 			return;
 		case EXISTING_PROPERTY_WINS:
 			logger.debug("The existing value for '" + key + "' is not being overridden by the " + source
 					+ " value. Existing:[{}] New:[{}]", plogger.getLogValue(key, currentValue),
 					plogger.getLogValue(key, newValue));
 			return;
 		default:
 			logger.trace("Merge property result: {} for {}", result.getType(), key);
 			return;
 
 		}
 
 	}
 
 	public Properties loadResourceProperties() throws IOException {
 		if (getLocations() == null || getLocations().length == 0) {
 			logger.info("No resource property locations to load from");
 			return new Properties();
 		}
 		Properties result = new Properties();
 		for (Resource location : getLocations()) {
 			Properties newProps = loadProperties(location);
 			PropertySource source = PropertySource.RESOURCE;
 			// If a property is declared in more than one resource location, the last resource location "wins"
 			boolean override = true;
 			PropertiesMergeContext context = new PropertiesMergeContext(result, newProps, override, source);
 			mergeProperties(context);
 		}
 		return result;
 	}
 
 	public boolean isIgnoreResourceNotFound() {
 		return ignoreResourceNotFound;
 	}
 
 	public String getFileEncoding() {
 		return fileEncoding;
 	}
 
 	public Properties[] getLocalProperties() {
 		return localProperties;
 	}
 
 	public void setLocalProperties(Properties[] localProperties) {
 		this.localProperties = localProperties;
 	}
 
 	public Resource[] getLocations() {
 		return locations;
 	}
 
 	public boolean isLocalOverride() {
 		return localOverride;
 	}
 
 	public PropertiesPersister getPropertiesPersister() {
 		return propertiesPersister;
 	}
 
 	public String getEnvironmentPropertyPrefix() {
 		return environmentPropertyPrefix;
 	}
 
 	public void setEnvironmentPropertyPrefix(String environmentPropertyPrefix) {
 		this.environmentPropertyPrefix = environmentPropertyPrefix;
 	}
 
 	public Logger getLogger() {
 		return logger;
 	}
 
 	public void setPropertiesPersister(PropertiesPersister propertiesPersister) {
 		this.propertiesPersister = propertiesPersister;
 	}
 
 	public void setLocations(Resource[] locations) {
 		this.locations = locations;
 	}
 
 	public void setLocalOverride(boolean localOverride) {
 		this.localOverride = localOverride;
 	}
 
 	public void setIgnoreResourceNotFound(boolean ignoreResourceNotFound) {
 		this.ignoreResourceNotFound = ignoreResourceNotFound;
 	}
 
 	public void setFileEncoding(String fileEncoding) {
 		this.fileEncoding = fileEncoding;
 	}
 
 	public SystemPropertiesMode getSystemPropertiesMode() {
 		return systemPropertiesMode;
 	}
 
 	public void setSystemPropertiesMode(SystemPropertiesMode systemPropertiesMode) {
 		this.systemPropertiesMode = systemPropertiesMode;
 	}
 
 	public boolean isSearchSystemEnvironment() {
 		return searchSystemEnvironment;
 	}
 
 	public void setSearchSystemEnvironment(boolean searchSystemEnvironment) {
 		this.searchSystemEnvironment = searchSystemEnvironment;
 	}
 
 	public void setResourceProperties(Properties resourceProperties) {
 		this.resourceProperties = resourceProperties;
 	}
 
 	public void setSystemProperties(Properties systemProperties) {
 		this.systemProperties = systemProperties;
 	}
 
 	public void setEnvironmentProperties(Properties environmentProperties) {
 		this.environmentProperties = environmentProperties;
 	}
 
 	public void setMergedLocalProperties(Properties mergedLocalProperties) {
 		this.mergedLocalProperties = mergedLocalProperties;
 	}
 
 	public boolean isUseEnvironmentPropertyPrefix() {
 		return useEnvironmentPropertyPrefix;
 	}
 
 	public void setUseEnvironmentPropertyPrefix(boolean useEnvironmentPropertyPrefix) {
 		this.useEnvironmentPropertyPrefix = useEnvironmentPropertyPrefix;
 	}
 
 	public PropertyLogger getPlogger() {
 		return plogger;
 	}
 
 	public void setPlogger(PropertyLogger propertiesLogger) {
 		this.plogger = propertiesLogger;
 	}
 
 	public Properties getProperties() {
 		return properties;
 	}
 
 	public void setProperties(Properties properties) {
 		this.properties = properties;
 	}
 
 	public Properties getSystemProperties() {
 		return systemProperties;
 	}
 
 	public Properties getEnvironmentProperties() {
 		return environmentProperties;
 	}
 
 	public Properties getResourceProperties() {
 		return resourceProperties;
 	}
 
 	public Properties getMergedLocalProperties() {
 		return mergedLocalProperties;
 	}
 
 }