package org.kuali.common.util.spring.env;
   
   import java.io.File;
   
   import org.kuali.common.util.Assert;
   import org.kuali.common.util.Mode;
   import org.kuali.common.util.ModeUtils;
   import org.springframework.core.env.Environment;
   
  /**
   * <p>
   * By default, an exception is thrown if a value cannot be located (unless a default value has been supplied).
   * </p>
   * 
   * <p>
   * By default, an exception is thrown if any placeholders cannot be resolved in any string values.
   * </p>
   * 
   * <p>
   * By default, environment variables are automatically checked if a normal property value cannot be found.
   * 
   * For example, given the key <code>db.vendor</code> the service will also automatically check <code>env.DB_VENDOR</code>
   * </p>
   * 
   * @deprecated Use BasicEnvironmentService instead
   */
  @Deprecated
  public class DefaultEnvironmentService implements EnvironmentService {
  
  	public static final boolean DEFAULT_CHECK_ENVIRONMENT_VARIABLES = true;
  	public static final boolean DEFAULT_RESOLVE_STRINGS = true;
  	public static final Mode DEFAULT_MISSING_PROPERTY_MODE = Mode.ERROR;
  	public static final String ENV_PREFIX = "env";
  
  	private final boolean checkEnvironmentVariables;
  	private final boolean resolveStrings;
  	private final Environment env;
  	private final Mode missingPropertyMode;
  
  	public DefaultEnvironmentService(Environment env) {
  		this(env, DEFAULT_CHECK_ENVIRONMENT_VARIABLES, DEFAULT_RESOLVE_STRINGS, DEFAULT_MISSING_PROPERTY_MODE);
  	}
  
  	public DefaultEnvironmentService(Environment env, boolean checkEnvironmentVariables) {
  		this(env, checkEnvironmentVariables, DEFAULT_RESOLVE_STRINGS, DEFAULT_MISSING_PROPERTY_MODE);
  	}
  
  	public DefaultEnvironmentService(Environment env, boolean checkEnvironmentVariables, boolean resolveStrings, Mode missingPropertyMode) {
  		Assert.noNulls(env, missingPropertyMode);
  		this.env = env;
  		this.missingPropertyMode = missingPropertyMode;
  		this.checkEnvironmentVariables = checkEnvironmentVariables;
  		this.resolveStrings = resolveStrings;
  	}
  
  	@Override
  	public boolean containsProperty(String key) {
  		Assert.noBlanks(key);
  		return env.containsProperty(key);
  	}
  
  	@Override
  	public <T> T getProperty(EnvContext<T> context) {
  
  		// If context is null, we have issues
  		Assert.noNulls(context);
  
  		// Extract a value from Spring's Environment abstraction
  		T springValue = getSpringValue(context.getKey(), context.getType());
  
  		// If that value is null, use whatever default value they gave us (this might also be null)
  		T returnValue = (springValue == null) ? context.getDefaultValue() : springValue;
  
  		// If we could not locate a value, we may need to error out
  		if (returnValue == null) {
  			ModeUtils.validate(missingPropertyMode, getMissingPropertyMessage(context.getKey()));
  		}
  
  		// Return the value we've located
  		return returnValue;
  	}
  
  	protected String getMissingPropertyMessage(String key) {
  		if (checkEnvironmentVariables) {
  			String envKey = EnvUtils.getEnvironmentVariableKey(key);
  			return "No value for [" + key + "] or [" + envKey + "]";
  		} else {
  			return "No value for [" + key + "]";
  		}
  	}
  
  	protected <T> T getSpringValue(String key, Class<T> type) {
  		T value = env.getProperty(key, type);
  		if (value == null && checkEnvironmentVariables) {
  			String envKey = EnvUtils.getEnvironmentVariableKey(key);
  			return env.getProperty(envKey, type);
  		} else {
  			return value;
  		}
 	}
 
 	protected <T> Class<T> getSpringValueAsClass(String key, Class<T> type) {
 		Class<T> value = env.getPropertyAsClass(key, type);
 		if (value == null && checkEnvironmentVariables) {
 			String envKey = EnvUtils.getEnvironmentVariableKey(key);
 			return env.getPropertyAsClass(envKey, type);
 		} else {
 			return value;
 		}
 	}
 
 	@Override
 	public <T> Class<T> getClass(String key, Class<T> type) {
 		return getClass(key, type, null);
 	}
 
 	@Override
 	public <T> Class<T> getClass(String key, Class<T> type, Class<T> defaultValue) {
 		Class<T> springValue = getSpringValueAsClass(key, type);
 		Class<T> returnValue = (springValue == null) ? defaultValue : springValue;
 
 		// If we could not locate a value, we may need to error out
 		if (returnValue == null) {
 			ModeUtils.validate(missingPropertyMode, getMissingPropertyMessage(key));
 		}
 
 		// Return what we've got
 		return returnValue;
 	}
 
 	@Override
 	public String getString(String key) {
 		return getString(key, null);
 	}
 
 	@Override
 	public String getString(String key, String defaultValue) {
 		String string = getProperty(EnvContext.newString(key, defaultValue));
 		if (resolveStrings) {
 			return env.resolveRequiredPlaceholders(string);
 		} else {
 			return string;
 		}
 	}
 
 	@Override
 	public Boolean getBoolean(String key) {
 		return getBoolean(key, null);
 	}
 
 	@Override
 	public Boolean getBoolean(String key, Boolean defaultValue) {
 		return getProperty(EnvContext.newBoolean(key, defaultValue));
 	}
 
 	@Override
 	public File getFile(String key) {
 		return getFile(key, null);
 	}
 
 	@Override
 	public File getFile(String key, File defaultValue) {
 		return getProperty(EnvContext.newFile(key, defaultValue));
 	}
 
 	@Override
 	public Integer getInteger(String key, Integer defaultValue) {
 		return getProperty(EnvContext.newInteger(key, defaultValue));
 	}
 
 	@Override
 	public Integer getInteger(String key) {
 		return getInteger(key, null);
 	}
 
 	public boolean isCheckEnvironmentVariables() {
 		return checkEnvironmentVariables;
 	}
 
 	public boolean isResolveStrings() {
 		return resolveStrings;
 	}
 
 	public Environment getEnv() {
 		return env;
 	}
 
 	public Mode getMissingPropertyMode() {
 		return missingPropertyMode;
 	}
 
 	@Override
 	public <T> T getProperty(String key, Class<T> type, T provided) {
 		return getProperty(EnvContext.newCtx(key, type, provided));
 	}
 
 	@Override
 	public <T> T getProperty(String key, Class<T> type) {
 		return getProperty(EnvContext.newCtx(key, type, null));
 	}
 
 }