package org.kuali.spring.util;
   
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.List;
   import java.util.Properties;
   import java.util.regex.Matcher;
   import java.util.regex.Pattern;
   
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  public class PropertyLogger {
  	final Logger logger = LoggerFactory.getLogger(PropertyLogger.class);
  
  	// Matches any string containing "password" (case insensitive)
  	public static final String DEFAULT_MASK_EXPRESSION = ".*((?i)password).*";
  	public static final String DEFAULT_MASKED_VALUE = "******";
  	public static final boolean DEFAULT_IS_MASK_PROPERTY_VALUES = true;
  	public static final boolean DEFAULT_IS_FLATTEN_PROPERTY_VALUES = false;
  	public static final boolean DEFAULT_IS_TRIM_PROPERTY_VALUES = false;
  	public static final boolean DEFAULT_IS_LOG_IN_SORTED_ORDER = true;
  	// Space
  	public static final String DEFAULT_REPLACEMENT_STRING = " ";
  	// Carriage return
  	public static final String CR = "\r";
  	// Line feed
  	public static final String LF = "\n";
  
  	// If true, log entries from a Properties object sorted by key
  	boolean logInSortedOrder = DEFAULT_IS_LOG_IN_SORTED_ORDER;
  	// If true, replace \n and \r when logging values
  	boolean flattenPropertyValues = DEFAULT_IS_FLATTEN_PROPERTY_VALUES;
  	// The value to replace linefeeds with
  	String linefeedReplacement = DEFAULT_REPLACEMENT_STRING;
  	// The value to replace carriage returns with
  	String carriageReturnReplacement = DEFAULT_REPLACEMENT_STRING;
  	// If true, call trim() on property values before logging them
  	boolean trimPropertyValues = DEFAULT_IS_TRIM_PROPERTY_VALUES;
  	// If true, mask values for keys that match any of the maskExpressions
  	boolean maskPropertyValues = DEFAULT_IS_MASK_PROPERTY_VALUES;
  	// Regular expressions to compare property keys against
  	String[] maskExpressions;
  	// The value to log in place of the actual value if we need to mask it
  	String maskValue = DEFAULT_MASKED_VALUE;
  	// Compiled representation of the regular expression
  	Pattern[] patterns;
  
  	public PropertyLogger() {
  		super();
  		setMaskExpression(DEFAULT_MASK_EXPRESSION);
  	}
  
  	/**
  	 * This setter invokes setMaskExpressions() - plural
  	 * 
  	 * @param maskExpression
  	 */
  	public void setMaskExpression(String maskExpression) {
  		setMaskExpressions(new String[] { maskExpression });
  	}
  
  	/**
  	 * This setter invokes Pattern.compile() for each maskExpression
  	 * 
  	 * @param maskExpressions
  	 */
  	public void setMaskExpressions(String[] maskExpressions) {
  		this.maskExpressions = maskExpressions;
  		this.patterns = new Pattern[maskExpressions.length];
  		for (int i = 0; i < patterns.length; i++) {
  			patterns[i] = Pattern.compile(maskExpressions[i]);
  		}
  	}
  
  	public String getLogEntry(String key, String value) {
  		return key + "=" + getLogValue(key, value);
  	}
  
  	protected boolean isEmpty(String s) {
  		if (s == null) {
  			return true;
  		}
  		if (s.trim().length() == 0) {
  			return true;
  		}
  		return false;
  	}
  
  	public String getLogEntry(Properties properties) {
  		if (properties == null || properties.size() == 0) {
  			return "No properties to log";
  		}
  		StringBuilder sb = new StringBuilder();
  		List<String> keys = new ArrayList<String>(properties.stringPropertyNames());
  		if (isLogInSortedOrder()) {
  			Collections.sort(keys);
  		}
  		for (String key : keys) {
 			String value = properties.getProperty(key);
 			sb.append(getLogEntry(key, value) + "\n");
 		}
 		return sb.toString();
 	}
 
 	protected boolean isMatch(Pattern[] patterns, String key) {
 		for (Pattern pattern : patterns) {
 			Matcher matcher = pattern.matcher(key);
 			if (matcher.matches()) {
 				return true;
 			}
 		}
 		return false;
 	}
 
 	public String getLogValue(String key, String value) {
 		if (isFlattenPropertyValues()) {
 			value = value.replace(LF, getLinefeedReplacement());
 			value = value.replace(CR, getCarriageReturnReplacement());
 		}
 		if (isTrimPropertyValues()) {
 			value = value.trim();
 		}
 		if (!isMaskPropertyValues()) {
 			return value;
 		}
 		boolean match = isMatch(getPatterns(), key);
 		if (match) {
 			return getMaskValue();
 		} else {
 			return value;
 		}
 	}
 
 	public boolean isFlattenPropertyValues() {
 		return flattenPropertyValues;
 	}
 
 	public void setFlattenPropertyValues(boolean flattenPropertyValues) {
 		this.flattenPropertyValues = flattenPropertyValues;
 	}
 
 	public boolean isMaskPropertyValues() {
 		return maskPropertyValues;
 	}
 
 	public void setMaskPropertyValues(boolean maskPropertyValues) {
 		this.maskPropertyValues = maskPropertyValues;
 	}
 
 	public String getMaskValue() {
 		return maskValue;
 	}
 
 	public void setMaskValue(String maskValue) {
 		this.maskValue = maskValue;
 	}
 
 	public String getLinefeedReplacement() {
 		return linefeedReplacement;
 	}
 
 	public void setLinefeedReplacement(String linefeedReplacement) {
 		this.linefeedReplacement = linefeedReplacement;
 	}
 
 	public String getCarriageReturnReplacement() {
 		return carriageReturnReplacement;
 	}
 
 	public void setCarriageReturnReplacement(String carriageReturnReplacement) {
 		this.carriageReturnReplacement = carriageReturnReplacement;
 	}
 
 	public boolean isTrimPropertyValues() {
 		return trimPropertyValues;
 	}
 
 	public void setTrimPropertyValues(boolean trimPropertyValues) {
 		this.trimPropertyValues = trimPropertyValues;
 	}
 
 	public String[] getMaskExpressions() {
 		return maskExpressions;
 	}
 
 	public Pattern[] getPatterns() {
 		return patterns;
 	}
 
 	public boolean isLogInSortedOrder() {
 		return logInSortedOrder;
 	}
 
 	public void setLogInSortedOrder(boolean logInSortedOrder) {
 		this.logInSortedOrder = logInSortedOrder;
 	}
 
 }