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;

         }

 }